Java——常用工具_集合

集合简介

集合，简称集，是用来存储多个元素的容器。

集合和数组的区别：

java的集合体系：
单列集合（Collection）:List：ArrayList、Set：HashSet
双列集合（Map：key, value）：Map：HashMap

List集合的特点和应用

特点：可重复、有序（存取顺序相同）
应用：List list = new ArrayList():

package com.collect;

import java.util.ArrayList;
import java.util.List;

public class test01 {
    public static void main(String[] args) {
        //使用集合的步骤：
        //1. 创建集合对象 2. 创建元素对象 3.将元素对象添加到集合对象中 4.遍历集合对象
        //往List集合中添加三个学生对象，然后遍历

        //1. 创建集合对象
        List list = new ArrayList();
        //2. 创建元素对象
        Student s1 = new Student("乔峰", 41);
        Student s2 = new Student("乔峰", 41);
        Student s3 = new Student("虚竹", 38);
        Student s4 = new Student("段誉", 26);
        //3. 将元素对象添加到集合对象中
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);

        //直接打印集合
        System.out.println(list);
        //获取索引为2的元素
        Object obj = list.get(2);
        System.out.println("索引为2的元素是：" + obj);
        //获取集合中的元素个数
        System.out.println("集合的长度为：" + list.size());
        
        //4.遍历集合
        for (int i = 0; i <list.size(); i++) {
            Object obj2 = list.get(i);
            System.out.println("索引为 " + i + "的元素是：" + obj2);
        }
    }
}

增强for循环和迭代器

1.迭代器是遍历Collection集合的通用方式，可以在对集合遍历的同时进行添加、删除等操作。
2.迭代器的常用方法
next()：返回迭代的下一个元素对象
hasNext()：如果仍有元素可以迭代，则返回true

使用步骤：
1.根据集合对象获取其对象的迭代器对象；
2.判断迭代器中是否有元素
3.如果有就获取元素

package com.collect;

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

public class test02 {
    public static void main(String[] args) {
        //通过迭代器遍历list集合
        //创建集合对象
        List list = new ArrayList();
        //添加元素对象
        list.add("a");
        list.add("b");
        list.add("c");
        //迭代器遍历
        //根据集合对象获取其对象的迭代器对象
        Iterator it = list.iterator();
        //判断迭代器中是否有元素
        while (it.hasNext()) {
            //如果有元素就获取
//            Object obj = it.next();
//            System.out.println(obj);
            String s = (String)it.next();
//            if ("b".equals(s)){ //这样写可以规避：空指针异常
//                list.add("z");  //这样写不行，并发修改异常 需要使用列表迭代器
//            }
            System.out.println(s);
        }

        //使用列表迭代器修改list
        //根据集合对象获取列表迭代器对象
        ListIterator lit = list.listIterator();
        //判断迭代器中是否有元素
        while (lit.hasNext()) {
            //获取元素
            String s = (String)lit.next();
            if ("b".equals(s)) {
                lit.add("z");
            }
            System.out.println(s);
        }
        System.out.println("新集合的值:" + list);  //新集合的值:[a, b, z, c]
    }
}

列表迭代器是List体系独有的遍历方式，可以在对集合遍历的同时进行添加、删除等操作，但必须通过调用列表迭代器的方法来实现。

泛型简介

泛型即泛指任意类型，又叫参数化类型，对具体类型的使用起到辅助作用，类似于方法的参数。泛型一般只和集合类相结合使用。
例：集合类泛型，表示该集合中存放指定类型的元素。
好处：类型安全，避免了类型转换
例：List list = new ArrayList<>();

package com.collect;

import java.util.ArrayList;
import java.util.List;

public class test03 {
    public static void main(String[] args) {
        //正常
        List list1 = new ArrayList();
        list1.add("a");
        list1.add("b");
        list1.add("c");
        for (Object obj : list1) {
            String s  = (String)obj;
            System.out.println(s);
        }
        //泛型
        List<String> list2 = new ArrayList<>();
        list2.add("abc");
        list2.add("bcd");
        list2.add("cde");
        for (String s: list2) {
            System.out.println(s);
        }
    }
}

Collections工具类

Collections工具类是针对集合进行操作的工具类。
成员方法：
sort(List)：根据元素的自然顺序，将指定列表按升序排序
max(Collection)：返回集合的最大元素
reverse(List)：反转list集合元素
shuffle(List)：使用默认的随机源随机置换指定的列表

package com.collect;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

public class test04 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(13);
        list.add(3);
        list.add(4);
        list.add(1);
        list.add(99);
        //获取集合中的最大元素
        int max = Collections.max(list);
        System.out.println(max);
        //升序排列
        Collections.sort(list);
        //反转
        Collections.reverse(list);
        //随机打乱
        Collections.shuffle(list);
        System.out.println(list);
    }
}

Set集合的特点

特点：不可重复、无序

package com.collect;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class test05 {
    public static void main(String[] args) {
        //往set集合添加5个学生对象，然后遍历
        //1. 创建集合对象
        Set<Student> set = new HashSet<>();
        //2.创建元素对象
        Student s1 = new Student("乔峰", 41);
        Student s2 = new Student("虚竹", 38);
        Student s3 = new Student("段誉", 26);
        Student s4 = new Student("乔峰", 41);
        Student s5 = new Student("虚竹", 38);

        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);
        set.add(s5);
        System.out.println(set);
        //打印出的结果并没有"去重"，因为equals() 和 hashCode() 两个方法没有在Student类里重写
        //重写后打印出的结果只有三条

        //迭代器遍历集合
        Iterator<Student> it = set.iterator();
        while (it.hasNext()) {
            Student s = it.next();
            System.out.println(s);
        }
        //增强for遍历set集合  快捷键：iter
        for (Student student : set) {
            System.out.println(student);
        }
    }
}

Map集合的特点和应用

1. 特点：双列集合，元素由键值对构成，键不可以重复，值可以重复
2. 应用：Map<T1, T2> map = new HashMap<>();
3. 成员方法：
   （1）V put(K key, V value)：添加元素（键值对的形式）；
   （2）V get(Object key)：根据键获取其对应的值
   （3）Set keySet()：获取所有键的集合

package com.collect;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class test06 {
    public static void main(String[] args) {
        //往Map集合中添加3个学生对象，然后打印
        //1.创建集合对象
        Map<Integer, Student> map = new HashMap<>();
        //2.创建元素对象
        Student s1 = new Student("张三", 23);
        Student s2 = new Student("李四", 24);
        Student s3 = new Student("张三", 23);
        //3.将元素对象添加到集合中
        map.put(1, s1);
        map.put(2, s2);
        map.put(3, s3);
        System.out.println(map);

        //根据键，获取值
        Student stu3 = map.get(3);
        System.out.println("key: " + 2 +", value: " + stu3);

        //遍历集合
        //1. 获取所有键的集合 keySet()
        Set<Integer> keys = map.keySet();
        //2. 遍历所有的键，获取到每一个键   迭代器，增强for
        //获取迭代器对象
        Iterator<Integer> it = keys.iterator();
        while (it.hasNext()) {
            Integer key = it.next();
            //根据键获取值
            Student value = map.get(key);
            System.out.println("key: " + key + " value" + value);
        }
        
        //获取到所有键
        for (Integer key: keys) {
            Student value = map.get(key);
            System.out.println("key: " + key + " value" + value);
        }
    }
}