• 【零基础学Java】第二十二篇 集合2（Set，Map，Collections工具类)

    📄个人简介
    🔔作者简介：大家好，我是小学生！！🙈大三学生一枚，目前正在自学Java，如果大家觉得我写的还不错的话，希望大家给我点赞👍+收藏⭐+评论📢，有什么写的不对的地方还请大家多多指教🙏，共同进步。
    📝个人主页：小学生！！
    📖系列专栏
    🌕阶段一：Java基础编程
    💦目前已原创22篇

    🌕阶段二：数据结构与算法
    🌕阶段三：操作系统
    🌕阶段四：计算机网络

    文章目录

    1.Set接口
    1.基本介绍
    1. 无序（添加和取出的顺序不一致)，没有索引]
    2. 不允许重复元素，所以最多包含一个null

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cTEEDQNE-1661136945919)(C:\Users\w'y'x\AppData\Roaming\Typora\typora-user-images\image-20220821102041554.png)]

    2.Set接口的常用方法

    和List接口一样, Set接口也是Collection的子接口，因此，常用方法和Collection接口一样。

    3.Set接口的遍历方式

    同Collection的遍历方式一样，因为Set接口是Collection接口的子接口。

    1. 可以使用迭代器。
    2. 增强for。
    3. 不能使用索引的方式来获取。
    4.HashSet
    1.HashSet的基本介绍

    1. HashSet实现了Set接口。

    2. HashSet实际上是HashMap

      public Hashset() {
map = new HashMap<>();
}

      • 1
      • 2
      • 3

    3. 可以存放null值，但是只能有一个null。

    4. HashSet不保证元素是有序的,取决于hash后，再确定索引的结果。

    5. 不能有重复元素/对象。

    2.HashSet的底层说明
    1. HashSet底层是HashMap。
    2. 添加一个元素时，先得到hash值-会转成->索引值。
    3. 找到存储数据表table，看这个索引位置是否已经存放的有元素。
    4. 如果没有，直接加入。
    5. 如果有，调用equals比较，如果相同，就放弃添加,如果不相同，则添加到最后。
    6. 第一次添加时,table数组扩容到16，临界值(threshold)是16*加载因子(loadFactor)是0.75 = 12。
    7. 如果table数组使用到了临界值12,就会扩容到16*2 = 32,新的临界值就是32*0.75 = 24,依次类推。
    8. 在Java8中,如果一条链表的元素个数到达TREEIFY_THRESHOLD(默认是8)，并且table的大小>=MIN TREEIFY CAPACITY(默认64)就会进行树化(红黑树),否则仍然采用数组扩容机制。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-b6p05OV8-1661136945920)(C:\Users\w’y’x\AppData\Roaming\Typora\typora-user-images\image-20220730103638823.png)]

    @SuppressWarnings({"all"})
