• Collection集合体系（ArrayList，LinekdList，HashSet，LinkedHashSet，TreeSet，Collections）

    目录

    一.Collection

    二.List集合

    三.ArrayList集合

    四.LinkedList集合

    五.Set集合             

    六.hashSet集合

    七.LinkedHashSet集合

    八.TreeSet集合

    九.集合工具类Collections

    集合体系概述

            单列集合：Collection代表单列集合，每个元素（数据）只包含一个值。

            双列集合：Map代表双列集合，每个元素包含两个值（键值对）。

    单列集合：

            List系列集合：添加的元素是有序、可重复、有索引

                    ArrayList：有序、可重复、有索引

                    LinekdList：有序、可重复、有索引

            Set系列集合：添加的元素是无序、不重复、无索引

                   HashSet：无序、不重复、无索引

                   LinkedHashSet：有序、不重复、无索引

                   TreeSet：按照大小默认升序排序、不重复、无索引

    一.Collection

    为什么要先学Collection的常用方法？

            Collection是单列集合的祖宗，它规定的方法（功能）是全部单列集合都会继承的。

    Collection的常用方法：

    代码展示：

    1. package com.itheima.day06.teacher.g_collection;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.Arrays;
    5. import java.util.Collection;
    6.  
    7. /**
    8.  * Collection常用方法
    9.  */
    10. public class CollectionDemo {
    11.  
    12.     public static void main(String[] args) {
    13.         /*
    14.           Collection 是 ArrayList祖宗
    15.          */
    16. //        Collection con = new ArrayList<>();//多态
    17. //        ArrayList list = new ArrayList<>();//本态
    18.         //采用多态？为什么呢？  多态特点  多态下只能调用 父中定义的功能，不会调用子类特有的。
    19.         // 我们要研究是 共性的功能 使用多态
    20.         Collection con = new ArrayList<>();//多态
    21.         // add()
    22.         con.add("name1");
    23.         con.add("name2");
    24.         con.add("name3");
    25.         con.add("name4");
    26.         System.out.println(con);
    27.         //size() 获取集合长度 元素个数
    28.         System.out.println("集合中有"+con.size()+"个元素");
    29.         // boolean contains(元素)  判断集合中是否包含指定元素
    30.         System.out.println("是否包含张三 "+con.contains("张三"));//false
    31.         System.out.println("是否包含赵四 "+con.contains("赵四"));//true
    32.         //boolean remove(元素)  删除指定元素 返回 是否删除成功
    33.         System.out.println("删除一下:王老七 "+con.remove("王老七"));
    34.         System.out.println(con);
    35.         //情况集合方法 void clear()
    36.         con.clear();
    37.         System.out.println("清空集合之后:"+con);
    38.         // isEmpty() 判断集合是否为空
    39.         System.out.println("con当前是空的吗?"+con.isEmpty());
    40.         // 重写添加数据
    41.         con.add("谢大脚");
    42.         con.add("王小蒙");
    43.         con.add("香秀");
    44.         con.add("王云");
    45.         // Object[] toArray() 变成数组
    46.         Object[] array = con.toArray();
    47.         System.out.println(Arrays.toString(array));
    48.         //扩展一个
    49.  
    50.  
    51.         Collection c1 = new ArrayList<>();//多态
    52.         // add()
    53.         c1.add("name1");
    54.         c1.add("name2");
    55.         c1.add("name3");
    56.         c1.add("name4");
    57.  
    58.         Collection c2 = new ArrayList<>();//多态
    59.         // add()
    60.         c2.add("name1");
    61.         c2.add("name2");
    62.         c2.add("name3");
    63.         c2.add("name4");
    64.  
    65.         c1.addAll(c2);//c2集合内容 批量添加到c1中
    66.         System.out.println(c1);
    67.     }
    68. }

    Collection的遍历方式：

    1.迭代器：

            迭代器是用来遍历集合的专用方式(数组没有迭代器)，在Java中迭代器的代表是Iterator。

            Collection集合获取迭代器的方法  Iterator iterator() 返回集合中的迭代器对象，该迭代器对象默认指向当前集合的第一个元素

            Iterator迭代器中的常用方法:

            boolean hasNext():询问当前位置是否有元素存在，存在返回true ,不存在返回false

            E next():获取当前位置的元素，并同时将迭代器对象指向下一个元素处。

    2.增强for循环：

            格式：for (元素的数据类型 变量名 : 数组或者集合) { }

            增强for可以用来遍历集合或者数组。

            增强for遍历集合，本质就是迭代器遍历集合的简化写法。

    3.lambda表达式

            得益于JDK 8开始的新技术Lambda表达式，出现了一种更简单、更直接遍历集合的方式-Lambda表达式。

            需要使用Collection的如下方法来完成：default void forEach(Consumer action)

            lists.forEach(s -> {System.out.println(s); });

    1. package com.itheima.day06.teacher.g_collection;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.Arrays;
    5. import java.util.Collection;
    6. import java.util.Iterator;
    7.  
    8. public class CollectionDemo2 {
    9.  
    10.     public static void main(String[] args) {
    11.         /*
    12.           Collection 是 ArrayList祖宗
    13.          */
    14. //        Collection con = new ArrayList<>();//多态
    15. //        ArrayList list = new ArrayList<>();//本态
    16.         //采用多态？为什么呢？  多态特点  多态下只能调用 父中定义的功能，不会调用子类特有的。
    17.         // 我们要研究是 共性的功能 使用多态
    18.         Collection con = new ArrayList<>();//多态
    19.         // add()
    20.         con.add("name1");
    21.         con.add("name2");
    22.         con.add("name3");
    23.         con.add("name4");
    24.         System.out.println(con);
    25.         //size() 获取集合长度 元素个数
    26. //        for (int i = 0; i < con.size(); i++) {
    27. //           String s =  con.get(i);//Conllection 认为无索引
    28. //        }
    29.         // Collection集合的遍历 需要借助一个工具 来完成遍历(迭代)
    30.                                   //  迭代器 Interator
    31.         // 每一个集合对象 都有自己的 迭代器。
    32.         // 呼叫迭代器 获取迭代器
    33.         Iterator it = con.iterator();
    34.         // iterator 可以帮助集合完成 元素的获取
    35.         // 迭代器指向第一个元素
    36.  
    37.         while(it.hasNext()){//询问 当前位置是否有元素 有true false
    38.             //再去获取
    39.             String e = it.next();
    40.             System.out.println(e);
    41.  
    42.         }
    43.  
    44.  
    45.     }
    46. }
    47.  
    48. -------------
    49.  
    50. package com.itheima.day06.teacher.g_collection;
    51.  
    52. import java.util.ArrayList;
    53. import java.util.Collection;
    54. import java.util.Iterator;
    55.  
    56. public class CollectionDemo3 {
    57.  
    58.     public static void main(String[] args) {
    59.         /*
    60.           Collection 是 ArrayList祖宗
    61.          */
    62. //        Collection con = new ArrayList<>();//多态
    63. //        ArrayList list = new ArrayList<>();//本态
    64.         //采用多态？为什么呢？  多态特点  多态下只能调用 父中定义的功能，不会调用子类特有的。
    65.         // 我们要研究是 共性的功能 使用多态
    66.         Collection con = new ArrayList<>();//多态
    67.         // add()
    68.         con.add("name1");
    69.         con.add("name2");
    70.         con.add("name3");
    71.         con.add("name4");
    72.         System.out.println(con);
    73.  
    74.          //因为开发中 大量场景都要使用到 集合 都要去完成遍历 所以jdk 升级的时候 做了一个很高明的操作 就是简化迭代器的使用
    75.         /*
    76.            增强for - --单列集合  数组
    78.            for(数据类型 变量名 :被遍历的集合/数组){}
    80.          */
    81. //        for(String s:con){
    82. //            System.out.println(s);
    83. //        }
    84.         //集合.for
    85.         for (String s : con) {
    86.             System.out.println(s);
    87.         }
    88.         //增强for 只适合于获取数据 不适合与修改
    89.  
    90.     }
    91. }
    92.  
    93.  
    94. ----------
    95.  
    96. package com.itheima.day06.teacher.g_collection;
    97.  
    98. import java.util.ArrayList;
    99. import java.util.Collection;
    100. import java.util.function.Consumer;
    101.  
    102. public class CollectionDemo4 {
    103.  
    104.     public static void main(String[] args) {
    105.         /*
    106.           Collection 是 ArrayList祖宗
    107.          */
    108. //        Collection con = new ArrayList<>();//多态
    109. //        ArrayList list = new ArrayList<>();//本态
    110.         //采用多态？为什么呢？  多态特点  多态下只能调用 父中定义的功能，不会调用子类特有的。
    111.         // 我们要研究是 共性的功能 使用多态
    112.         Collection con = new ArrayList<>();//多态
    113.         // add()
    114.         con.add("name1");
    115.         con.add("name2");
    116.         con.add("name3");
    117.         con.add("name4");
    118.         System.out.println(con);
    119.  
    120.        /*
    121.          jdk8提供的 foreach
    122.         */
    123.         con.forEach(new Consumer() {
    124.             @Override
    125.             public void accept(String s) {//s 接收每次得到的数据
    126.                 System.out.println(s);
    127.             }
    128.         });
    129.         System.out.println("=================");
    130.         con.forEach(s -> System.out.println(s));
    131.  
    132.         con.forEach(System.out::println);
    133.     }
    134. }

    二.List集合

           1.List集合因为支持索引，所以多了很多与索引相关的方法

            特有方法:

            

    2.遍历方式:

            1.for循环（因为List集合有索引）

            2.迭代器

            3.增强for循环

            4.Lambda表达式

    1. package com.itheima.day07.teacher.list01;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.List;
    5.  
    6. public class ListDemo {
    7.     /*
    8.      Collection 单列集合顶层接口
    9.         里面定义关于元素的  一些 获取添加删除的通用方法
    10.        --- List 子接口  有序集合
    11.           特点:
    12.              有序  可以重复  有索引
    13.              里面 有写特有和索引相关方法
    14.           增  void add(int index,E e) 往集合指定位置添加元素
    15.           删  E remove(int index) 根据指定索引进行删除  返回被删除元素
    16.           改  E set(int index,E e) 根据索引进行元素替换，返回被替换的元素
    17.           查  E get(int index) 根据索引获取元素
    19.      */
    20.     public static void main(String[] args) {
    21.         // 这是多态写法 因为在多态下只能使用List 接口定义的方法
    22.         List list = new ArrayList<>();
    23.         //添加元素
    24.         list.add("name1");
    25.         list.add("name2");
    26.         list.add("name3");
    27.         list.add("name4");
    28.         System.out.println(list);
    29.         //有序--存取顺序一致。且有索引
    30.         // 索引为3的位置添加一个 真玲
    31.         list.add(3,"真玲");
    32.         System.out.println(list);
    33.         // 删除
    34.         // 删除索引为4的元素
    35.         String remove = list.remove(4);
    36.         System.out.println("删除索引为4的元素:"+remove);
    37.         System.out.println("删除后的集合:"+list);
    38. //        System.out.println(list.remove(4)); 报错  索引越界
    39.         //修改  索引为2的 改为狗蛋
    40.         System.out.println(list.set(2,"狗蛋"));
    41.         System.out.println("修改后的集合:"+list);
    42.         // 获取  索引为1的元素
    43.         System.out.println(list.get(1));
    44.  
    45.  
    46.  
    47.     }
    48. }
    49.  
    50.  
    51. -----------
    52. package com.itheima.day07.teacher.list01;
    53.  
    54. import java.util.ArrayList;
    55. import java.util.Iterator;
    56. import java.util.List;
    57.  
    58. public class ListDemo02 {
    59.  
    60.     public static void main(String[] args) {
    61.         /*
    62.         完成集合的遍历
    63.            遍历方式 四种
    64.          */
    65.         List list  =  new ArrayList<>();
    66.         list.add("name1");
    67.         list.add("name2");
    68.         list.add("name3");
    69.         list.add("name4");
    70.  
    71.         //普通for循环  list集合.fori
    72.         for (int i = 0; i < list.size(); i++) {
    73.             System.out.println(list.get(i));
    74.         }
    75.         System.out.println("===============");
    76.         //迭代器 iterator()
    77.         Iterator it = list.iterator();
    78.         while(it.hasNext()){
    79.             System.out.println(it.next());
    80.         }
    81.         System.out.println("===============");
    82.         //增强for  list集合.for
    83.         for (String s : list) {
    84.             System.out.println(s);
    85.         }
    86.         // lambda 集合.forEach
    87.         list.forEach(s -> System.out.println(s));
    88.         System.out.println("===============");
    89.         list.forEach(System.out::println);
    90.     }
    91. }

    三.ArrayList集合

            1.ArrayList集合底层是基于数组实现的

            2.数组的特点：查询快，增删慢（数组长度固定,增删需要新数组效率低）

            3.ArrayList集合对象的创建和扩容过程

                    1、利用无参构造器创建的集合，会在底层创建一个默认长度为0的数组

                    2、添加第一个元素时，底层会创建一个新的长度为10的数组

                    3、存满时，会扩容1.5倍  

                    4、如果一次添加多个元素，1.5倍还放不下，则新创建数组的长度以实际为准

            4.ArrayList集合适合什么业务场景？不适合什么业务场景?        

                    适合根据索引查询数据的场景或者数据量不是很大的场景

                    不适合数据量很大时又要频繁地进行增删操作的场景

            因为比较常用我单独写了一篇

    四.LinkedList集合

            1.LinkedList集合底层是基于双链表实现的

            2.链表中的结点是独立的对象，在内存中是不连续的，每个结点包含数据值和下一个结点的地址。

            3.链表的特点:查询慢，都要从头开始找，增删快

            4.双链表的特点：

                    每个节点包含数据值和上一个节点的地址以及下一个节点的地址

                    查询慢，增删相对较快，但对首尾元素进行增删改查的速度是极快的

            5.LinkedList新增了：很多首尾操作的特有方法。

                    

            6.LinkedList集合适合需要频繁操作首尾元素的场景，比如栈和队列

            

    1. package com.itheima.day07.teacher.list02;
    2.  
    3. import java.util.LinkedList;
    4.  
    5. public class LikendListDemo01 {
    6.  
    7.     public static void main(String[] args) {
    8.         /*
    9.           用LinkedList模拟 小火车过山洞...模拟 队列结构
    11.            队列结构
    12.               先进先出 FIFO
    14.          */
    15.         LinkedList list = new LinkedList<>();
    16.         //入队 进山洞
    17.         list.addLast("火车头");
    18.         list.addLast("第一节车厢");
    19.         list.addLast("第二节车厢");
    20.         list.addLast("第三节车厢");
    21.         list.addLast("火车尾");
    22.  
    23.         //出山洞
    24.         System.out.println(list.removeFirst());
    25.         System.out.println(list.removeFirst());
    26.         System.out.println(list.removeFirst());
    27.         System.out.println(list.removeFirst());
    28.         System.out.println(list.removeFirst());
    29.  
    30.  
    31.     }
    32. }
    33.  
    34.  
    35. ------------
    36.  
    37. package com.itheima.day07.teacher.list02;
    38.  
    39. import java.util.LinkedList;
    40.  
    41. public class LinkedListDemo02 {
    42.  
    43.     public static void main(String[] args) {
    44.         /*
    45.          模拟弹夹  发射子弹
    46.              栈结构
    47.                特点 先进后出 FILO
    48.          */
    49.         LinkedList danJia = new LinkedList<>();
    50.  
    51.         // 压 子弹
    52.         danJia.addFirst("第一颗子弹");//每次都在最上面
    53.         danJia.addFirst("第二颗子弹");//每次都在最上面
    54.         danJia.addFirst("第三颗子弹");//每次都在最上面
    55.         danJia.addFirst("第四颗子弹");//每次都在最上面
    56.  
    57.         // 射子弹
    58.         System.out.println(danJia.removeFirst());//每次射最上面的
    59.         System.out.println(danJia.removeFirst());
    60.         System.out.println(danJia.removeFirst());
    61.         System.out.println(danJia.removeFirst());
    62.     }
    63. }

            

    五.Set集合             

    整体特点:  无序 ,存取顺序不保证一致； 不重复； 无索引;

    HashSet:  无序、不重复、无索引

    LinkedHashSet:有序、不重复、无索引

    TreeSet：可排序、不重复、无索引

    六.hashSet集合

    1.哈希值：

            1.就是一个int类型的数值，Java中每个对象都有一个哈希值

            2.Java中的所有对象，都可以调用Obejct类提供的hashCode方法，返回该对象自己的哈希值

    2.对象哈希值的特点： 

            同一个对象多次调用hashCode()方法返回的哈希值是相同的。

            不同的对象，它们的哈希值一般不相同，但也有可能会相同(哈希碰撞)。 

    3.HashSet底层基于哈希表实现

            JDK8之前，哈希表 = 数组+链表：

                    1.创建一个默认长度16的数组，默认加载因子为0.75，数组名table

                    2.使用元素的哈希值对数组的长度求余计算出应存入的位置

                    3.判断当前位置是否为null，如果是null直接存入

                    4.如果不为null，表示有元素，则调用equals方法比较

            JDK8开始，哈希表 = 数组+链表+红黑树(一种平衡的二叉树)

                    JDK8开始，当链表长度超过8，且数组长度>=64时，自动将链表转成红黑树

                    JDK8开始后，哈希表中引入了红黑树后，进一步提高了操作数据的性能。

            哈希表是一种增删改查数据性能都较好的结构。

    4.数据结构：树

            二叉查找树：规则：小的往左存，大的往右存，一样的不存

            可能存在的问题：当数据已经是排好序的，导致查询的性能与单链表一样，查询速度变慢！

            平衡二叉树：在满足二叉查找树的大小规则下，让树尽可能矮小，以此提高查数据的性能。

            红黑树：是一种可以自平衡的二叉树，红黑树是一种增删改查数据性能相对都较好的结构

    5.如何让HashSet集合能够实现对内容一样的两个不同对象也能去重复？

            重写hashCode()和equals()方法

    1. package com.itheima.day07.teacher.set02;
    2.  
    3. import java.util.Objects;
    4.  
    5. /**
    6.  * 学术类
    7.  */
    8. public class Student {
    9.     private String name;
    10.     private int age;
    11.     private double height;
    12.  
    13.  
    14.     public Student() {
    15.     }
    16.  
    17.     public Student(String name, int age, double height) {
    18.         this.name = name;
    19.         this.age = age;
    20.         this.height = height;
    21.     }
    22.  
    23.     /**
    24.      * 获取
    25.      * @return name
    26.      */
    27.     public String getName() {
    28.         return name;
    29.     }
    30.  
    31.     /**
    32.      * 设置
    33.      * @param name
    34.      */
    35.     public void setName(String name) {
    36.         this.name = name;
    37.     }
    38.  
    39.     /**
    40.      * 获取
    41.      * @return age
    42.      */
    43.     public int getAge() {
    44.         return age;
    45.     }
    46.  
    47.     /**
    48.      * 设置
    49.      * @param age
    50.      */
    51.     public void setAge(int age) {
    52.         this.age = age;
    53.     }
    54.  
    55.     /**
    56.      * 获取
    57.      * @return height
    58.      */
    59.     public double getHeight() {
    60.         return height;
    61.     }
    62.  
    63.     /**
    64.      * 设置
    65.      * @param height
    66.      */
    67.     public void setHeight(double height) {
    68.         this.height = height;
    69.     }
    70.  
    71.     public String toString() {
    72.         return "Student{name = " + name + ", age = " + age + ", height = " + height + "}";
    73.     }
    74.  
    75.     //利用idea快捷键  hashCode equals
    76.  
    77.     /*
    78.       比较两个对象的内容
    79.      */
    80.     @Override
    81.     public boolean equals(Object o) {
    82.         if (this == o) return true;
    83.         if (o == null || getClass() != o.getClass()) return false;
    84.         Student student = (Student) o;
    85.         return age == student.age && Double.compare(student.height, height) == 0 && Objects.equals(name, student.name);
    86.     }
    87.     /*
    88.      根据属性算哈希值  尽量不一样的属性 值不同 减少哈希碰撞
    89.      */
    90.     @Override
    91.     public int hashCode() {
    92.         return Objects.hash(name, age, height);
    93.     }
    94. }
    95.  
    96.  
    97. ------------
    98. package com.itheima.day07.teacher.set02;
    99.  
    100. import java.util.HashSet;
    101.  
    102. public class HashSetDemo {
    103.  
    104.     public static void main(String[] args) {
    105.         /*
    106.           创建一个学生集合  用来存储不同 学生对象
    107.          */
    108.         HashSet set = new HashSet<>();
    109.         //创建学生对象
    110.         Student stu1 = new Student("小磊",18,1.88);
    111.         Student stu2 = new Student("小鑫",28,1.38);
    112.         Student stu3 = new Student("小哲",22,1.78);
    113.         Student stu4 = new Student("小鑫",28,1.38);
    114.  
    115.         set.add(stu1);
    116.         set.add(stu2);
    117.         set.add(stu3);
    118.         set.add(stu2);
    119.         set.add(stu4);//我们没有重写 hashCode equals的时候可以存储进去的，
    120.             // 原因是 存的时候先调用 hashCode方法(Object--根地址有一定关系) 哈希code不一样.
    121.             // 即使哈希一样,也能存！！没有重写equals 比较的是地址值  不是一个元素。
    122.         /*
    123.            在开发过程中
    124.                是地址值不一样就是不同对象吗？
    125.                其实不尽然，我们开发中认为 两个对象如果 所有属性值都一样 认为是 同一个对象。
    126.                在我们观点里面 stu2 stu4是同一个对象。
    127.                默认情况下没有当成 同一个对象 并没有完成 元素的去重
    128.          如果 想要达到开发标准 两个对象属性值都一样 就是同一个对象怎么做？
    129.             重写
    130.                hashCode()  -- 目的  是要根据内容算哈希值。
    131.                equals()    -- 目的  是进行内容比较。
    132.             重写之后
    133.               stu2 stu4 先算出哈希值 哈希碰撞  位置一样 再进行equals比较 内容一样不存
    134.          */
    135.  
    136.  
    137.         for (Student student : set) {
    138.             System.out.println(student);
    139.         }
    140.         /*
    141.          存储元素原理
    142.              先根据hashcode算出 存储位置
    143.              位置上有元素 就进行equals比较。
    145.          */
    146.     }
    147. }

    七.LinkedHashSet集合

            依然是基于哈希表(数组、链表、红黑树)实现的

            但是，它的每个元素都额外的多了一个双链表的机制记录它前后元素的位置

    八.TreeSet集合

           1. 特点：不重复、无索引、可排序（默认升序排序 ，按照元素的大小，由小到大排序）

            对于数值类型：Integer , Double，默认按照数值本身的大小进行升序排序。

            对于字符串类型：默认按照首字符的编号升序排序。

            2.底层是基于红黑树实现的排序。

            3.TreeSet集合中对自定义类型元素排序方案：

            方式一：让自定义的类（如学生类）实现Comparable接口，重写里面的compareTo方法来指定比较规则。

            方式二：通过调用TreeSet集合有参数构造器，可以设置Comparator对象（比较器对象，用于指定比较规则)

           

    1. package com.itheima.day07.teacher.set03;
    2.  
    3. /**
    4.     学生类
    5. */
    6.  
    7. public class Student implements Comparable {
    8.     private String name;
    9.     private int age;
    10.     private double height;
    11.  
    12.  
    13.     public Student() {
    14.     }
    15.  
    16.     public Student(String name, int age, double height) {
    17.         this.name = name;
    18.         this.age = age;
    19.         this.height = height;
    20.     }
    21.  
    22.     /**
    23.      * 获取
    24.      * @return name
    25.      */
    26.     public String getName() {
    27.         return name;
    28.     }
    29.  
    30.     /**
    31.      * 设置
    32.      * @param name
    33.      */
    34.     public void setName(String name) {
    35.         this.name = name;
    36.     }
    37.  
    38.     /**
    39.      * 获取
    40.      * @return age
    41.      */
    42.     public int getAge() {
    43.         return age;
    44.     }
    45.  
    46.     /**
    47.      * 设置
    48.      * @param age
    49.      */
    50.     public void setAge(int age) {
    51.         this.age = age;
    52.     }
    53.  
    54.     /**
    55.      * 获取
    56.      * @return height
    57.      */
    58.     public double getHeight() {
    59.         return height;
    60.     }
    61.  
    62.     /**
    63.      * 设置
    64.      * @param height
    65.      */
    66.     public void setHeight(double height) {
    67.         this.height = height;
    68.     }
    69.  
    70.     public String toString() {
    71.         return "Student{name = " + name + ", age = " + age + ", height = " + height + "}";
    72.     }
    73.  
    74.  
    75.     @Override
    76.     public int compareTo(Student o) {
    77.         return this.age-o.age;//前-后 升序
    78.     }
    79. }
    80.  
    81.  
    82. -------------
    83. package com.itheima.day07.teacher.set03;
    84.  
    85.  
    86. import java.util.Comparator;
    87. import java.util.TreeSet;
    88.  
    89. public class TreeSetDemo {
    90.     /*
    91.       TreeSet
    92.         底层是一个 二叉排序树
    93.            遵循特点
    94.              小的存左边 大的存右边 一样的不存
    95.         里面的存储的元素必须具备 ！！排序功能！！ 元素之间有大小关系
    96.      */
    97.     public static void main(String[] args) {
    98.  
    99.         TreeSet set1 = new TreeSet<>();
    100.         set1.add(13);
    101.         set1.add(15);
    102.         set1.add(12);
    103.         set1.add(33);
    104.         set1.add(26);
    105.         set1.add(13);
    106.         set1.add(14);
    107.  
    108.         System.out.println(set1);
    109.         /*
    110.           TreeSet去重原则  一样的不存
    111.           存完之后元素进行排序
    112.             是因为 存储的元素类型有排序规则
    113.                implements Comparable
    114.                实现 Comparable 代表有了排序的规则 所以可以使用TreeSet存储
    115.             TreeSet 去重的原理
    116.                 是排序的规则 如果一样就不存。
    117.          */
    118.  
    119.         System.out.println("==========");
    120.        TreeSet  set2 = new TreeSet<>();
    121.        set2.add("cba");
    122.        set2.add("cbb");
    123.        set2.add("aba");
    124.        set2.add("bbb");
    125.        set2.add("cbb");
    126.        System.out.println(set2);
    127.  
    128.     }
    129. }
    130.  
    131.  
    132. -------------
    133. package com.itheima.day07.teacher.set03;
    134.  
    135.  
    136. import java.util.Comparator;
    137. import java.util.TreeSet;
    138.  
    139. public class TreeSetDemo01 {
    140.  
    141.     /*
    142.       开发中不建议 用TreeSet存储自定义类型，因为会根据只定义排序内容进行去重，与实际开发不符。
    143.         如果执意要用 你就得对所有的 属性进行排序比较 规则
    145.       如果要用TreeSet存自定义类型
    146.          1:自定义类型 实现 Comparable接口  实现排序规则。
    147.          2:在 TreeSet 构造中 写出临时的排序规则 传递规则Comparator接口。
    149.      */
    150.     public static void main(String[] args) {
    151.  
    152.         //创建学生对象
    153.        Student stu1 = new Student("小磊",18,1.88);
    154.        Student stu2 = new Student("小鑫",28,1.38);
    155.        Student stu3 = new Student("小哲",22,1.78);
    156.        Student stu4 = new Student("小迪",28,1.68);
    157.       //创建 TreeSet集合
    158.        TreeSet set = new TreeSet<>(new Comparator() {
    159.            @Override
    160.            public int compare(Student o1, Student o2) {
    161.                return o2.getAge()-o1.getAge();//按照年龄降序
    162.            }
    163.        });
    164.         //存元素
    165.         set.add(stu1);
    166.         set.add(stu2);
    167.         set.add(stu3);
    168.         set.add(stu4);
    169.  
    170.         for (Student student : set) {
    171.             System.out.println(student);
    172.         }
    173.  
    174.     }
    175. }
    176.  
    177.

    Collection集合使用小结：

            1、如果希望记住元素的添加顺序，需要存储重复的元素，又要频繁的根据索引查询数据?
                    用ArrayList集合(有序、可重复、有索引)，底层基于数组的。(常用)
            2、如果希望记住元素的添加顺序，且增删首尾数据的情况较多?
                    用LinkedList集合(有序、可重复、有索引)，底层基于双链表实现的。
            3.如果不在意元素顺序，也没有重复元素需要存储，只希望增删改查都快?
                    用HashSet集合(无序，不重复，无索引)，底层基于哈希表实现的。(常用)
            4.如果希望记住元素的添加顺序，也没有重复元素需要存储，且希望增删改查都快?
                    用LinkedHashSet集合(有序，不重复，无索引)，底层基于哈希表和双链表，
            5.如果要对元素进行排序，也没有重复元素需要存储?且希望增删改查都快?
                    用Treeset集合，基于红黑树实现。

    集合的并发修改异常：
            使用迭代器遍历集合时，又同时在删除集合中的数据，程序就会出现并发修改异常的错误"王麻子”);("小李子");由于增强for循环遍历集合就是迭代器遍历集合的简化写法，因此，使用增强for循环遍历("李爱花");在同时("张全蛋");("晓李");删除集合中的数据时，程序也会出现并发修改异常的错误。("李玉刚");


    怎么保证遍历集合同时删除数据时不出bug?
    使用迭代器遍历集合，但用迭代器自己的删除方法删除数据即可
    如果能用for循环遍历时:可以倒着遍历并删除;或者从前往后遍历，但删除元素后做i--操作

    九.集合工具类Collections

            Collections代表集合工具类，提供的都是静态方法，用来操作集合元素的。

            常用静态方法：

    public static void sort(List list):

                    数值型的List集合，按照值特性排序，默认升序

                    字符串的List集合，按照字符串元素的首字母编号排序。默认升序

                    对于自定义类型的集合，List ,默认报错的解决方法

                            解决方式一：让学生类实现比较规则Comparable接口。重写比较方法。

                            解决方式二：可以让sort方法自带一个比较器

                    

    1. package com.itheima.day07.teacher.other;
    2.  
    3. import java.util.ArrayList;
    4. import java.util.Iterator;
    5. import java.util.List;
    6.  
    7. public class EditException {
    8.    /*
    9.      并发修改异常
    10.         什么是并发修改异常:
    11.              ConcurrentModificationException
    12.              在使用迭代器(增强for) 遍历元素的同时,通过集合对象删除了集合中的指定数据，
    13.              这个时候就会出现并发修改异常。
    14.         原因是什么：
    15.            迭代器里面 元素个数  和 集合中元素个数不一致了。
    16.         怎么避免并发修改异常:
    17.            在开发中不在迭代器 迭代过程中 使用集合删除对象。
    19.            使用迭代器去删 迭代器删除的同时会给集合进行同步。
    20.     */
    21.     public static void main(String[] args) {
    22.         List list = new ArrayList<>();
    23.         list.add("name1");
    24.         list.add("name2");
    25.         list.add("name3");
    26.         list.add("name3");
    27.         list.add("name4");
    28.         list.add("name5");
    29.         System.out.println(list); // [王麻子, 小李子, 李爱花, 张全蛋, 晓李, 李玉刚]
    30.  
    31. //需求：找出集合中带"李"字的姓名，并从集合中删除
    32.         Iterator it = list.iterator();
    33.         while(it.hasNext()){
    34.             String name = it.next();
    35.             if(name.contains("李")){
    36. //                list.remove(name);不用集合删  用迭代器删除
    37.                 it.remove();//迭代器删除 会同步给集合
    38.             }
    39.         }
    40.         System.out.println(list);
    41.     }
    42. }
    43.  
    44.  
    45. -------------
    46. package com.itheima.day07.teacher.other;
    47.  
    48. import java.util.ArrayList;
    49. import java.util.Collections;
    50. import java.util.Comparator;
    51. import java.util.List;
    52.  
    53. public class CollenctionsDemo {
    54.     /*
    55.         集合工具类使用
    56.      */
    57.     public static void main(String[] args) {
    58.         //ArrayList集合 是Collection子类 也是List子类
    59.         List list = new ArrayList<>();
    60.         //
    61. //        list.add("a");  一个一个元素添加
    62.         //批量添加 Collections.addAll(Collection集合,T...t)//T 泛型的意思 集合里面是什么类型 泛型就是什么类型
    63.         Collections.addAll(list,"nba","cba","qba","abc");
    64.  
    65.         System.out.println("查看集合内容:"+list);
    66.         // 打乱顺序方法   --针对有序集合的(List)
    67.         // Collections.shuffle(List集合)
    68.         Collections.shuffle(list);
    69.         System.out.println("打乱后集合内容:"+list);
    70.         // 对集合元素排序 --针对有序集合(List)
    71.         // Collections.sort(List集合)  有前提 元素类型 具备排序规则 需要实现Comparable接口
    72.         Collections.sort(list); //按照默认顺序 升序
    73.         System.out.println("排序之后:"+list);
    74.         // 临时改变排序规则
    75.         //  Collections.sort(List集合,Comparator接口实现类对象) 按照当前自己定义的排序规则排序
    76.         Collections.sort(list, new Comparator() {
    77.             @Override
    78.             public int compare(String o1, String o2) {
    79.                 return o2.compareTo(o1);//字符串进行 降序  后面比较前面
    80.             }
    81.         });
    82.         System.out.println("自定义排序规则后:"+list);
    83.     }
    84. }

            

  • 相关阅读:
    FFmpeg入门详解之14：FFmpeg简介
    操作系统原理，IO控制方式，轮询流程，中断驱动流程，设备IO部件演化；IO的软件组成与层次，设备独立性；IO相关技术，缓冲技术
    NodeJS入门以及文件模块fs模块
    （附源码）小程序 记账微信小程序 毕业设计 180815
    （6）Lightweight OpenPose轻量化模型用于实时CPU多人姿态估计
    【Qt】控件探幽——QComboBox
    【无标题】
    硅-罗丹明-二苯并环辛炔；硅基罗丹明-二苯并环辛炔染料,SIR-DBCO，CAS号：2259859-41-9
    【C语法学习】17 - fwrite()函数
    推荐一个.Net Core开发的Websocket群聊、私聊的开源项目
  • 原文地址：https://blog.csdn.net/qq_52748334/article/details/136181056