集合总结

2.Collection集合

• 相同点 都是容器,可以存储多个数据
• 不同点
• 数组的长度是不可变的,集合的长度是可变的

• 数组可以存基本数据类型和引用数据类型 集合只能存引用数据类型,如果要存基本数据类型,需要存对应的包装类

• Collection集合概述

• 是单例集合的顶层接口,它表示一组对象,这些对象也称为Collection的元素
• JDK 不提供此接口的任何直接实现.它提供更具体的子接口(如Set和List)实现
• 创建Collection集合的对象
• 多态的方式
• 具体的实现类ArrayList

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

• 迭代器介绍

• 迭代器,集合的专用遍历方式
• Iterator
• Iterator中的常用方法 ​ boolean hasNext(): 判断当前位置是否有元素可以被取出​ E next(): 获取当前位置的元素,将迭代器对象移向下一个索引位置
• 示例代码

  public class MyCollectionDemo3 {
      public static void main(String[] args) {
          Collection<String> list = new ArrayList<>();
          list.add("a");
          list.add("b");
          list.add("c");
          list.add("d");
          list.add("e");
  ​
  

• 迭代器原理

• 迭代器中删除的方法 ​ void remove(): 删除迭代器对象当前指向的元素

  
  public class IteratorDemo2 {
      public static void main(String[] args) {
          ArrayList<String> list = new ArrayList<>();
          list.add("a");
          list.add("b");
          list.add("b");
          list.add("c");
          list.add("d");
  ​
          Iterator<String> it = list.iterator();
          while(it.hasNext()){
              String s = it.next();
              if("b".equals(s)){
  

• 介绍

• 它是JDK5之后出现的,其内部原理是一个Iterator迭代器
• 实现Iterable接口的类才可以使用迭代器和增强for
• 简化数组和Collection集合的遍历
• 格式 ​ for(集合/数组中元素的数据类型 变量名 : 集合/数组名) { ​ // 已经将当前遍历到的元素封装到变量中了,直接使用变量即可 ​ }
• 代码

  
  public class MyCollectonDemo1 {
      public static void main(String[] args) {
          ArrayList<String> list =  new ArrayList<>();
          list.add("a");
          list.add("b");
          list.add("c");
          list.add("d");
          list.add("e");
          list.add("f");
  ​
  

• 注意事项

  
  public class MyCollectionDemo7 {
      public static void main(String[] args) {
  ​
          ArrayList<String> list =  new ArrayList<>();
          list.add("a");
          list.add("b");
          list.add("c");
          list.add("d");
  ​
  

• 三种遍历集合方式总结
• 如果需要操作索引，使用普通for循环
• 如果在遍历的过程中需要删除元素，请使用迭代器
• 如果仅仅只是遍历，则使用增强for

public class MyCollectionDemo8 {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();
​
        list.add(new Student("小皮同学",23));
        list.add(new Student("小路同学",31));
        list.add(new Student("小贾同学",33));
​

3.List集合

• List集合的概述
• 有序集合,这里的有序指的是存取顺序
• 用户可以精确控制列表中每个元素的插入位置,用户可以通过整数索引访问元素,并搜索列表中的元素
• 与Set集合不同,列表通常允许重复的元素
• List集合的特点
• 存取有序
• 可以重复
• 有索引

• 示例代码

  
  public class MyListDemo1 {
      public static void main(String[] args) {
          List<String> list = new ArrayList<>();
          list.add("aaa");
          list.add("bbb");
          list.add("ccc");
  ​
          Iterator<String> it = list.iterator();
          while(it.hasNext()){
              String s = it.next();
              System.out.println(s);
          }
  ​
          System.out.println("---------------------");
  ​
          for (String s : list) {
              System.out.println(s);
          }
      }
  }

  ​

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

• 示例代码

  
  public class MyListDemo2 {
      public static void main(String[] args) {
          List<String> list = new ArrayList<>();
          list.add("aaa");
          list.add("bbb");
          list.add("ccc");
          method1(list);
          method2(list);
          method3(list);
          method4(list);
      }
  ​
      private static void method4(List<String> list) {
  

4.数据结构

• 栈结构 ​ 先进后出

• 队列结构 ​ 先进先出

• 数组结构 ​ 查询快、增删慢 arraylist

• 链表结构 ​ 查询慢、增删快 添加元素 *查询元素

5.List集合的实现类

• ArrayList集合 ​ 底层是数组结构实现，查询快、增删慢
• ArrayList源码分析 ArrayList使用无参构造创建时，数组的长度为零。当ArrayList第一次添加元素时，创建一个新的长度为10的数组，后续每次数组要进行扩容时，每次扩大为原来的1.5倍。
• LinkedList集合 ​ 底层是链表结构实现，查询慢、增删快

• LinkedList示例代码

  
  public class MyLinkedListDemo3 {
      public static void main(String[] args) {
          LinkedList<String> list = new LinkedList<>();
          list.add("aaa");
          list.add("bbb");
          list.add("ccc");
  ​
          for (int i = 0; i < list.size(); i++) {
              System.out.println(list.get(i));
          }
          System.out.println("-------------------------");
          Iterator<String> it = list.iterator();
          while (it.hasNext()) {
              String s = it.next();
              System.out.println(s);
          }
          System.out.println("--------------------------");
          for (String s : list) {
              System.out.println(s);
          }
      }
  }

  ​

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

• 示例代码

  
  public class MyLinkedListDemo4 {
      public static void main(String[] args) {
          LinkedList<String> list = new LinkedList<>();
          list.add("aaa");
          list.add("bbb");
          list.add("ccc");
  

6.泛型

• 泛型的介绍 泛型是JDK5中引入的特性，它提供了编译时类型安全检测机制
• 泛型的好处
• 把运行时期的问题提前到了编译期间
• 避免了强制类型转换
• 示例代码

​

7.Set集合

• 不可以存储重复元素
• 存取顺序不一致
• 没有索引,不能使用普通for循环遍历，跟索引相关的方法也没有。

存储字符串并遍历

public class MySet1 {    public static void main(String[] args) {

8.TreeSet集合

• 不可以存储重复元素
• 没有索引
• 不可以重复
• 可以将元素按照规则进行排序
• TreeSet()：根据其元素的自然排序进行排序
• TreeSet(Comparator comparator) ：根据指定的比较器进行排序

存储Integer类型的整数并遍历

public class MyTreeSet1 {
    public static void main(String[] args) {
        TreeSet<Integer> ts = new TreeSet<>();
        ts.add(5);
        ts.add(3);
        ts.add(4);
        ts.add(1);
        ts.add(2);
        System.out.println(ts);
    }
}

• 案例需求
• 存储学生对象并遍历，创建TreeSet集合使用无参构造方法
• 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
• 实现步骤
• 使用空参构造创建TreeSet集合
  • 用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
• 自定义的Student类实现Comparable接口
  • 自然排序，就是让元素所属的类实现Comparable接口，重写compareTo(T o)方法
• 重写接口中的compareTo方法
  • 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写
• 代码实现 学生类

  
  public class Student implements Comparable<Student>{
      private String name;
      private int age;
  ​
      public Student() {
      }
  ​
      public Student(String name, int age) {
          this.name = name;
          this.age = age;
      }
  ​
      public String getName() {
          return name;
      }
  ​
      public void setName(String name) {
          this.name = name;
      }
  ​
      public int getAge() {
          return age;
      }
  ​
      public void setAge(int age) {
          this.age = age;
      }
  ​
  

  测试类

public class MyTreeSet2 {    public static void main(String[] args) {

• 自然排序原理

• 案例需求

• 存储老师对象并遍历，创建TreeSet集合使用带参构造方法
• 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
• 实现步骤
• 用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的
• 比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare(T o1,T o2)方法
• 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写
• 代码实现 老师类

public class Teacher {    private String name;    private int age;​    public Teacher() {    }​    public Teacher(String name, int age) {        this.name = name;        this.age = age;    }​    public String getName() {        return name;    }​    public void setName(String name) {        this.name = name;    }​    public int getAge() {        return age;    }​    public void setAge(int age) {        this.age = age;    }​

测试类

public class MyTreeSet4 {    public static void main(String[] args) {

• 两种比较方式小结
• 自然排序: 自定义类实现Comparable接口,重写compareTo方法,根据返回值进行排序
• 比较器排序: 创建TreeSet对象的时候传递Comparator的实现类对象,重写compare方法,根据返回值进行排序
• 在使用的时候,默认使用自然排序,当自然排序不满足现在的需求时,使用比较器排序
• 两种方式中关于返回值的规则
• 如果返回值为负数，表示当前存入的元素是较小值，存左边
• 如果返回值为0，表示当前存入的元素跟集合中元素重复了，不存
• 如果返回值为正数，表示当前存入的元素是较大值，存右边
• 二种方式如何确定是升序还是降序
• 自然排序

public int compareTo(Student o) {

​
– 比较器排序

public int compare(String o1, String o2) {

• 示例代码 存入四个字符串，”c” “ab” “df” “qwer”按照长度排序，如果长度一样则按照首字母排序

public class MyTreeSet5 {    public static void main(String[] args) {

​

9.数据结构

• 关于树的一些专业名称
• 节点: 在树结构中,每一个元素称之为节点
• 根节点：最顶层的节点，我们叫做根节点
• 度: 每一个节点的子节点数量称之为度

• 树高：一个树的层数，我们叫做树高

• 二叉树的特点 任意一个节点的度要小于等于2，即任意一个节点最多只能有二个子节点。

• 二叉树结构图

• 二叉查找树的特点

• 每一个节点上最多有两个子节点
• 左子树上所有节点的值都小于根节点的值
• 右子树上所有节点的值都大于根节点的值
• 二叉查找树结构图
• 二叉查找树和二叉树对比结构图
• 二叉查找树添加节点规则
• 小的存左边
• 大的存右边

• 一样的不存

• 平衡二叉树的特点

• 是一个二叉查找树
• 任意节点的左右两个子树的高度差不超过1
• 平衡二叉树旋转
• 旋转触发时机
  • 当添加一个节点之后,该树不再是一颗平衡二叉树
• 左旋
  • 就是将根节点的右侧往左拉,原先的右子节点变成新的父节点,并把多余的左子节点出让,给已经降级的根节点当右子节点
• 右旋
  • 就是将根节点的左侧往右拉,左子节点变成了新的父节点,并把多余的右子节点出让,给已经降级根节点当左子节点
• 平衡二叉树和二叉查找树对比结构图
• 平衡二叉树旋转的四种情况
• 左左
  • 左左: 当根节点左子树的左子树有节点插入,导致二叉树不平衡
  • 如何旋转: 直接对整体进行右旋即可
• 左右
  • 左右: 当根节点左子树的右子树有节点插入,导致二叉树不平衡
  • 如何旋转: 先在左子树对应的节点位置进行左旋,在对整体进行右旋
• 右右
  • 右右: 当根节点右子树的右子树有节点插入,导致二叉树不平衡
  • 如何旋转: 直接对整体进行左旋即可

• 右左

  • 右左:当根节点右子树的左子树有节点插入,导致二叉树不平衡
  • 如何旋转: 先在右子树对应的节点位置进行右旋,在对整体进行左旋

• 红黑树的特点

• 是一个二叉查找树
• 每一个节点可以是红或者黑
• 红黑树不是高度平衡的,它的平衡是通过”自己的红黑规则”进行实现的
• 红黑树的红黑规则有哪些
• 每一个节点或是红色的,或者是黑色的
• 根节点必须是黑色
• 如果一个节点没有子节点或者父节点,则该节点相应的指针属性值为Nil,这些Nil视为叶节点,每个叶节点(Nil)是黑色的
• 如果某一个节点是红色,那么它的子节点必须是黑色(不能出现两个红色节点相连 的情况)
• 对每一个节点,从该节点到其所有后代叶节点的简单路径上,均包含相同数目的黑色节点
• 红黑树添加节点的默认颜色
• 添加节点时,默认为红色,效率高
• 红黑树添加节点后如何保持红黑规则
• 根节点位置
  • 直接变为黑色
• 非根节点位置
  • 父节点为黑色
  • 不需要任何操作,默认红色即可
  • 父节点为红色
  • 叔叔节点为红色
    1. 将”父节点”设为黑色,将”叔叔节点”设为黑色
    2. 将”祖父节点”设为红色
    3. 如果”祖父节点”为根节点,则将根节点再次变成黑色
  • 叔叔节点为黑色
    1. 将”父节点”设为黑色
    2. 将”祖父节点”设为红色
    3. 以”祖父节点”为支点进行旋转

10.HashSet集合

• 底层数据结构是哈希表
• 存取无序
• 不可以存储重复元素
• 没有索引,不能使用普通for循环遍历

public class HashSetDemo {    public static void main(String[] args) {

• 哈希值简介 ​ 根据对象的地址值或者属性值计算出来的一个int类型的整数
• 如何获取哈希值 ​ Object类中的public int hashCode()：返回对象的哈希码值
• 哈希值的特点
• 如果没有重写hashcode方法，那么就根据对象的地址值进行计算哈希值 针对同一个对象，返回的哈希值相同，针对不同的对象，返回的哈希值不同
• 如果重写了hashcode方法，一般都是根据对象的属性值来进行重写。 如果不同对象的属性值相同，那么它们的哈希值也是一样的。
• 示例代码

public class HashSetDemo2 {    public static void main(String[] args) {        Student s1 = new Student("张三",23);        Student s2 = new Student("张三",23);        Student s3 = new Student("李四",24);​

​

• JDK1.8以前 ​ 数组 + 链表 ​ 默认长度16，加载因子0.75 ，16*0.75=12 每次扩容2倍 头插法
• JDK1.8以后 ​ 尾插法（七上八下）
• 节点个数小于等于8个 ​ 数组 + 链表

• 节点个数大于8个 ​ 数组 + 红黑树

• 案例需求

• 创建一个存储学生对象的集合，存储多个学生对象，使用程序实现在控制台遍历该集合
• 要求：学生对象的成员变量值相同，我们就认为是同一个对象
• 代码实现 学生类

public class Student {    private String name;    private int age;​    public Student() {    }​    public Student(String name, int age) {        this.name = name;        this.age = age;    }​    public String getName() {        return name;    }​    public void setName(String name) {        this.name = name;    }​    public int getAge() {        return age;    }​    public void setAge(int age) {        this.age = age;    }​

测试类

• 总结 ​ HashSet集合存储自定义类型元素,要想实现元素的唯一,要求必须重写hashCode方法和equals方法

11.Map集合

• interface Map
• 键不可以重复,值可以重复
• 键和值一一对应，通过一个键能找到对应的值

• 键和值这个整体，我们称之为键值对，或者又叫做Entry对象

• 示例代码

  
  public class MyMap1 {
      public static void main(String[] args) {
          Map<String,String> map = new HashMap<>();
  ​
          map.put("itheima001","小智");
          map.put("itheima002","小美");
          map.put("itheima003","大胖");
  ​
          System.out.println(map);
      }
  }

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

• 示例代码

  
  public class MyMap2 {
      public static void main(String[] args) {
          Map<String,String> map = new HashMap<>();
          map.put("itheima001","小智");
          map.put("itheima002","小美");
          map.put("itheima003","大胖");
          map.put("itheima004","小黑");
          map.put("itheima005","大师");
  ​
  

• 方法介绍方法名说明V get(Object key)根据键获取值Set 获取所有键的集合Set 获取所有键值对对象的集合K getKey()通过entry对象获取键V getValue()通过entry对象获取值

• 遍历思路

• 我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合
  • 把所有的丈夫给集中起来
  • 遍历丈夫的集合，获取到每一个丈夫
  • 根据丈夫去找对应的妻子
• 步骤分析
• 获取所有键的集合。用keySet()方法实现
• 遍历键的集合，获取到每一个键。用增强for实现
• 根据键去找值。用get(Object key)方法实现
• 代码实现

public class MyMap3 {    public static void main(String[] args) {

• 遍历思路
• 我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合
  • 获取所有结婚证的集合
  • 遍历结婚证的集合，得到每一个结婚证
  • 根据结婚证获取丈夫和妻子
• 步骤分析
• 获取所有键值对对象的集合
  • Set
• 遍历键值对对象的集合，得到每一个键值对对象
  • 用增强for实现，得到每一个Map.Entry
• 根据键值对对象获取键和值
  • 用getKey()得到键
  • 用getValue()得到值
• 代码实现

public class MyMap4 {    public static void main(String[] args) {

12.HashMap集合

• HashMap底层是哈希表结构的
• 依赖hashCode方法和equals方法保证键的唯一
• 如果键要存储的是自定义对象，需要重写hashCode和equals方法

• 底层结构与HashSet一样

• 案例需求

• 创建一个HashMap集合，键是学生对象(Student)，值是居住地 (String)。存储多个元素，并遍历。
• 要求保证键的唯一性：如果学生对象的成员变量值相同，我们就认为是同一个对象
• 代码实现 学生类

public class Student {    private String name;    private int age;​    public Student() {    }​    public Student(String name, int age) {        this.name = name;        this.age = age;    }​    public String getName() {        return name;    }​    public void setName(String name) {        this.name = name;    }​    public int getAge() {        return age;    }​    public void setAge(int age) {        this.age = age;    }​

测试类

public class MyMap5 {
    public static void main(String[] args) {
        HashMap<Student,String> hm = new HashMap<>();
​
        Student s1 = new Student("xiaohei",23);
        Student s2 = new Student("dapang",24);
        Student s3 = new Student("xiaomei",22);
​
        hm.put(s1,"江苏");
        hm.put(s2,"北京");
        hm.put(s3,"天津");
​

13.TreeMap集合

• TreeMap底层是红黑树结构
• 依赖自然排序或者比较器排序,对键进行排序

• 如果键存储的是自定义对象,需要实现Comparable接口或者在创建TreeMap对象时候给出比较器排序规则

• 案例需求

• 创建一个TreeMap集合,键是学生对象(Student),值是籍贯(String),学生属性姓名和年龄,按照年龄进行排序并遍历
• 要求按照学生的年龄进行排序,如果年龄相同则按照姓名进行排序
• 代码实现 学生类

  
  public class Student implements Comparable<Student>{
      private String name;
      private int age;
  ​
      public Student() {
      }
  ​
      public Student(String name, int age) {
          this.name = name;
          this.age = age;
      }
  ​
      public String getName() {
          return name;
      }
  ​
      public void setName(String name) {
          this.name = name;
      }
  ​
      public int getAge() {
          return age;
      }
  ​
      public void setAge(int age) {
          this.age = age;
      }
  ​
  

  测试类

public class Test {    public static void main(String[] args) {

14.可变参数

• 可变参数介绍

• JDK5新特性

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

• 方法的参数类型已经确定,个数不确定,我们可以使用可变参数
• 可变参数定义格式

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

• 可变参数的注意事项
• 这里的变量其实是一个数组
• 如果一个方法有多个参数，包含可变参数，可变参数要放在最后
• 可变参数的基本使用

15.创建不可变集合

• 方法介绍

• JDK9新特性

• 在List、Set、Map接口中,都存在of方法,可以创建一个不可变的集合

• 这个集合不能添加,不能删除,不能修改
• 但是可以结合集合的带参构造,实现集合的批量添加
• 在Map接口中,还有一个ofEntries方法可以提高代码的阅读性
• 首先会把键值对封装成一个Entry对象,再把这个Entry对象添加到集合当中
• 示例代码

public class MyVariableParameter4 {    public static void main(String[] args) {

16.集合总结

• 扩展一 LinkedHashSet和LinkedHashMap: 可以实现去重并且存取有序的效果

      HashMap<String, Integer> hashMap = new HashMap<>();
      hashMap.put("fff", 1);
      hashMap.put("aaa", 1);
      hashMap.put("bbb", 1);
      hashMap.put("ccc", 1);
      hashMap.put("ddd", 1);
      System.out.println("hashMap" + hashMap);
​
​
      LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<>();
      linkedHashMap.put("fff", 1);
      linkedHashMap.put("aaa", 1);
      linkedHashMap.put("bbb", 1);
      linkedHashMap.put("ccc", 1);
      linkedHashMap.put("ddd", 1);
      System.out.println("linkedHashMap" + linkedHashMap);
  }

​- 扩展二​

Original: https://www.cnblogs.com/shiguangzheng/p/16621399.html
Author: 彭然
Title: 集合总结