java常用工具集合

1、集合和数组的区别：

①集合中只能存储引用型数据，如果存储基本类型会自动装箱；数组既可以存储基本类型也可以存储引用类型的数据。

②集合长度不固定，可任意扩充；数组长度固定。

2、Java的集合体系：

（1）单列集合：（顶层是Collection接口）

①List集合（list是接口，要想使用里面的方法必须创建子类对象） ：最常用的子类是ArrayList

List集合中元素可重复，有序。通过创建子类对象使用：List list=new ArrayList();

eg:向List集合中添加三个元素并遍历打印

分析：向集合中添加元素的方法：add()、遍历集合的方式：for()、获取集合中元素个数的方法：size()

package com.wang.list;

import java.util.ArrayList;
import java.util.List;
/*List是接口，要创建子类对象
使用集合的步骤：创建集合对象-》创建元素对象-》将元素对象添加到集合对象中-》遍历集合
 */
public class ListDemo01 {
    public static void main(String[] args) {
        //往List集合中添加3个学生对象，然后遍历
        //创建集合对象
        List list=new ArrayList();
        //创建元素对象
        Student s1=new Student("王迎婧",22);
        Student s2=new Student("王迎",21);
        Student s3=new Student("王",20);
        Student s4=new Student("王",20);
        //将元素添加到集合对象中
        //add方法返回是否添加成功的布尔值
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);
        //直接打印集合,怎样添加的就怎样打印，并且可重复
        System.out.println(list);
        //获取索引为2的元素
        System.out.println(list.get(2));
        Object obj=list.get(2);
        System.out.println(obj);
        //获取集合的长度
        int a=list.size();
        System.out.println(a);
        //遍历集合
        for(int i=0;i<list.size();i++){
            System.out.println("索引为"+i+"的元素是："+list.get(i));
        }
        //增强for循环
        for(Object x:list){//集合中添加的元素都是Object类型
            System.out.println(x);
        }
    }
}
class Student{
    private String name;
    private int age;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }
    public Student(){};
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }

    @Override
    public String toString() {
        return "Student{name=‘"+getName()+"‘,age="+getAge()+"}";
 }}

增强for循环和迭代器