public class HashSetSource {
    public static void main(String[] args) {

        HashSet hashSet = new HashSet();
        hashSet.add("java");//到此位置，第1次add分析完毕.
        hashSet.add("php");//到此位置，第2次add分析完毕
        hashSet.add("java");
        System.out.println("set=" + hashSet);

        /*
        1. 执行 HashSet()
            public HashSet() {
                map = new HashMap<>();
            }
        2. 执行 add()
           public boolean add(E e) {//e = "java"
                return map.put(e, PRESENT)==null;//(static) PRESENT = new Object();
           }
         3.执行 put() , 该方法会执行 hash(key) 得到key对应的hash值 算法h = key.hashCode()) ^ (h >>> 16)
             public V put(K key, V value) {//key = "java" value = PRESENT 共享
                return putVal(hash(key), key, value, false, true);
            }
         4.执行 putVal
         final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
                Node[] tab; Node p; int n, i; //定义了辅助变量
                //table 就是 HashMap 的一个数组，类型是 Node[]
                //if 语句表示如果当前table 是null, 或者 大小=0
                //就是第一次扩容，到16个空间.
                if ((tab = table) == null || (n = tab.length) == 0)
                    n = (tab = resize()).length;

                //(1)根据key，得到hash 去计算该key应该存放到table表的哪个索引位置
                //并把这个位置的对象，赋给 p
                //(2)判断p 是否为null
                //(2.1) 如果p 为null, 表示还没有存放元素, 就创建一个Node (key="java",value=PRESENT)
                //(2.2) 就放在该位置 tab[i] = newNode(hash, key, value, null)

                if ((p = tab[i = (n - 1) & hash]) == null)
                    tab[i] = newNode(hash, key, value, null);
                else {
                    //一个开发技巧提示： 在需要局部变量(辅助变量)时候，在创建
                    Node e; K k; //
                    //如果当前索引位置对应的链表的第一个元素和准备添加的key的hash值一样
                    //并且满足 下面两个条件之一:
                    //(1) 准备加入的key 和 p 指向的Node 结点的 key 是同一个对象
                    //(2)  p 指向的Node 结点的 key 的equals() 和准备加入的key比较后相同
                    //就不能加入
                    if (p.hash == hash &&
                        ((k = p.key) == key || (key != null && key.equals(k))))
                        e = p;
                    //再判断 p 是不是一颗红黑树,
                    //如果是一颗红黑树，就调用 putTreeVal , 来进行添加
                    else if (p instanceof TreeNode)
                        e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);
                    else {//如果table对应索引位置，已经是一个链表, 就使用for循环比较
                          //(1) 依次和该链表的每一个元素比较后，都不相同, 则加入到该链表的最后
                          //    注意在把元素添加到链表后，立即判断 该链表是否已经达到8个结点
                          //    , 就调用 treeifyBin() 对当前这个链表进行树化(转成红黑树)
                          //    注意，在转成红黑树时，要进行判断, 判断条件
                          //    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY(64))
                          //            resize();
                          //    如果上面条件成立，先table扩容.
                          //    只有上面条件不成立时，才进行转成红黑树
                          //(2) 依次和该链表的每一个元素比较过程中，如果有相同情况,就直接break

                        for (int binCount = 0; ; ++binCount) {
                            if ((e = p.next) == null) {
                                p.next = newNode(hash, key, value, null);
                                if (binCount >= TREEIFY_THRESHOLD(8) - 1) // -1 for 1st
                                    treeifyBin(tab, hash);
                                break;
                            }
                            if (e.hash == hash &&
                                ((k = e.key) == key || (key != null && key.equals(k))))
                                break;
                            p = e;
                        }
                    }
                    if (e != null) { // existing mapping for key
                        V oldValue = e.value;
                        if (!onlyIfAbsent || oldValue == null)
                            e.value = value;
                        afterNodeAccess(e);
                        return oldValue;
                    }
                }
                ++modCount;
                //size 就是我们每加入一个结点Node(k,v,h,next), size++
                if (++size > threshold)
                    resize();//扩容
                afterNodeInsertion(evict);
                return null;
            }
         */

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    5.LinkedHashSet
    1.LinkedHashSet的基本介绍
    1. LinkedHashSet是 HashSet的子类
      a HashSet - java.util
      LinkedHashSet - java.util
    2. LinkedHashSet底层是一个 LinkedHashMap，底层维护了一个数组+双
      向链表
      3)LinkedHashSet根据元素的hashCode值来决定元素的存储位置,同时使
      用链表维护元素的次序(图)，这使得元素看起来是以插入顺序保存的。
    3. LinkedHashSet 不允许添重复元素
    2.LinkedHashSet的底层结构

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qrAishgO-1661136945920)(C:\Users\w’y’x\AppData\Roaming\Typora\typora-user-images\image-20220730103954179.png)]

    @SuppressWarnings({"all"})
public class LinkedHashSetSource {
    public static void main(String[] args) {
        //分析一下LinkedHashSet的底层机制
        Set set = new LinkedHashSet();
        set.add(new String("AA"));
        set.add(456);
        set.add(456);
        set.add(new Customer("刘", 1001));
        set.add(123);
        set.add("HSP");

        System.out.println("set=" + set);
       
        //1. LinkedHashSet 加入顺序和取出元素/数据的顺序一致
        //2. LinkedHashSet 底层维护的是一个LinkedHashMap(是HashMap的子类)
        //3. LinkedHashSet 底层结构 (数组table+双向链表)
        //4. 添加第一次时，直接将数组table扩容到 16 ,存放的结点类型是 LinkedHashMap$Entry
        //5. 数组是 HashMap$Node[] 存放的元素/数据是 LinkedHashMap$Entry类型
        /*
                //继承关系是在内部类完成.
                static class Entry extends HashMap.Node {
                    Entry before, after;
                    Entry(int hash, K key, V value, Node next) {
                        super(hash, key, value, next);
                    }
                }

         */

    }
}
class Customer {
    private String name;
    private int no;

