java集合&List& Set&Map

集合

集合类的特点：提供一种存储空间可变的存储模型，存储的数据容量可以随时发生改变

集合类的体系图

Collection集合

0.1Collection集合概述

• 是单例集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素

• JDK 不提供此接口的任何直接实现，它提供更具体的子接口（如Set和List）实现

//创建Collection集合的对象
        Collection<String> c = new ArrayList<String>();

        //添加元素：boolean add(E e)
        c.add("hello");
        c.add("world");
        c.add("java");

        //输出集合对象
        System.out.println(c);

0.2Collection集合的常用方法

方法名	说明
boolean add(E e)	添加元素
boolean remove(Object o)	从集合中移除指定的元素
void clear()	清空集合中的元素
boolean contains(Object o)	判断集合中是否存在指定的元素
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合中元素的个数

        //创建Collection集合的对象
        Collection<String> c = new ArrayList<String>();
        //添加元素
        c.add("小明");
        c.add("小红");
        c.add("小防");
        c.add("小明");
        System.out.println(c);
        //移除
        c.remove("小明");
        System.out.println(c);
        c.remove("小明");
        System.out.println(c);
        //清空
        c.clear();
        System.out.println(c);
        //是否存在
        System.out.println(c.contains("小明"));
        c.add("红");
        System.out.println(c.contains("红"));
        //是否空
        System.out.println(c.isEmpty());
        //集合长度
        System.out.println(c.size());

0.3Collection集合的遍历

• 迭代器的介绍
  • 迭代器，集合的专用遍历方式
  • Iterator iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到
  • 迭代器是通过集合的iterator()方法得到的，所以我们说它是依赖于集合而存在的

        //Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到
        Iterator<String> it = c.iterator();

        //用while循环改进元素的判断和获取
        while (it.hasNext()) {//判断下一个元素是否存在
            String s = it.next();
            System.out.println(s);
        }

一、List集合

1.1List集合概述和特点【记忆】

• List集合概述
  • 有序集合(也称为序列)，用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索在这里插入代码片引访问元素，并搜索列表中的元素
  • 与Set集合不同，列表通常允许重复的元素
• List集合特点
  • 有索引
  • 可以存储重复元素
  • 元素存取有序

1.2List集合的特有方法【应用】

方法名	描述
void add(int index,E element)	在此集合中的指定位置插入指定的元素
E remove(int index)	删除指定索引处的元素，返回被删除的元素
E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
E get(int index)	返回指定索引处的元素

        List<String> list=new ArrayList<>();
        list.add("a小红");
        list.add("c小绿");
        list.add("d小黑");
        list.add("a小红");
        System.out.println(list);
        //插入
        list.add(2,"小黄");
        System.out.println(list);
        //删除
        list.remove(2);
        System.out.println(list);
        //修改，返回被修改元素
        System.out.println(list.set(1,"小朋友"));
        System.out.println(list);
        //返回索引元素
        System.out.println(list.get(1));

        //迭代器方式遍历
        Iterator<String> it = list.iterator();
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }

1.3并发修改异常【应用】

• 出现的原因

  ​ 迭代器遍历的过程中，通过集合对象修改了集合中的元素，造成了迭代器获取元素中判断预期修改值和实际修改值不一致，则会出现：ConcurrentModificationException

• 解决的方案

  ​ 用for循环遍历，然后用集合对象做对应的操作即可

1.4列表迭代器【应用】

• ListIterator介绍

  • 通过List集合的listIterator()方法得到，所以说它是List集合特有的迭代器
  • 用于允许程序员沿任一方向遍历的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置

1.5数据结构之栈和队列【记忆】

• 栈结构

  ​ 先进后出

• 队列结构

  ​ 先进先出

1.6数据结构之数组和链表【记忆】

• 数组结构

  ​ 查询快、增删慢

• 队列结构

  ​ 查询慢、增删快

1.7List集合子类的特点【记忆】

• ArrayList集合

  ​ 底层是数组结构实现，查询快、增删慢

• LinkedList集合

  ​ 底层是链表结构实现，查询慢、增删快

1.8三种遍历方式

        //迭代器：集合特有的遍历方式
        Iterator<Student> it = array.iterator();
        while (it.hasNext()) {
            Student s = it.next();
            System.out.println(s.getName() + "," + s.getAge());
        }
        System.out.println("--------");

        //普通for：带有索引的遍历方式
        for(int i=0; i<array.size(); i++) {
            Student s = array.get(i);
            System.out.println(s.getName() + "," + s.getAge());
        }
        System.out.println("--------");

        //增强for：最方便的遍历方式
        for(Student s : array) {
            System.out.println(s.getName() + "," + s.getAge());
        }

1.9LinkedList集合的特有功能【应用】

