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);
    }
}