    public Customer(String name, int no) {
        this.name = name;
        this.no = no;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    6.TreeSet的源码分析
    public class TreeSet_ {
    public static void main(String[] args) {

        //1. 当我们使用无参构造器，创建TreeSet时，仍然是无序的
        //2. 希望添加的元素，按照字符串大小来排序
        //3. 使用TreeSet 提供的一个构造器，可以传入一个比较器(匿名内部类)
        //   并指定排序规则
        //4. 简单看看源码
        /*
        1. 构造器把传入的比较器对象，赋给了 TreeSet的底层的 TreeMap的属性this.comparator

         public TreeMap(Comparator comparator) {
                this.comparator = comparator;
            }
         2. 在 调用 treeSet.add("tom"), 在底层会执行到

             if (cpr != null) {//cpr 就是我们的匿名内部类(对象)
                do {
                    parent = t;
                    //动态绑定到我们的匿名内部类(对象)compare
                    cmp = cpr.compare(key, t.key);
                    if (cmp < 0)
                        t = t.left;
                    else if (cmp > 0)
                        t = t.right;
                    else //如果相等，即返回0,这个Key就没有加入
                        return t.setValue(value);
                } while (t != null);
            }
         */

//        TreeSet treeSet = new TreeSet();
        TreeSet treeSet = new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                //下面 调用String的 compareTo方法进行字符串大小比较
                //如果要求加入的元素，按照长度大小排序
                //return ((String) o2).compareTo((String) o1);
                return ((String) o1).length() - ((String) o2).length();
            }
        });
        //添加数据.
        treeSet.add("jack");
        treeSet.add("tom");//3
        treeSet.add("sp");
        treeSet.add("a");
        treeSet.add("abc");//3