增强for循环的格式：for(数据类型 变量名：数组或集合对象){//循环体，变量即元素}




iter回车：增强for循环的快捷方式




        for(Object x:list){//集合中添加的元素都是Object类型            System.out.println(x);        }




增强for循环的底层依据的是迭代器（Iterator）：增强for就是迭代器的简写形式




迭代器： 对过程的重复，称为迭代。迭代器是遍历Collection集合的通用方式，可以在对集合遍历的同时进行添            加、删除等操作




迭代器的常用方法： next():返回迭代的下一个元素对象




hasnext():判断迭代器中是否有下一个元素，如果仍有元素可以迭代，则返回true




迭代器的使用步骤： 通过集合对象获取其对应的迭代器对象->判断迭代器中是否有元素->如果有，获取元素




普通的迭代器在遍历集合的同时不能添加或删除元素，否则会报：并发修改异常




列表迭代器在遍历集合的同时可以修改集合中的元素，必须使用列表迭代器中的方法




eg：通过迭代器遍历List集合




package com.wang.list;




import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;




//通过迭代器遍历List集合
public class ListDemo02 {
    public static void main(String[] args) {
        List list=new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        //根据集合对象获取其对应的迭代器对象
        Iterator i=list.iterator();
        //迭代器中是否有元素




while (i.hasNext()){//如果有元素就一直迭代
            //如果有就获取这个元素
            Object o=i.next();
            //数据类型都是字符串，可以向下转型
            String s=(String)o;
            System.out.println(s);
        }
        System.out.println("==========================================");
        //判断集合中如果有字符串"b",有就在后面添加一个新的字符串"java"
        //添加、删除操作需要列表迭代器
        ListIterator lis=list.listIterator();
        while(lis.hasNext()){
            String s=(String)lis.next();
            if("b".equals(s)){//常量与变量比较时，常量写到前面，变量写在括号中。
                            //常量调用方法，即使常量是null也能规避控指针异常
                //能走到这里说明集合中有字符串"b"
                lis.add("java");
            }
            System.out.println(s);
        }
        System.out.println(list);
    }
}


泛型


什么是泛型：泛指任意类型，又叫参数化类型（ParameterizedType），对具体类型的使用起到辅助作用，类似于方法的参数。


泛型一般只与集合类结合使用。


集合类泛型：如果在集合对象上写了一个泛型，就表示该集合中存放指定类型的元素。


例如：在list集合上加上泛型String：List <String> list=new ArrayList<>();说明在这个集合中只能添加字符串类型的数据。


package com.wang.list;?import java.util.ArrayList;import java.util.List;?//演示泛型public class ListDemo03 {    public static void main(String[] args) {      //不使用泛型的集合      List list1=new ArrayList();      list1.add("a");//添加数据为Object类型      list1.add("b");      list1.add("c");      list1.add("d");     // list1.add(10);//可以添加整数型，但在遍历时不能向下转型，会报类型转换异常        for (Object o : list1) {            String s=(String)o;            System.out.println(s);        }        System.out.println("==============================");      //泛型，避免类型转换的问题        List <String> list2=new ArrayList<>();        list2.add("d");//泛型是什么类型，就只能添加什么类型的数据        list2.add("e");        list2.add("f");        for (String s : list2) {            System.out.println(s);        }    }}?


collection工具类


针对及集合进行操作的工具类。


成员方法： sort(List<T>): 根据元素的自然顺序（0-9、a-z），将指定列表按升序排序


max(Collection<T>):返回集合中的最大元素


reverse(List<T>):反转集合中的元素


shuffle(List<T>):使用默认的随机源随机置换指定的列表


package com.wang.collection;?import java.util.ArrayList;import java.util.Collection;import java.util.Collections;import java.util.List;?/*sort(List<T>): 根据元素的自然顺序（0-9、a-z），将指定列表按升序排序  max(Collection<T>):返回集合中的最大元素  reverse(List<T>):反转集合中的元素  shuffle(List<T>):使用默认的随机源随机置换指定的列表 */public class CollectionDemo01 {    public static void main(String[] args) {        List <Integer>list=new ArrayList<>();        list.add(1);        list.add(3);        list.add(3);        list.add(5);        list.add(2);        list.add(2);        list.add(4);        System.out.println("没有操作前，集合中的数据是"+list);        System.out.println("==============================");        //获取集合中最大元素,max是Collection中的静态方法，可通过类名直接调用        Integer max= Collections.max(list);        System.out.println("集合中的最大元素为："+max);       /* //对集合中的数据进行反转        Collections.reverse(list);        System.out.println("反转后集合中数据为："+list);        //对集合进行升序排列        Collections.sort(list);        System.out.println("排序后的集合数据为："+list);        //对集合中的数据降序排序,先升序排列，再反转        Collections.reverse(list);        System.out.println("集合中元素降序排序："+list);?        */        //随机置换，相当于洗牌        Collections.shuffle(list);        System.out.println("随机置换后的结果为："+list);        Collections.shuffle(list);        System.out.println("随机置换后的结果为："+list);?  }}


②Set ：


特点：不可重复、无序


Set接口要创建子类对象使用，最常用子类：HashSet


eg：向Set集合中添加五个元素，并遍历打印


package com.wang.set;?import javax.swing.text.html.HTMLDocument;import java.util.HashSet;import java.util.Iterator;import java.util.Objects;import java.util.Set;?public class SetDemo01 {    public static void main(String[] args) {        //向Set集合中添加5个元素，并遍历打印        Set <Student> set=new HashSet<>();        Student s1=new Student("wang",22);        Student s2=new Student("wangy",21);        Student s3=new Student("wangyi",20);        Student s4=new Student("wangyin",19);        Student s5=new Student("wang",22);        set.add(s1);        set.add(s2);        set.add(s3);        set.add(s4);        set.add(s5);        /*为什么打印结果没有去重？        因为Set集合保证元素的唯一性依赖：equals()和HashCode()，两个方法。现在没有在学生类中重写这两个方法，        所以默认调用的是Object类中的这两个方法，而Object类中的equals方法默认比较的是地址值是否相同?        解决方法：在Student中重写equals和HashCode方法         */             //通过迭代器遍历Set集合        //1、通过集合对象获取其对应的迭代器对象        Iterator<Student> it=set.iterator();        //2、判断迭代器中是否有元素        while (it.hasNext()){            //3、如果有，就获取元素           Student s= it.next();            System.out.println(s);        }        System.out.println("===========================");        for (Student student : set) {            System.out.println(student);        }    }}class Student{    private String name;    private int age;    public Student(){}    public Student(String name,int age){        this.name=name;        this.age=age;    }?    public void setName(String name) {        this.name = name;    }?    public String getName() {        return name;    }?    public void setAge(int age) {        this.age = age;    }?    public int getAge() {        return age;    }?    @Override    public String toString() {        return "Student{name=‘"+getName()+"‘,age="+getAge()+"}";    }?    @Override    public boolean equals(Object o) {        if (this == o) return true;        if (o == null || getClass() != o.getClass()) return false;        Student student = (Student) o;        return age == student.age &&                Objects.equals(name, student.name);    }?    @Override    public int hashCode() {        return Objects.hash(name, age);    }}


双列集合 ：（顶层是Map接口：key、value）


Map ：Map接口最常用子类：HashMap


特点：双列集合，元素由键值对（Entry）构成


键用key表示，值用value表示   key不可以重复，value可以重复


Map<T1,T2> map=new HashMap<>();


T1表示键的类型，T2表示值的类型


eg：向Map集合中添加三个元素，并遍历打印


向Map集合中添加元素的方法为：put()


遍历集合的方式：获取所有的key：keySet(),遍历keySet，通过key获取value：get()


步骤：1、创建集合对象 Map <Integer,Student> map=new HashMap<>()；


2、分别创建三个Student对象


3、使用put方法将Student对象添加到集合中


4、获取所有的key，并使用迭代器迭代


package com.wang.map;?import java.util.*;?public class MapDemo01 {    public static void main(String[] args) {        Map<Integer,Student> map=new HashMap<>();        Student s1=new Student("wang",22);        Student s2=new Student("wangy",21);        Student s3=new Student("wang",22);        /*添加元素，元素第一次添加，返回null，重复添加，会用新值覆盖旧值，并返回旧值        Student stu1=map.put(1,s1);        System.out.println(stu1);        Student stu2=map.put(1,s2);        System.out.println(stu2);         */        map.put(1,s1);        map.put(2,s2);        map.put(3,s3);        System.out.println(map);        //根据键，获取值        Student stu3=map.get(2);        System.out.println("key:"+2+",value:"+stu3);        System.out.println("===============================");        //遍历集合,双列集合不能直接遍历，要先转化为单列集合        //1、获取所有键的集合：keySet()        Set<Integer> keys=map.keySet();        //2、遍历所有的键，获取到每一个键        //迭代器        Iterator<Integer> it=keys.iterator();        while (it.hasNext()){            Integer key=it.next();        //3、根据键，获取指定的值 get()        Student value=map.get(key);            System.out.println("key:"+key+",value:"+value);        }        System.out.println("=================================");        //增强for        for (Integer key : keys) {            Student value=map.get(key);            System.out.println("key:"+key+",value:"+value);        }    }}class Student{    private String name;    private int age;    public Student(){}    public Student(String name,int age){        this.name=name;        this.age=age;    }?    public void setName(String name) {        this.name = name;    }?    public String getName() {        return name;    }?    public void setAge(int age) {        this.age = age;    }?    public int getAge() {        return age;    }?    @Override    public String toString() {        return "Student{name=‘"+getName()+"‘,age="+getAge()+"}";    }?    @Override    public boolean equals(Object o) {        if (this == o) return true;        if (o == null || getClass() != o.getClass()) return false;        Student student = (Student) o;        return age == student.age &&                Objects.equals(name, student.name);    }?    @Override    public int hashCode() {        return Objects.hash(name, age);    }}


 



原文地址：https://www.cnblogs.com/wyj96/p/11903535.html
				


				
时间： 2024-08-24 05:09:03 

		


		


	

	
	

		


		
java常用工具集合的相关文章


								

		

			

                Java常用工具类集合
			

		

		

									

				数据库连接工具类 仅仅获得连接对象 ConnDB.java package com.util; import java.sql.Connection; import java.sql.DriverManager; /** * 数据库连接工具类——仅仅获得连接对象 * */ public class ConnDB { private static Connection conn = null; private static final String DRIVER_NAME = "com.mysql			

		

	

				

		

			

                java  常用工具
			

		

		

									

				System:类中的属性方法都是静态的.无法实例化 err:"标准"错误输出流 in:"标准"输入流 out:"标准"输出流 常见方法: long currentTimeMillis();获取当前时间的毫秒值 Properties    getProperties(); 获取系统属性 Properties集合中存储的都是String类型的键和值. Runtime:没有构造方法摘要,说明该类不可以创建对象. 方法又是非静态,说明该类提供静态返回该类			

		

	

				

		

			

                java常用工具类（java技术交流群57388149）
			

		

		

									

				package com.itjh.javaUtil; import java.util.ArrayList; import java.util.List; /** * * String工具类. <br> * * @author 宋立君 * @date 2014年06月24日 */ public class StringUtil { private static final int INDEX_NOT_FOUND = -1; private static final String EMPTY =			

		

	

				

		

			

                java常用工具方法2
			

		

		

									

				/* * Copyright 2005 Joe Walker * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LI			

		

	

				

		

			

                Java 常用List集合使用场景分析
			

		

		

									

				Java 常用List集合使用场景分析 过年前的最后一篇,本章通过介绍ArrayList,LinkedList,Vector,CopyOnWriteArrayList 底层实现原理和四个集合的区别.让你清楚明白,为什么工作中会常用ArrayList和CopyOnWriteArrayList?了解底层实现原理,我们可以学习到很多代码设计的思路,开阔自己的思维.本章通俗易懂,还在等什么,快来学习吧! 知识图解: 技术:ArrayList,LinkedList,Vector,CopyOnWriteAr			

		

	

				

		

			

                java常用工具类（三）—— Excel 操作工具
			

		

		

									

				import org.apache.poi.hssf.usermodel.HSSFWorkbook; import org.apache.poi.ss.usermodel.*; import org.apache.poi.xssf.usermodel.XSSFWorkbook; import java.io.File; import java.io.FileInputStream; import java.io.IOException; import java.io.InputStream; i			

		

	

				

		

			

                项目经验分享——Java常用工具类集合 转
			

		

		

									

				http://blog.csdn.net/xyw591238/article/details/51678525 写在前面 本文涉及的工具类部分是自己编写,另一部分是在项目里收集的.工具类涉及数据库连接.格式转换.文件操作.发送邮件等等.提高开发效率,欢迎收藏与转载. 数据库连接工具类 数据库连接工具类——仅仅获得连接对象 ConnDB.java [java] package com.util; import java.sql.Connection; import java.sql.DriverM			

		

	

				

		

			

                [转]Java常用工具类集合
			

		

		

									

				转自:http://blog.csdn.net/justdb/article/details/8653166 数据库连接工具类——仅仅获得连接对象 ConnDB.java package com.util; import java.sql.Connection; import java.sql.DriverManager; /** * 数据库连接工具类——仅仅获得连接对象 * */ public class ConnDB { private static Connection conn = nu			

		

	

				

		

			

                Java常用工具——java集合
			

		

		

									

				一.ArrayList package com.imooc.set; import java.util.ArrayList; import java.util.List; public class ArrayListDemo { public static void main(String[] args) { // 用ArrayList存储编程语言的名称,并输出. //名称包括”Java”.”C”.”C++“.”Go”和”Swift” List list=new ArrayList(); lis