• 特有方法

  方法名	说明
  public void addFirst(E e)	在该列表开头插入指定的元素
  public void addLast(E e)	将指定的元素追加到此列表的末尾
  public E getFirst()	返回此列表中的第一个元素
  public E getLast()	返回此列表中的最后一个元素
  public E removeFirst()	从此列表中删除并返回第一个元素
  public E removeLast()	从此列表中删除并返回最后一个元素

        LinkedList<String> list=new LinkedList<>();
        list.add("a小红");
        list.add("c小绿");
        list.add("d小黑");
        list.add("a小红");
        System.out.println(list);
        //表头插入
        list.addFirst("小哈");
        System.out.println(list);
        //末尾插入
        list.addLast("小嘿");
        System.out.println(list);
        //返回第一个元素
        System.out.println(list.getFirst());
        //返回最后一个元素
        System.out.println(list.getLast());
        //删除第一个元素，返回第一个元素
        list.removeFirst();
        System.out.println(list);
        System.out.println(list.removeFirst());
        System.out.println(list);
        //删除最后一个元素，返回最后一个元素
        System.out.println(list.removeLast());
        System.out.println(list);

二、Set集合

2.1Set集合概述和特点【应用】

• Set集合的特点
  • 元素存取无序
  • 没有索引、只能通过迭代器或增强for循环遍历
  • 不能存储重复元素

2.2哈希值【理解】

• 哈希值简介

  ​ 是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值

• 如何获取哈希值

  ​ Object类中的public int hashCode()：返回对象的哈希码值

• 哈希值的特点

  • 同一个对象多次调用hashCode()方法返回的哈希值是相同的
  • 默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象的哈希值相同

2.3HashSet集合概述和特点【应用】

• HashSet集合的特点

  • 底层数据结构是哈希表
  • 对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
  • 没有带索引的方法，所以不能使用普通for循环遍历
  • 由于是Set集合，所以是不包含重复元素的集合

2.4HashSet集合保证元素唯一性源码分析【理解】

• HashSet集合保证元素唯一性的原理

  ​ 1.根据对象的哈希值计算存储位置

  ​ 如果当前位置没有元素则直接存入

  ​ 如果当前位置有元素存在，则进入第二步

  ​ 2.当前元素的元素和已经存在的元素比较哈希值

  ​ 如果哈希值不同，则将当前元素进行存储

  ​ 如果哈希值相同，则进入第三步

  ​ 3.通过equals()方法比较两个元素的内容

  ​ 如果内容不相同，则将当前元素进行存储

  ​ 如果内容相同，则不存储当前元素

2.5LinkedHashSet集合概述和特点【应用】

• LinkedHashSet集合特点

  • 哈希表和链表实现的Set接口，具有可预测的迭代次序
  • 由链表保证元素有序，也就是说元素的存储和取出顺序是一致的
  • 由哈希表保证元素唯一，也就是说没有重复的元素

2.6TreeSet集合概述和特点【应用】

• TreeSet集合概述

  • 元素有序，可以按照一定的规则进行排序，具体排序方式取决于构造方法
    • TreeSet()：根据其元素的自然排序进行排序
    • TreeSet(Comparator comparator) ：根据指定的比较器进行排序
  • 没有带索引的方法，所以不能使用普通for循环遍历
  • 由于是Set集合，所以不包含重复元素的集合

2.7泛型概述和好处【理解】

• 泛型概述

  ​ 是JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型

  它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型。这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口

• 泛型定义格式

  • <类型>：指定一种类型的格式。这里的类型可以看成是形参
  • <类型1,类型2…>：指定多种类型的格式，多种类型之间用逗号隔开。这里的类型可以看成是形参
  • 将来具体调用时候给定的类型可以看成是实参，并且实参的类型只能是引用数据类型

• 泛型的好处

  • 把运行时期的问题提前到了编译期间
  • 避免了强制类型转换

2.8泛型类【应用】

• 定义格式

  修饰符 class 类名<类型> {  }
  

public class Generic<T> {
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

2.9泛型方法【应用】

• 定义格式

  修饰符 <类型> 返回值类型 方法名(类型 变量名) {  }
  

public class Generic {
    public <T> void show(T t) {
        System.out.println(t);
    }
}

2.10泛型接口【应用】

• 定义格式

  修饰符 interface 接口名<类型> {  }
  

public interface Generic<T> {
    void show(T t);
}

public class GenericImpl<T> implements Generic<T> {
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

//测试类
public class GenericDemo {
    public static void main(String[] args) {
        Generic<String> g1 = new GenericImpl<String>();
        g1.show("林青霞");

        Generic<Integer> g2 = new GenericImpl<Integer>();
        g2.show(30);
    }
}

2.11类型通配符【应用】

• 类型通配符的作用

  ​ 为了表示各种泛型List的父类，可以使用类型通配符

• 类型通配符的分类

  • 类型通配符：<?>
    • List<?>：表示元素类型未知的List，它的元素可以匹配任何的类型
    • 这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中
  • 类型通配符上限：<? extends 类型>
    • List<? extends Number>：它表示的类型是Number或者其子类型
  • 类型通配符下限：<? super 类型>
    • List<? super Number>：它表示的类型是Number或者其父类型

2.12可变参数【应用】

• 可变参数介绍

