• java之集合

    目录

    数据结构

    数据结构分类：

    逻辑结构和物理结构关系

    紧密结构优缺点

    跳转结构优缺点

    线性表

    线性表的逻辑结构

    线性表的特点

    链表

    链表分类

    单向链表

    双向链表​编辑

    循环链表

    树

    树的分析

    树中的基本概念

    二叉树

    二叉树的遍历

    集合

    数组特点：

    集合特点：

    集合结构图

    继承结构特点

    Collection接口

    常用方法

    集合的遍历

    List接口

    常用方法

    List集合的遍历

    ArrayList类

    ArrayList与Vector差别

    LinkedList类

    常用方法

    增加

    删除

    查看

    LinkedList总结

    Iterator迭代器

    hasNext和next方法

    iterator方法

    listIterator方法

    迭代器总结

    Set接口

    HashSet类

    HashSet原理

    LinkedHashSet类

    比较器

    String的内部比较器

    比较自定义类型

    内部比较器

    外部比较器

    TreeSet类

    TreeSet的使用

    内部比较器

    外部比较器

    TreeSet总结

    Map接口

    常用方法

    增加

    删除

    查看

    判断

    HashMap类

    注意：

    HashMap原理

    HashMap原理总结

    HashMap与HashTable

    LinkedHashMap类

    TreeMap类

    内部比较器使用

    外部比较器使用

    TreeMap特点

    Collections工具类

    常用方法

    数据结构

    含义：就是在计算机的缓存，内存，硬盘如何组织管理数据的；重点是在结构上，是按照什么结构来管理我们的数据的

    数据结构分类：

    • 逻辑结构：思想上的结构->线性表(数组、链表)、图、树、栈、队列
    • 物理结构：逻辑上的结构->紧密结构(顺序结构)、跳转结构(链式结构)

    逻辑结构和物理结构关系

    • 线性表的逻辑结构，对应的真实结构如果是紧密结构，那么典型例子就是数组
    • 线性表的逻辑结构，对应的真实结构如果是跳转结构，那么典型例子就是链表 

    紧密结构优缺点

    • 优点：寻址快（查找元素快）
    • 缺点：增删慢

    跳转结构优缺点

    • 优点：增删快
    • 缺点：查询慢

    线性表

    含义：线性表是n个类型相同数据元素的有限序列。

    线性表的逻辑结构

    线性表的特点

    • 相同数据类型：线性表的每个数据元素是具有相同的属性的元素
    • 序列(顺序性)：除了表头和表尾之间的所有元素都有且仅有一个直接前驱和直接后继
    • 有限：线性表中数据元素的个数n是一个有限值

    链表

    含义：链表是一种物理存储结构上非连续，非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。

    链表分类

    • 单向链表：链表中的每个数据都保存着数据与下一个元素的地址
    • 双向链表：链表中的每个元素都保存着数据与上一个元素地址以及下一个元素的地址，首元素的上一个地址为null，尾地址的下一个地址为null
    • 循环链表：链表中的每个元素都保存着数据与上一个元素地址以及下一个元素的地址，首元素上一个元素地址为尾元素地址，尾元素的下一个地址为首元素地址

    单向链表

    双向链表

    循环链表

    在这里插入图片描述

    树

    含义：树是(n>=0)个节点的有限集合，n=0时称为空树

    任何一个非空树的满足条件

    1. 有且仅有一个特定的称为根的节点
    2. 当n>1时，其余节点可分为m(m>0)个互不相交的有限集合，T1，T2，T3……Tm，其中，每个集合本身又是一棵树，称为根节点的子树 

    注意：

    • 树是一种递归的数据结构
    • 除了根节点以外的所有节点，有且仅有1个前驱节点
    • 树中的所有节点可以有0或多个后继节点 

    树的分析

     

    根节点：A

    祖先节点：A，B，D都为I的祖先节点

    子孙节点：B，D，I，K为A的子孙节点

    双亲节点：A为B的双亲节点，也为C的双亲节点

    孙子节点：B为A的孙子节点

    兄弟节点：有相同双亲的节点（如B和C）

    树中的基本概念

    节点的度：树中的1个节点的子节点个数（如A的度为2，B的度为3）

    树的度：树中节点的最大度（如上面树的度为3）

    分支节点：度大于0的节点

    叶子节点：度为0的节点

    节点的层次：从根节点开始定义，根节点为第一次，他的子节点为第二层，以此类推

    节点的深度：从根节点开始，自顶向下逐层累加

    节点的高度：从叶子节点开始从底向上逐层累加

    树的高度：树中节点的最大层数

    有序树：树中节点的子树从左到右是有次序的

    无序树：树中节点的子树从左到右没有次序，可以交换

    路径：树中两个节点的路径是由这两个节点之间所经过的节点序列构成

    路径的长度：路径上所经过边的个数

    二叉树

    含义：二叉树又称二叉查找树，亦称二叉搜索树，二叉树（binary tree）是指树中结点的度不大于2的有序树，它是一种最简单且最重要的树。

    二叉树的特性：任意一个左子树的节点值都比当前节点的值小，任意一个右子树的节点值都比当前节点值大

    二叉树的遍历

    • 先序遍历：根节点——>左子树——>右子树（A,B,D,C,E,G,F）
    • 中序遍历：左子树——>根节点——>右子树（B,D,A,E,G,C,F）
    • 后序遍历：左子树——>右子树——>根节点（D,B,G,E,F,C,A）

    集合

    注意：数组和集合都是对数据进行存储操作的，简称容器，但这里的存储指的是内存层面的存储，而不是持久化的存储

    数组特点：

    • 数组一旦创建，长度不可改变
    • 数组中可以存放引用数据类型与基本数据类型
    • 一旦声明了类型以后，数组中只能存放这个类型的数据。数组中只能存放同一种类型的数据
    • 删除，增加元素效率低
    • 数组只能获取数组整个长度，实际元素数量没有办法获取，没有提供对应的方法或者属性来获取
    • 数组储存：有序、可重复，对于无序，不可重复的数据，数组不能满足要求

    集合特点：

    • 只能存放引用类型数据，不能存放基本数据类型数据
    • 集合的长度是可变的
    • 集合可以存放不同数据类型

    集合结构图

    在这里插入图片描述

    继承结构特点

    List接口：数据有下标，有序，可重复

    • ArrayList类：底层维护的是数组——紧密结构
    • LinkedList类：底层维护的是链表——跳转结构（虚拟下标）

    Set接口：数据无下标，无序，不可重复

    • HashSet类：底层HashMap
    • TreeSet类：底层TreeMap

    Map接口：键值对的方式存数据

    • HashMap类：底层数组+链表（哈希表）
    • TreeMap类：底层二叉树

    Collection接口

    常用方法

    在这里插入图片描述

    clear()：移除此集合中的所有元素，没有返回值

    equals(Object o)：判断此集合对象与指定对象是否相等，相等返回true，否则为false

    1.         Collection c = new ArrayList<>();
    2.         c.add(18);
    3.         c.add(34);
    4.         c.add(18);
    5.         List list = Arrays.asList(new Integer[]{1,4,9});
    6.         c.addAll(list);//将另一个集合加入该集合中
    7.         c.remove(18);
    8.         System.out.println(c);
    9.         System.out.println("集合是否包含18这个元素"+c.contains(18));
    10.         System.out.println("集合的长度为"+c.size());
    11.         c.clear();//清空集合所有元素
    12.         System.out.println("集合是否为空"+c.isEmpty());
    13.         System.out.println(c.toString());
    14.         Collection c1=new ArrayList<>();
    15.         System.out.println("c和c1集合内容是否一样"+c.equals(c1));//判断集合是否一样

    集合的遍历

    1.         Collection collection = new ArrayList<>();
    2.         collection.add(18);
    3.         collection.add(34);
    4.         collection.add("18");
    5.        //对集合进行遍历
    6.         //增强for循环
    7.         for(Object o:collection){
    8.             System.out.println(o);
    9.         }
    10.  
    11.         //迭代器遍历
    12.         Iterator iterator = collection.iterator();
    13.         //如果有下一个元素就返回true，否则返回false
    14.         while (iterator.hasNext()){
    15.             //打印该（下一个）元素，并且指针下移一位
    16.             System.out.println(iterator.next());
    17.         }

    List接口

    List接口：数据有下标，有序，可重复

    常用方法

    在这里插入图片描述

    remove(int index)：根据下标移除列表中指定位置的元素， 返回值为移除的元素

    注意：可以看到list扩展的方法都和索引相关 

    1.         //集合下标从0开始
    2.         List list=new ArrayList();
    3.         list.add(13);
    4.         list.add(17);
    5.         list.add(true);
    6.         list.add(2);
    7.         list.add(1,89);//在下标为1的位置增加89
    8.         list.set(3, 66);//将下标为3位置的元素改为66
    9.         //注意：list的remove有2个方法，分别传入索引与Object类型
    10.         list.remove(2);//索引的优先级高，如果索引和元素恰好一样，那么会把索引下的元素删除。
    11.         list.remove((Object)2);//删除为2的元素
    12.         System.out.println(list);
    13.         System.out.println("下标为0的元素"+list.get(0));

    List集合的遍历

    1.         //list集合的遍历
    2.         //for循环
    3.         for (int i=0;i
    4.             System.out.println(list.get(i));
    5.         }
    6.  
    7.         //利用迭代器（这里我打算给下标为1以及之后的元素进行迭代）
    8.         ListIterator listIterator = list.listIterator(1);
    9.         //正序迭代
    10.         while (listIterator.hasNext()){
    11.             System.out.println(listIterator.next());
    12.         }

    注意：ListIterator迭代器可以进行逆序迭代

    ArrayList类

    创建对象：ArrayList arrayList=new ArrayList([初始容量]);

    注意：

    • ArrayList类重写了toString方法，重写后的toString方法能具体表示集合中的元素
    • ArrayList类重写了equals方法，重写后的equals方法比较的是集合内容是否相等
    • jdk1.8的ArrayList类底层维护的是Object类型的数组，在调用构造器的时候，底层数组为空，在调用add方法以后，底层数组才重新赋值为新数组，新数组的长度为10，节省了内存，当容量不够用的时候，底层会以1.5倍的容量增长

    ArrayList与Vector差别

    • ArrayList底层扩容长度为原数组的1.5倍，Vector底层扩容长度为原数组的两倍
    • ArrayList线程不去安全，效率高；而Vector的每个方法都加了同步关键字，线程安全，但效率低
    • ArrayList调用方法时才会初始化数组长度，Vertor在调用构造方法时就初始化数组长度（两者初始化数组长度都为10

    LinkedList类

    创建对象：LinkedList linkedList = new LinkedList<>();

    请添加图片描述

    常用方法

    增加

    addFirst(E e)：将指定元素插入到此列表的开头，返回值为void

    addLast(E e)：将指定元素插入到此列表的结尾，返回值为void

    offer(E e)：将指定元素添加到此列表的末尾，成功返回true，否则返回false

    offerFirst(E e)：在此列表的开头插入指定元素，成功返回true，否则返回false

    offerLast(E e)：在此列表末尾插入指定元素，成功返回true，否则返回false

    删除

    poll()：获取并移除此列表的头

    pollFirst()：获取并移除此列表的第一个元素，若列表中没元素则返回null

    pollLast()：获取并移除此列表的最后一个元素，若列表中没元素则返回null

    removeFirst()：移除并返回此列表的第一个元素，若列表中没元素则抛异常

    removeLast()：移除并返回此列表的最后一个元素，若列表中没元素则抛异常

    查看

    element()：获取但不移除此列表的第一个元素，返回第一个元素

    getFirst()：返回此列表的第一个元素，若列表中没元素则抛异常

    getLast()：返回此列表中的最后一个元素，若列表中没元素则抛异常

    indexOf(Object o)：返回此列表中首次出现的指定元素的索引，如果此列表中不包含该素，则返回-1

    lastIndexOf(Object o)：返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回-1

    peek()：获取但不移除此列表的头

    peekFirst()：获取但不移除此列表的第一个元素，若此列表为空，则返回null

    peekLast()：获取但不移除此列表的最后一个元素，若此列表为空，则返回null

    LinkedList总结

    • LinkedList底层使用的链表为双向链表
    • LinkedList链表中，首先将需要放入的元素封装为对象，对象中有3个属性，第一个属性为前一个元素的地址，第二个属性为数据部分，第三个属性为后一个元素的地址，整个这个对象才是链表中的一个节点
    • LinkedList链表查询速度，查询中间元素速度小于查询两边元素速度

    Iterator迭代器

    hasNext和next方法

    1. public class ArrayList<E> {
    2.     //底层的Object类型数组
    3.     transient Object[] elementData;
    4.     //数组的长度
    5.     private int size;
    6.     private class Itr implements Iterator<E>{
    7.         int cursor;
    8.         int lastRet=-1;
    9.         public boolean hasNext() {
    10.             //cursor和size相等则返回false，否则返回true
    11.             return cursor!=size;
    12.         }
    13.         @Override
    14.         public E next() {
    15.             int i=cursor;
    16.             //获取局部变量数组
    17.             Object[] elementData = ArrayList.this.elementData;
    18.             cursor=i+1;
    19.             return (E) elementData[lastRet-i];
    20.         }
    21.     }
    22. }

    iterator方法

    1.         ArrayList<String> l = new ArrayList<>();
    2.         l.add("a");
    3.         l.add("b");
    4.         l.add("c");
    5.         System.out.println(l);
    6.         //遍历
    7.         Iterator<String> iterator = l.iterator();
    8.         //查看集合有没有下一个元素，有则返回true，否则返回false
    9.         while (iterator.hasNext()){
    10.             //打印下一元素，并将指针下移一位
    11.             System.out.println(iterator.next());
    12.         }

    listIterator方法

    1.         ArrayList l = new ArrayList<>();
    2.         l.add("a");
    3.         l.add("b");
    4.         l.add("c");
    5.         l.add("d");
    6.         System.out.println(l);
    7.         //正序遍历(遍历索引1以及之后的元素，当然也可以不传，那么就是遍历所有元素）
    8.         ListIterator lt = l.listIterator(1);
    9.         while (lt.hasNext()){
    10.             System.out.println(lt.next());
    11.         }
    12.         System.out.println(lt);
    13.         System.out.println(lt.hasNext());
    14.         //如今指针已经指向最后了，可以逆序遍历
    15.         //判断是否有前一个元素，如果有返回true，否则false
    16.         while (lt.hasPrevious()){
    17.             //打印前一个元素，指针上移一位
    18.             System.out.println(lt.previous());
    19.         }

    迭代器总结

    1. Collection接口继承了Iterable接口，Iterable接口里面有iterator方法
    2. iterator()为抽象方法，该抽象方法要在具体的实现类中实现，而方法的返回值为Iterator接口
    3. 在Iterator接口里有两个经典方法：hasNext()，next()；
    4. hasNext(),next()两个为抽象方法，这两种抽象方法在Itr类中得到具体实现，但Itr类为ArrayList类的内部类
    5. listIterator可以实现逆序遍历
    6. 增强for循环的底层也是通过迭代器实现

    Set接口

    set接口：数据无下标，无序，不可重复(如果第二次add同样的数据，那么第二次的数据不会放入集合)

    注意：set接口里没有与索引相关的方法

    HashSet类

    创建对象：HashSet hs = new HashSet<>([初始容量],[加载因子]);

    1.         HashSet hs = new HashSet<>();
    2.         hs.add(19);
    3.         hs.add(8);
    4.         hs.add(19);
    5.         System.out.println(hs.size());//结果为2
    6.         System.out.println(hs);//打印是乱序的

    注意：

    • 自定义的引用类型必须重写hashCode和equals函数才能实现HashSet的去重，原因请见HashSet原理
    • HashSet的去重原理就是利用HashMap的key（将存的数据放入HashMap的key中）
    • HashSet底层就是HashMap，因此，初始容量和加载因子以及扩容方式参照HashMap

    HashSet原理

    向hashSet集合中存入数据（以Integer类型为例)

    注意：

    • hashSet底层原理：数组+链表
    • 通过hashCode函数来计算出关键字key
    • key通过哈希函数算出存放入数组的具体下标
    • hashSet集合中存放数据时，会对存放的数据进行比对(调用内部的equals方法)，看是否该元素在集合中是否已经存在，若存在则不会对该元素进行处理
    • 哈希函数是根据关键字设计的，有很多种函数，主要原理就是根据数组大小求模运算（关键字%数组大小）最后求得的余数放入数组中某个下标的位置
    • 哈希冲突：通过key和哈希函数计算出的数组下标一样，解决方式——链表
    • 对于哈希冲突，jdk1.8采用尾插法（后来的元素插到链表的后面）

    LinkedHashSet类

    • LinkedHashSet继承自HashSet
    • LinkedHashSet集合元素有序，不可重复(就相当于有序的HashSet)，其会按照输入顺序进行输出
    • LinkedHashSet相对于HashSet来说就多了一个总的链表，这总的链表将放入的元素都串在一起（第一个存放的数据作为链表的第一个数据，最后一个存放的数据作为链表最后一个数据）

    比较器

    String的内部比较器

    comparable接口有compareTo方法，这个compareTo方法就是用来完成比较的方法

    1. public interface Comparable<T> {
    2.     public int compareTo(T o);
    3. }

    String类实现了这个接口，重写了该方法，如下

    1.     public int compareTo(String anotherString) {
    2.         int len1 = value.length;
    3.         int len2 = anotherString.value.length;
    4.         int lim = Math.min(len1, len2);
    5.         char v1[] = value;
    6.         char v2[] = anotherString.value;
    7.  
    8.         int k = 0;
    9.         while (k < lim) {
    10.             char c1 = v1[k];
    11.             char c2 = v2[k];
    12.             if (c1 != c2) {
    13.                 return c1 - c2;
    14.             }
    15.             k++;
    16.         }
    17.         return len1 - len2;
    18.     }

    理解：由上面源码可知String在比较两个字符串的时候对两个字符串的每个字符逐个比较，如果在比较过程中出现了不等情况，那么将会返回第一次出现不相等情况下字符1与字符2的ASCII码值差值，如果两个字符串前面字符都一样，只是长度不相同，那么将会返回字符串1的长度与字符串2长度的差值，差值为0代表两个字符串相等

    1.         String s1="abc";
    2.         String s2="abc";
    3.         System.out.println(s1.compareTo(s2));

    比较自定义类型

    内部比较器

    含义：实现了Comparable接口，所有比较的逻辑全部都在自己即将比较的类的内部进行实现

    1. public class Student implements Comparable<Student>{
    2.     private int age;
    3.     private double height;
    4.     private String name;
    5.     public int getAge() {
    6.         return age;
    7.     }
    8.     public void setAge(int age) {
    9.         this.age = age;
    10.     }
    11.     public double getHeight() {
    12.         return height;
    13.     }
    14.     public void setHeight(double height) {
    15.         this.height = height;
    16.     }
    17.     public String getName() {
    18.         return name;
    19.     }
    20.     public void setName(String name) {
    21.         this.name = name;
    22.     }
    23.     public Student(int age, double height, String name) {
    24.         this.age = age;
    25.         this.height = height;
    26.         this.name = name;
    27.     }
    28.     @Override
    29.     public String toString() {
    30.         return "Student{" +
    31.                 "age=" + age +
    32.                 ", height=" + height +
    33.                 ", name='" + name + '\'' +
    34.                 '}';
    35.     }
    36.     //比较两个学生的年龄
    37.     @Override
    38.     public int compareTo(Student o) {
    39.         return this.getAge()-o.getAge();
    40.     }
    41. }
    42. class test8{
    43.     public static void main(String[] args){
    44.         Student s1 = new Student(10, 160.5, "lili");
    45.         Student s2 = new Student(14, 160, "lan");
    46.         System.out.println(s1.compareTo(s2));
    47.     }
    48. }

    注意：

    • 若想要将自定义的类型进行比较，一定要实现Comparable接口，重写里面的compareTo方法，里面的泛型传入你要比较的类型
    • compareTo方法的返回值为int类型

    外部比较器

    1. @FunctionalInterface
    2. public interface Comparator<T> {
    3.     int compare(T o1, T o2);
    4. }

    案例

    1. public class Student{
    2.     private int age;
    3.     private double height;
    4.     private String name;
    5.     public int getAge() {
    6.         return age;
    7.     }
    8.     public void setAge(int age) {
    9.         this.age = age;
    10.     }
    11.     public double getHeight() {
    12.         return height;
    13.     }
    14.     public void setHeight(double height) {
    15.         this.height = height;
    16.     }
    17.     public String getName() {
    18.         return name;
    19.     }
    20.     public void setName(String name) {
    21.         this.name = name;
    22.     }
    23.     public Student(int age, double height, String name) {
    24.         this.age = age;
    25.         this.height = height;
    26.         this.name = name;
    27.     }
    28.     @Override
    29.     public String toString() {
    30.         return "Student{" +
    31.                 "age=" + age +
    32.                 ", height=" + height +
    33.                 ", name='" + name + '\'' +
    34.                 '}';
    35.     }
    36. }
    37. class Contrast implements Comparator<Student> {
    38.     @Override
    39.     public int compare(Student o1, Student o2) {
    40.         return o1.getName().compareTo(o2.getName());
    41.     }
    42. }
    43. class test8{
    44.     public static void main(String[] args){
    45.         //比较名字
    46.         Student s1 = new Student(10, 160.5, "lili");
    47.         Student s2 = new Student(14, 160, "lili");
    48.         Contrast contrast = new Contrast();
    49.         System.out.println(contrast.compare(s1, s2));
    50.     }
    51. }

    使用步骤

    • 自定义一个比较类，实现Comparator接口，重写里面的compare方法，将要比较的类型传入泛型
    • 通过调用该类compare方法的形式完成值的比较

    TreeSet类

    创建对象：TreeSet ts = new TreeSet<>([外部比较器]);

    TreeSet的使用

    内部比较器

    1. public class Student implements Comparable<Student>{
    2.     private int age;
    3.     private String name;
    4.     public int getAge() {
    5.         return age;
    6.     }
    7.     public void setAge(int age) {
    8.         this.age = age;
    9.     }
    10.     public String getName() {
    11.         return name;
    12.     }
    13.     public void setName(String name) {
    14.         this.name = name;
    15.     }
    16.     public Student(int age, String name) {
    17.         this.age = age;
    18.         this.name = name;
    19.     }
    20.     @Override
    21.     public String toString() {
    22.         return "Student{" +
    23.                 "age=" + age +
    24.                 ", name='" + name + '\'' +
    25.                 '}';
    26.     }
    27.     //根据年龄进行比较
    28.     @Override
    29.     public int compareTo(Student o) {
    30.         return this.getAge()-o.getAge();
    31.     }
    32. }
    33. class Test{
    34.     public static void main(String[] args) {
    35.         Student s1 = new Student(13, "lili");
    36.         Student s2 = new Student(8, "nana");
    37.         Student s3 = new Student(5, "liu");
    38.         Student s4 = new Student(13, "lan");
    39.         TreeSet<Student> students = new TreeSet<>();
    40.         students.add(s1);
    41.         students.add(s2);
    42.         students.add(s3);
    43.         students.add(s4);
    44.         //根据年龄升序递增排序
    45.         System.out.println(students);
    46.     }
    47. }

    外部比较器

    1. public class Student{
    2.     private int age;
    3.     private String name;
    4.     public int getAge() {
    5.         return age;
    6.     }
    7.     public void setAge(int age) {
    8.         this.age = age;
    9.     }
    10.     public String getName() {
    11.         return name;
    12.     }
    13.     public void setName(String name) {
    14.         this.name = name;
    15.     }
    16.     public Student(int age, String name) {
    17.         this.age = age;
    18.         this.name = name;
    19.     }
    20.     @Override
    21.     public String toString() {
    22.         return "Student{" +
    23.                 "age=" + age +
    24.                 ", name='" + name + '\'' +
    25.                 '}';
    26.     }
    27. }
    28. class Contrast implements Comparator<Student> {
    29.     @Override
    30.     public int compare(Student o1, Student o2) {
    31.         return o1.getAge()-o2.getAge();
    32.     }
    33. }
    34. class Test{
    35.     public static void main(String[] args) {
    36.         //利用外部比较器
    37.         Contrast contrast = new Contrast();
    38.         //一旦指定外部比较器就会按照外部比较器比较
    39.         Student s1 = new Student(13, "lili");
    40.         Student s2 = new Student(8, "nana");
    41.         Student s3 = new Student(5, "liu");
    42.         Student s4 = new Student(13, "lan");
    43.         TreeSet<Student> students = new TreeSet<>(contrast);
    44.         students.add(s1);
    45.         students.add(s2);
    46.         students.add(s3);
    47.         students.add(s4);
    48.         //根据年龄升序排序
    49.         System.out.println(students);
    50.     }
    51. }

    注意：以上的添加元素方式就是给二叉树添加元素的方式（比较左子树与右子树）数值小的放左边，数值大的放右边 

    TreeSet总结

    • 元素不能重复，并且无序（不会按照输入顺序进行输出）但是会按照升序方式进行遍历
    • TreeSet底层在调用空构造器时创建了TreeMap，通过TreeMap的key来控制TreeSet的特点
    • TreeSet底层是二叉树（数据结构中的逻辑结构），其用的遍历方式为中序遍历（左，根，右）刚刚好就是一个升序的遍历方式
    • 创建自定义类型的TreeSet集合那么该自定义类型必须有比较器，不然会报错
    • TreeSet创建对象时若构造方法若不传外部比较器，则默认用内部比较器比较，用内部比较器比较就要求要比较的类实现Comparable接口

    Map接口

    常用方法

    增加

    put(K key,V value)：将指定键值放入map，返回重复了key而被移除的值，否则返回null

    删除

    clear()：清空map所有键值，返回值为void

    remove(Object key)：将map中的指定键值删除，返回删除键对应的值

    查看

    entrySet()：将map中的所有映射信息放入set集合，返回这个set集合

    get(Object key)：返回map中指定键所映射的值，若不包含映射关系则返回null

    keySet()：将map中的所有key放入set集合，返回这个set集合

    values()：将map中的所有value放入collection集合，返回这个collection集合

    size()：返回此map的长度

    判断

    containsKey(Object key)：如果map中包含key则返回true，否则返回false

    containsValue(Object value)：如果map中包含value则返回true

    equals(Object o)：比较两个map内容是否相等，相等返回true，否则返回false

    isEmpty()：判断此map映射是否为空，为空返回true，否则返回false

    1.         Map map = new HashMap<>();
    2.         map.put("lili", 1001);
    3.         map.put("nana", 1005);
    4.         System.out.println(map.put("lan", 1024));//null
    5.         System.out.println(map.put("lan", 1024));//1024
    6.         System.out.println(map.containsKey("nana"));
    7.         System.out.println(map.containsValue(1024));
    8.         System.out.println(map.remove("nana"));//1005
    9.         System.out.println("map集合的长度："+map.size());
    10.         System.out.println("map集合是否为空："+map.isEmpty());
    11.         System.out.println(map);
    12.         System.out.println(map.get("lili"));
    13.         for (String s : map.keySet()) {
    14.             System.out.println("key为："+s);
    15.         }
    16.         for (Integer value : map.values()) {
    17.             System.out.println("value为："+value);
    18.         }
    19.         for (Map.Entry entry : map.entrySet()) {
    20.             System.out.println("key为："+entry.getKey()+"\tvalue为："+entry.getValue());
    21.         }
    22.         map.clear();
    23.         System.out.println(map);

    Map集合的特点：键值对都是无序的，而且键不能重复，值可以重复，如果第二次put入相同的键，那么第二次put的键所对应的值将会把第一次的值覆盖

    HashMap类

    创建对象：HashMap map = new HashMap<>([初始容量],[加载因子]);

    注意：

    • HashMap初始容量为16，默认加载因子为0.75（存放的数据超过12就扩容）
    • 加载因子不是1的原因：减少哈希碰撞的发生
    • 传入的初始容量若小于16，直接初始容量变为2倍
    • HashMap的扩容按照2倍扩容
    • 如果链表的长度>8且数组长度>64时，链表会转为红黑树，当链表的长度<6时，红黑树会重新恢复成链表

    HashMap原理

    以下面代码为例

    1.         HashMap map = new HashMap<>();
    2.         map.put(12, "lili");
    3.         map.put(7, "lulu");
    4.         map.put(9, "lala");
    5.         map.put(16, "liu");
    6.         map.put(6, "fafa");
    7.         System.out.println(map.put(12, "lan"));
    8.         System.out.println("集合中的长度"+map.size());//3
    9.         System.out.println("集合"+map);

    HashMap原理总结

    1. HashMap底层原理：采用数组+链表（哈希表）
    2. 存放数据时会通过元素的key调用hashCode函数来生成具体的key，再通过key经过哈希函数来计算出具体的放入数组的下标位置
    3. HashMap集合存放数据时会根据key来调用equals函数，看是否该元素的key在集合中已经存在，如果存在则直接替换掉该key原来的value值，返回原来被替换掉的value值，若不存在则不处理
    4. HashMap集合存放数据原理：将元素的key，value，通过key算出的哈希码，下一个元素的地址封装为对象（Entry对象），来向数组中进行存放
    5. 对于遇到不同key值的哈希冲突情况，jdk1.8的情况采用尾插法（就是后来的元素插到链表的后面）

    HashMap与HashTable

    HashTable与HashMap类似，不同点是HashTable是线程安全的，它几乎给所有的public方法都加上了synchronizatized关键字，还有一个不同点是HashTable的K，V都不能为null，HashMap就可以

    LinkedHashMap类

    • LinkedHashMap为HashMap的子类
    • LinkedHashMap底层：哈希表+链表（多维护一张链表，对输入数据进行串联记录）
    • LinkedHashMap特点：键不能重复，有序（按照输入顺序进行输出）

    TreeMap类

    创建对象：TreeMap map = new TreeMap<>([外部比较器]);

    内部比较器使用

    1. public class People implements Comparable<People>{
    2.     private String name;
    3.     private int age;
    4.     public People(String name, int age) {
    5.         this.name = name;
    6.         this.age = age;
    7.     }
    8.     public String getName() {
    9.         return name;
    10.     }
    11.     public void setName(String name) {
    12.         this.name = name;
    13.     }
    14.     public int getAge() {
    15.         return age;
    16.     }
    17.     public void setAge(int age) {
    18.         this.age = age;
    19.     }
    20.     @Override
    21.     public String toString() {
    22.         return "People{" +
    23.                 "name='" + name + '\'' +
    24.                 ", age=" + age +
    25.                 '}';
    26.     }
    27.  
    28.     @Override
    29.     public int compareTo(People o) {
    30.         //按照年龄排序
    31.         return this.getAge()-o.getAge();
    32.     }
    33. }
    34. class Test03{
    35.     public static void main(String[] args) {
    36.         People p1 = new People("lili", 23);
    37.         People p2 = new People("lan", 25);
    38.         People p3 = new People("nana", 23);
    39.         TreeMap<People, Integer> map = new TreeMap<>();
    40.         map.put(p1,1001);
    41.         map.put(p2, 1003);
    42.         map.put(p3, 1002);
    43.         System.out.println(map);//23岁的只有1个，因为按照年龄排序
    44.     }
    45. }

    外部比较器使用

    1. public class People{
    2.     private String name;
    3.     private int age;
    4.     public People(String name, int age) {
    5.         this.name = name;
    6.         this.age = age;
    7.     }
    8.     public String getName() {
    9.         return name;
    10.     }
    11.     public void setName(String name) {
    12.         this.name = name;
    13.     }
    14.     public int getAge() {
    15.         return age;
    16.     }
    17.     public void setAge(int age) {
    18.         this.age = age;
    19.     }
    20.     @Override
    21.     public String toString() {
    22.         return "People{" +
    23.                 "name='" + name + '\'' +
    24.                 ", age=" + age +
    25.                 '}';
    26.     }
    27. }
    28. class Test03{
    29.     public static void main(String[] args) {
    30.         People p1 = new People("lili", 23);
    31.         People p2 = new People("lan", 25);
    32.         People p3 = new People("nana", 23);
    33.         TreeMap<People, Integer> map = new TreeMap<>(new Comparator<People>() {
    34.             @Override
    35.             public int compare(People o1, People o2) {
    36.                 return o1.getName().compareTo(o2.getName());
    37.             }
    38.         });
    39.         map.put(p1,1001);
    40.         map.put(p2, 1003);
    41.         map.put(p3, 1002);
    42.         System.out.println(map);
    43.     }
    44. }

    TreeMap特点

    • 键不能重复，输出顺序按照升序或降序的方式
    • 底层的原理：二叉树，key遵循二叉树的特点
    • 放入集合的key的数据对应的类型内部一定要实现比较器（内部比较器或外部比较器二选一）
    • 如果创建对象时不指定外部比较器，那么就默认使用内部比较器
    • TreeMap存放数据的方式：将K，V，左子树地址，右子树地址，父节点地址，树节点颜色封装为一个对象（节点对象）进行存放
    • 自定义类型用比较器后，被比较的属性若重复，则新的value会替换掉老的value，但是key不变

    Collections工具类

    注意：

    • Collection类仅有一个空参构造器，构造器被私有化无法直接创建对象
    • 该类里面的所有属性以及方法都被static关键字修饰，我们可以通过类名直接调用

    常用方法

    addAll()(Collection c,T... elements)：将后面的所有元素添加到集合c中，成功返回true，否则返回false

    sort(Collection c)：将c集合进行升序排序，返回值为void

    reverse(Collection c)：将c集合中的元素进行反转，返回值为void

    Collections.binarySearch(Collection c, 集合中的元素)：判断升序集合中元素在集合位置下的索引值并返回

    copy(Collection c1, Collection c2)：将c2集合中的元素替换到c1里面，如果c1长度长于c2，那么就会替换掉c1前面的数据，如果c1长度短于c2那么会抛出异常

    fill(Collection c, 数据data)：将c集合里的所有数据都替换为数据data

    1.         ArrayList list = new ArrayList<>();
    2.         Collections.addAll(list, "lili","lala","lulu");//向集合中加入元素列表
    3.         Collections.reverse(list);//反转集合
    4.         Collections.sort(list);//将集合进行升序排序
    5.         System.out.println(Collections.binarySearch(list, "lili"));//查找lili所在的集合下标
    6.         System.out.println(list);
    7.         ArrayList list1 = new ArrayList<>();
    8.         Collections.addAll(list1, "11","22");
    9.         Collections.copy(list, list1);
    10.         System.out.println(list);
    11.         Collections.fill(list1, "aa");
    12.         System.out.println(list1);

  • 相关阅读:
    在 Docker 容器中安装 nvm
    C语言柔性数组
    针对多分类问题，使用深度学习--Keras进行微调提升性能
    【第29篇】MAE：屏蔽自编码器是可扩展的视觉学习器
    一、安全完善度等级SIL(Safety Integrity Level)介绍
    [附源码]Python计算机毕业设计房地产销售系统
    项目实战第二十三讲：标准中心-类目体系
    Part3_理解MATSIM_第48章 MATSim作为蒙特卡洛引擎
    JSP webshell免杀——JSP的基础
    RPA实施中的8个坑点
  • 原文地址：https://blog.csdn.net/m0_60027772/article/details/126132984