        System.out.println("treeSet=" + treeSet);




    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    2.Map接口
    1.Map接口实现类的特点
    1. Map与Collection并列存在。用于保存具有映射关系的数据:Key-Value。
    1. Map 中的 key和value 可以是任何引用类型的数据，会封装到HashMap$Node对象中。
    2. Map中的key不允许重复，原因和HashSet一样，Map中的value可以重复。
    3. Map 的key可以为null, value也可以为null，注意key为null, 只能有一个，value为null ,可以多个。
    4. 常用String类作为Map的key。
    5. key 和 value之间存在单向一对一关系，即通过指定的key总能找到对应的value。
    6. Map存放数据的key-value示意图,一对k-v是放在一个HashMap$Node中的，有因为Node实现了Entry 接口，有些书上也说一对k-v就是一个Entry。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-r7CST8FO-1661136945921)(C:\Users\w’y’x\AppData\Roaming\Typora\typora-user-images\image-20220801090442748.png)]

    public class MapSource_ {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("no1", "韩顺平");//k-v
        map.put("no2", "张无忌");//k-v
        map.put(new Car(), new Person());//k-v

        //1. k-v 最后是 HashMap$Node node = newNode(hash, key, value, null)
        //2. k-v 为了方便程序员的遍历，还会 创建 EntrySet 集合 ，该集合存放的元素的类型 Entry, 而一个Entry
        //   对象就有k,v EntrySet> 即： transient Set> entrySet;
        //3. entrySet 中， 定义的类型是 Map.Entry ，但是实际上存放的还是 HashMap$Node
        //   这时因为 static class Node implements Map.Entry
        //4. 当把 HashMap$Node 对象 存放到 entrySet 就方便我们的遍历, 因为 Map.Entry 提供了重要方法
        //   K getKey(); V getValue();

        Set set = map.entrySet();
        System.out.println(set.getClass());// HashMap$EntrySet
        for (Object obj : set) {

            //System.out.println(obj.getClass()); //HashMap$Node
            //为了从 HashMap$Node 取出k-v
            //1. 先做一个向下转型
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey() + "-" + entry.getValue() );
        }

        Set set1 = map.keySet();
        System.out.println(set1.getClass());
        Collection values = map.values();
        System.out.println(values.getClass());


    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    2.Map接口常用方法
    1. put：添加。
    2. remove：根据键删除映射关系。
    3. get：根据键获取值。
    4. size：获取元素个数。
    5. isEmpty：判断个数是否为0。
    6. clear：清除。
    7. containsKey：查找键是否存在。
    3.Map的六大遍历方式
    4.HashMap
    1.HashMap的基本介绍

    1. Map接口的常用实现类:HashMap、Hashtable和Properties。

    2. HashMap是 Map接口使用频率最高的实现类。

    3. HashMap是以 key-val对的方式来存储数据(HashMap$Node类型)。

    4. key不能重复，但是值可以重复,允许使用null键和null值。

    5. 如果添加相同的key，则会覆盖原来的key-val ,等同于修改.(key不会替换,val会替换)。

    6. 与HashSet一样，不保证映射的顺序，因为底层是以hash表的方式来存储的.(jdk8的hashMap底层数组+链表+红黑树)。

    7. HashMap没有实现同步，因此是线程不安全的，方法没有做同步互斥的操作,没有synchronized。

    2.HashMap的底层说明

    扩容机制[和HashSet相同]

    1. HashMap底层维护了Node类型的数组table，默认为null。
    2. 当创建对象时，将加载因子(loadfactor)初始化为0.75。
    3. 当添加key-val时，通过key的哈希值得到在table的索引。然后判断该索引处是否有元素,如果没有元素直接添加。如果该索引处有元素,继续判断该元素的key和准备加入的key相是否等，如果相等，则直接替换val;如果不相等，需要判断是树结构还是链表结构，做出相应处理。如果添加时发现容量不够，则需要扩容。
    4. 第1次添加，则需要扩容table容量为16，临界值(threshold)为12(16*0.75)。
    5. 以后再扩容，则需要扩容table容量为原来的2倍(32)，临界值为原来的2倍,即24,依次类推。
    6. 在Java8中,如果一条链表的元素个数超过TREEIFY_THRESHOLD(默认是8),并且table的大小 >= MIN_TREEIFY_ CAPACITY(默认64),就会进行树化(红黑树)。
    5.HashTable
    1.HashTable的基本介绍
    1. 存放的元素是键值对：即K-V
    1. hashtable的键和值都不能为null，否则会抛出NullPointerException。
    2. hashTable使用方法基本上和HashMap一样。
    3. hashTable是线程安全的，hashMap是线程不安全的。
    2.HashTable的底层说明
    1. 底层有数组 Hashtable$Entry[]初始化大小为11。
    2. 临界值 threshold 8 = 11 * 0.75。
    3. 扩容：按照自己的扩容机制来进行即可。
    4. 执行方法 addEntry(hashT key,value，index);添加K-V封装到Entry。
    5. 当if (count >= threshold)满足时，就进行扩容。
    6. 按照int newCapacity =(oldCapacity <<1)+1;的大小扩容。
    6.HashMap和HashTable的比较
    版本线程安全（同步）效率允许null键null值
    HashMap1.2不安全高允许
    HashTable1.0安全低不允许
    7.TreeMap的源码分析
    public class TreeMap_ {
    public static void main(String[] args) {

        //使用默认的构造器，创建TreeMap, 是无序的(也没有排序)
        /*
            按照传入的 k(String) 的大小进行排序
         */
//        TreeMap treeMap = new TreeMap();
        TreeMap treeMap = new TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                //按照传入的 k(String) 的大小进行排序
                //按照K(String) 的长度大小排序
                //return ((String) o2).compareTo((String) o1);
                return ((String) o2).length() - ((String) o1).length();
            }
        });
        treeMap.put("jack", "杰克");
        treeMap.put("tom", "汤姆");
        treeMap.put("kristina", "克瑞斯提诺");
        treeMap.put("smith", "斯密斯");
        treeMap.put("hsp", "京津冀");//加入不了k的长度相同

        System.out.println("treemap=" + treeMap);

        /*

            1. 构造器. 把传入的实现了 Comparator接口的匿名内部类(对象)，传给给TreeMap的comparator
             public TreeMap(Comparator comparator) {
                this.comparator = comparator;
            }
            2. 调用put方法
            2.1 第一次添加, 把k-v 封装到 Entry对象，放入root
            Entry t = root;
            if (t == null) {
                compare(key, key); // type (and possibly null) check

                root = new Entry<>(key, value, null);
                size = 1;
                modCount++;
                return null;
            }
            2.2 以后添加
            Comparator cpr = comparator;
            if (cpr != null) {
                do { //遍历所有的key , 给当前key找到适当位置
                    parent = t;
                    cmp = cpr.compare(key, t.key);//动态绑定到我们的匿名内部类的compare
                    if (cmp < 0)
                        t = t.left;
                    else if (cmp > 0)
                        t = t.right;
                    else  //如果遍历过程中，发现准备添加Key 和当前已有的Key 相等，就不添加
                        return t.setValue(value);
                } while (t != null);
            }
         */

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    8.Properties
    1. Properties类继承自Hashtable类并且实现了Map接口，也是使用一种键值对的形式来保存数据。
    2. 他的使用特点和Hashtable类似。
    3. Properties还可以用于从 xxx.properties文件中，加载数据到Properties类对象,并进行读取和修改
    4. 说明:工作后 xxx.properties文件通常作为配置文件。
    public class Properties_ {
    public static void main(String[] args) {

        //1. Properties 继承  Hashtable
        //2. 可以通过 k-v 存放数据，当然key 和 value 不能为 null
        //增加
        Properties properties = new Properties();
        //properties.put(null, "abc");//抛出 空指针异常
        //properties.put("abc", null); //抛出 空指针异常
        properties.put("john", 100);//k-v
        properties.put("lucy", 100);
        properties.put("lic", 100);
        properties.put("lic", 88);//如果有相同的key ， value被替换

        System.out.println("properties=" + properties);

        //通过k 获取对应值
        System.out.println(properties.get("lic"));//88

        //删除
        properties.remove("lic");
        System.out.println("properties=" + properties);

        //修改
        properties.put("john", "约翰");
        System.out.println("properties=" + properties);


    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    3.如何选择集合实现类

    在开发中，选择什么集合实现类，主要取决于业务操作特点，然后根据集合实现类特性进行选择，分析如下:

    1. 先判断存储的类型(一组对象[单列]或一组键值对[双列])

    2. 一组对象[单列]：Collection接口

      允许重复：List
      增删多：LinkedList[底层维护了一个双向链表]

      ​ 改查多：ArrayList[底层维护Object类型的可变数组]
      不允许重复：Set
      ​ 无序：HashSet[底层是HashMap，维护了一个哈希表即(数组+链表+红黑树)]

      ​ 排序：TreeSet

      ​ 插入和取出顺序一致：LinkedHashSet，维护数组+双向链表

    3. 一组键值对[双列]：Map

      键无序：HashMap [底层是：哈希表 jdk7：数组+链表，jdk8：数组+链表+红黑树]

      键排序：TreeMap

      键插入和取出顺序一致：LinkedHashMap

      读取文件：Properties

      [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RakGYB0L-1661136945921)(C:\Users\w’y’x\AppData\Roaming\Typora\typora-user-images\image-20220804104250620.png)]

    4.Collections工具类
    1.Collections工具类介绍
    1. Collections是一个操作 Set、List和 Map 等集合的工具类
    2. Collections中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作
    2.排序操作:(均为static方法)
    1. reverse(List):反转 List中元素的顺序
    2. shuffle(List):对List集合元素进行随机排序
    3. sort(List):根据元素的自然顺序对指定List集合元素按升序排序
    4. sort(List, Comparator):根据指定的Comparator产生的顺序对List集合元素进行排序
    5. swap(List，int，int):将指定list集合中的i处元素和j处元素进行交换
    3.查找、替换
    1. Object max(Collection):根据元素的自然顺序，返回给定集合中的最大元素
    2. Object max(Collection, Comparator):根据Comparator指定的顺序,返回给定集合中的最大元素
    3. Object min(Collection)
    4. Object min(Collection, Comparator)
    5. int frequency(Collection, Object):返回指定集合中指定元素的出现次数
    6. void copy(List dest,List src):将src中的内容复制到dest中
    7. boolean replaceAll(List list,Object oldVal, Object newVal):使用新值替换List对象中的所有旧值
    public class Collections_ {
    public static void main(String[] args) {

        //创建ArrayList 集合，用于测试.
        List list = new ArrayList();
        list.add("tom");
        list.add("smith");
        list.add("king");
        list.add("milan");
        list.add("tom");


//        reverse(List)：反转 List 中元素的顺序
        Collections.reverse(list);
        System.out.println("list=" + list);
//        shuffle(List)：对 List 集合元素进行随机排序
//        for (int i = 0; i < 5; i++) {
//            Collections.shuffle(list);
//            System.out.println("list=" + list);
//        }

//        sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
        Collections.sort(list);
        System.out.println("自然排序后");
        System.out.println("list=" + list);
//        sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
        //我们希望按照 字符串的长度大小排序
        Collections.sort(list, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                //可以加入校验代码.
                return ((String) o2).length() - ((String) o1).length();
            }
        });
        System.out.println("字符串长度大小排序=" + list);
//        swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换

        //比如
        Collections.swap(list, 0, 1);
        System.out.println("交换后的情况");
        System.out.println("list=" + list);

        //Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
        System.out.println("自然顺序最大元素=" + Collections.max(list));
        //Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
        //比如，我们要返回长度最大的元素
        Object maxObject = Collections.max(list, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return ((String)o1).length() - ((String)o2).length();
            }
        });
        System.out.println("长度最大的元素=" + maxObject);


        //Object min(Collection)
        //Object min(Collection，Comparator)
        //上面的两个方法，参考max即可

        //int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
        System.out.println("tom出现的次数=" + Collections.frequency(list, "tom"));

        //void copy(List dest,List src)：将src中的内容复制到dest中

        ArrayList dest = new ArrayList();
        //为了完成一个完整拷贝，我们需要先给dest 赋值，大小和list.size()一样
        for(int i = 0; i < list.size(); i++) {
            dest.add("");
        }
        //拷贝
        Collections.copy(dest, list);
        System.out.println("dest=" + dest);

        //boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所有旧值
        //如果list中，有tom 就替换成 汤姆
        Collections.replaceAll(list, "tom", "汤姆");
        System.out.println("list替换后=" + list);

        
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    5.HashSet和TreeSet如何实现去重的

    1. HashSet的去重机制

      hashCode() + equals() ，底层先通过存入对象，进行运算得到一个hash值，通过hash值得到对应的索引，如果发现table索引所在的位置,没有数据，就直接存放，如果有数据，就进行equals比较[遍历比较]，如果比较不相同，就加入，否则就不加入。

    2. TreeSet的去重机制

      如果你传入了一个Comparator匿名对象，就使用实现的compare去重，如果方法返回0,就认为是相同的元素/数据，就不添加，如果你没有传入一个Comparator匿名对象，则以你添加的对象实现的Compareable接口的compareTo去重。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BFiTZ74Z-1661136945922)(C:\Users\w’y’x\AppData\Roaming\Typora\typora-user-images\image-20220809174323819.png)]

  • 相关阅读:
    【AI理论学习】语言模型：深入理解GPT-2计算掩码自注意力过程，了解GPT-3工作原理
    跨境运营培训品牌商店设计技巧
    Qt实现控件的折叠收起和展开的功能
    lspci源码
    C++实现类似QT中的计时器QTime类(CQTime)
    24、Flink 的table api与sql之Catalogs（java api操作视图）-3
    单链表的实现
    Python(七) 元组
    java计算机毕业设计呼和浩特市盈锐机电设备有限公司财务管理系统MyBatis+系统+LW文档+源码+调试部署
    【简单教程】利用Net2FTP构建免费个人网盘，实现便捷的文件管理
  • 原文地址：https://blog.csdn.net/m0_54024106/article/details/126461720