  ​ 可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了

• 可变参数定义格式

  修饰符 返回值类型 方法名(数据类型… 变量名) {  }
  

• 可变参数的注意事项

  • 这里的变量其实是一个数组
  • 如果一个方法有多个参数，包含可变参数，可变参数要放在最后

    public static int sum(int... a) {
        int sum = 0;
        for(int i : a) {
            sum += i;
        }
        return sum;
    }

2.13可变参数的使用【应用】

• Arrays工具类中有一个静态方法：

  • public static List asList(T… a)：返回由指定数组支持的固定大小的列表
  • 返回的集合不能做增删操作，可以做修改操作

• List接口中有一个静态方法：

  • public static List of(E… elements)：返回包含任意数量元素的不可变列表
  • 返回的集合不能做增删改操作

• Set接口中有一个静态方法：

  • public static Set of(E… elements) ：返回一个包含任意数量元素的不可变集合
  • 在给元素的时候，不能给重复的元素
  • 返回的集合不能做增删操作，没有修改的方法

三、Map集合

3.1Map集合概述和特点【理解】

• Map集合概述

  interface Map<K,V>  K：键的类型；V：值的类型
  

• Map集合的特点

  • 键值对映射关系
  • 一个键对应一个值
  • 键不能重复，值可以重复
  • 元素存取无序

        //创建集合对象
        Map<String,String> map = new HashMap<String,String>();

3.2Map集合的基本功能【应用】

• 方法介绍

  方法名	说明
  V put(K key,V value)	添加元素
  V remove(Object key)	根据键删除键值对元素
  void clear()	移除所有的键值对元素
  boolean containsKey(Object key)	判断集合是否包含指定的键
  boolean containsValue(Object value)	判断集合是否包含指定的值
  boolean isEmpty()	判断集合是否为空
  int size()	集合的长度，也就是集合中键值对的个数

        Map<Integer,String> map=new HashMap<>();
        //添加
        map.put(1,"小明");
        map.put(2,"小红");
        map.put(3,"小黑");
        map.put(3,"小黄");
        map.put(1,"小明");
        System.out.println(map);
        //删除
        map.remove(1);
        System.out.println(map);
        //判断是否包含键
        System.out.println(map.containsKey(1));
        System.out.println(map.containsKey(2));
        //判断是否包含值
        System.out.println(map.containsValue("小黄"));
        System.out.println(map.containsValue("好好"));
        System.out.println("--------");
        //判断是否为空
        System.out.println(map.isEmpty());
        //集合的长度
        System.out.println(map.size());
        //清空
        map.clear();
        System.out.println(map);
        System.out.println(map.isEmpty());

3.3Map集合的获取功能【应用】

• 方法介绍

  方法名	说明
  V get(Object key)	根据键获取值
  Set keySet()	获取所有键的集合
  Collection values()	获取所有值的集合
  Set<Map.Entry<K,V>> entrySet()	获取所有键值对对象的集合

        Map<Integer,String> map=new HashMap<>();
        //添加
        map.put(1,"小明");
        map.put(2,"小红");
        map.put(3,"小黑");
        //根据键获取值
        System.out.println(map.get(2));
        //获取所有键的集合
        Set<Integer> integers = map.keySet();
        System.out.println(integers);
        //获取所有值的集合
        Collection<String> values = map.values();
        System.out.println(values);
        //获取所有键值对对象的集合
        Set<Map.Entry<Integer, String>> entries = map.entrySet();
        System.out.println(entries);

3.4遍历

        //获取所有键的集合。用keySet()方法实现
        Set<String> keySet = map.keySet();
        //遍历键的集合，获取到每一个键。用增强for实现
        for (String key : keySet) {
            //根据键去找值。用get(Object key)方法实现
            String value = map.get(key);
            System.out.println(key + "," + value);
        }

            //获取所有键值对对象的集合
            Set<Map.Entry<String, String>> entrySet = map.entrySet();
            //遍历键值对对象的集合，得到每一个键值对对象
            for (Map.Entry<String, String> me : entrySet) {
                //根据键值对对象获取键和值
                String key = me.getKey();
                String value = me.getValue();
                System.out.println(key + "," + value);
            }

3.5Collections概述和使用【应用】

• Collections类的作用

  ​ 是针对集合操作的工具类

• Collections类常用方法

  方法名	说明
  public static void sort(List list)	将指定的列表按升序排序
  public static void reverse(List<?> list)	反转指定列表中元素的顺序
  public static void shuffle(List<?> list)	使用默认的随机源随机排列指定的列表

        List<Integer> list = new ArrayList<Integer>();
        list.add(3);
        list.add(31);
        list.add(5);
        list.add(20);
        list.add(30);
        list.add(3333);
        list.add(58);
        System.out.println(list);
        //反转
        Collections.reverse(list);
        System.out.println(list);
        //升序排序
        Collections.sort(list);
        System.out.println(list);
        //随机排列
        Collections.shuffle(list);
        System.out.println(list);