【JavaSE】之集合框架

柔情只为你懂 2024-04-03 10:01 107阅读 0赞

#### 【JavaSE】集合框架 ####

*  前言
 *  一、集合框架体系
 *  二、List
 *   *  1.数组扩容
     *  2.迭代器 : 只服务于Collection接口下的集合
     *  3.ArrayList
     *  4.LinkedList
     *  5. ArrayList和LinkedList的区别
     *  6.foreach的本质
     *  7.Vector
     *  8.Stack
 *  三、Queue
 *   *  1.队列的定义
     *  2.队列的使用
 *  四、Set
 *   *  1.TreeSet
     *  2.HashSet
 *  五、Map
 *   *  1.HashMap
     *  2.TreeMap
     *  3.HashTabl
     *  六.集合工具类Collections
 *  后记

--------------------

## 前言 ##

本文为Java集合框架相关知识，**Java全栈学习路线可参考：**[【Java全栈学习路线】最全的Java学习路线及知识清单，Java自学方向指引][Java_Java_Java]，内含最全Java全栈学习技术清单~

## 一、集合框架体系 ##

![在这里插入图片描述][02b4e62d56c64e8fb3d41d42238b05a9.png_pic_center]  
![在这里插入图片描述][ef1a26e67a3348fea60ea18fc87d7c7a.png_pic_center]

## 二、List ##

### 1.数组扩容 ###

// 扩容方法和位运算
    public class Demo01 {
        
        public static void main(String[] args) {
        
            int[] arr= new int[4];
            arr[0] = 10;
            arr[1] = 11;
            arr[2] = 12;
            arr[3] = 13;
            arr = grow(arr);
            System.out.println(arr.length);
        }
        public static int[] grow(int[] arr){
        
            //int[] newArr = new int[arr.length+arr.length/2];
            //  >>1  位运算  二进制向右移一位变成原来的 一半
            //  1<<          二进制向左移一位变成元的的 一倍
            int[] newArr = new int[arr.length+arr.length>>1];
            /**
               方法一：
             */
            for (int i = 0; i < arr.length; i++) {
        
                newArr[i] = arr[i];
            }
            /**
             *  方法二：
             */
            System.arraycopy(arr , 0 ,newArr,0,arr.length);
            /**
             *  方法三：
             */
            newArr = Arrays.copyOf(arr, arr.length+arr.length/2);
            return newArr;
        }
    }

### 2.迭代器 : 只服务于Collection接口下的集合 ###

**Iterator**

*  hasNext() 如果迭代具有更多元素，则返回 true 。
 *  next() 返回迭代中的下一个元素。
 *  remove() 从底层集合中删除此迭代器返回的最后一个元素（可选操作）。

// 使用Iterator 迭代器
        public static void print(ArrayList<Person> list){
        
            Iterator<Person> iterator = list.iterator();
            while (iterator.hasNext()){
        
                Person person = iterator.next();
                System.out.println(person.getName() + "\t" + person.getAge());
            }
        }

**ListIterator**

*  void add(E e) ：将指定的元素插入列表（可选操作）。
 *  boolean hasNext()：如果此列表迭代器在向前方向遍历列表时具有更多元素，则返回 true 。
 *  boolean hasPrevious()：如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回 true 。
 *  E next() 返回列表中的下一个元素，并且前进光标位置。
 *  int nextIndex() 返回由后续调用返回的元素的索引 next() 。
 *  E previous()返回列表中的上一个元素，并向后移动光标位置。
 *  int previousIndex() 返回由后续调用返回的元素的索引 previous()。
 *  void remove() 从列表中删除 next()或 previous() （可选操作）返回的最后一个元素。
 *  void set(E e) 用指定的元素（可选操作）替换 next()或 previous()返回的最后一个元素。

public static void itRepeat(ArrayList<Person> list){
        
            System.out.println("去除重复元素：");
            // 使用ListIterator 接口可以实现从指定位置迭代集合
            ListIterator<Person> iterator;
            for (int i = 0; i < list.size() ; i++) {
        
               iterator = list.listIterator(i+1);
               while (iterator.hasNext()){
        
                   Person person = iterator.next();
                   if (list.get(i).equals(person)){
        
                       iterator.remove();
                       System.out.println("即将被删除：..."+person);
                   }
               }
            }
        }

**Iterator VS ListIterator**

*  ListIterator有add()方法，可以向List中添加对象，而Iterator没有
 *  ListIterator和Iterator都有hasNext() 和 next() 方法，但ListIterator可以实现指定位置遍历，并且可以顺序遍历和逆序遍历。
 *  ListIterator有set方法，可以在遍历中修改对象。

### 3.ArrayList ###

*  有序可重复 ，底层是动态数组实现 —— 线程不安全
 *  添加数据，如果是基本数据类型会自动装箱为包装类，第一次添加数组长度为10
 *  存储的数据超过数组长度，会自动进行数组扩容，扩容为原来的1.5倍
 *  集合长度有限，最大容量默认为： Integer.MAX\_VALUE-8
 *  为什么空8位出来： 1、存储Headerwords；2、避免一些机器内存溢出，减少出错几率，所以少分配；3、最大还是能支持到Integer.MAX\_VALUE(2^31 -1)

public class Test{
        
        public static void main(String[] args) {
        
            ArrayList list = new ArrayList();
            // 1、添加元素  ——  如果数据是基本数据类型会自动装箱为包装类
            list.add(1);
            list.add("a");
            list.add(true);
            list.add(10.1);
            list.add(2);
            // 2、删除元素 —— 根据下标删除
            list.remove(1);
            // 根据对象删除
            list.remove(new Integer(2));
            // 3、修改
            list.set(1,"b");
            // 4、遍历集合
            print(list);
        }
        public static void print(ArrayList list){
        
            System.out.println("-------- for循环 ----------");
            for (int i = 0; i < list.size() ; i++) {
        
                System.out.print(list.get(i) + "\t");
            }
            System.out.println();
            System.out.println("=========== 迭代器循环 =========");
            Iterator iterator = list.iterator();
            while (iterator.hasNext()){
        
                System.out.print(iterator.next() + "\t");
            }
            System.out.println();
        }
    }

### 4.LinkedList ###

*  底层是 双向链表 实现 —— 线程不安全
 *  第一次添加对象，把对象添加到Node节点中，falst指向第一个节点，不存在索引
 *  集合长度无限

//  创建 LinkedList 对象
    LinkedList list = new LinkedList();
    list.add("111"); //添加一个新元素，默认尾部添加
    list.add("222");
    list.add("333");
    list.addFirst("444"); //在头部添加一个新元素
    list.addLast("555"); //在尾部添加一个新元素
    Object data1=list.removeFirst(); //移除头部元素并返回值
    System.out.println(data1); 
    Object data2=list.removeLast(); //移除尾部元素并返回值
    System.out.println(data2);
    list.getFirst(); // 获取头部元素并返回值
    list.getLast(); // 获取尾部元素并返回值
    for(Object object : list){
        
        System.out.println(object);
    }
    //  其他方法的使用与 ArrayList一致

### 5. ArrayList和LinkedList的区别 ###

*  数据结构的实现不同。 ArrayList是动态数组实现，LinkedList是双向链表实现
 *  List item查询的效率。ArrayList有下标查询速度快，而LinkedList底层是链表结构，查询需从头开始依次往下查找
 *  增删的效率。在排除增删前后两头的情况下，LinkedList的速度比ArrayList的快，因为LinkedList的添加和删除节点，只要其他节点的前驱后继指引值发生变化，而ArrayList增加删除会更改数组的结构

### 6.foreach的本质 ###

*  使用foreach来遍历集合的话，本质上是将其转换为迭代器来使用

System.out.println("=========== foreach循环 =========");
    for (Object obj:list) {
        
        System.out.print(obj+"\t");
    }
    System.out.println();
    
    // 等价于下边代码
    
    System.out.println("=========== foreach循环 =========");
    Iterator iterator = list.iterator();
    
    while(iterator.hasNext()) {
        
        Object obj = iterator.next();
        System.out.print(obj+"\t");
    }

### 7.Vector ###

*  数组结构实现，查询快、增删慢。
 *  JDK1.0版本，线程安全、运行效率比ArrayList较慢。

public class TestVector {
        
        public static void main(String[] args) {
        
            //创建集合
            Vector vector=new Vector<>();
            //1添加元素
            vector.add("草莓");
            vector.add("芒果");
            vector.add("西瓜");
            System.out.println("元素个数:"+vector.size());
            //2删除
    //        vector.remove(0);
    //        vector.remove("西瓜");
    //        vector.clear();
            //3遍历
            //使用枚举器
            Enumeration en=vector.elements();
            while(en.hasMoreElements()) {
        
                String  o=(String)en.nextElement();
                System.out.println(o);
            }
            //4判断
            System.out.println(vector.contains("西瓜"));
            System.out.println(vector.isEmpty());
            //5vector其他方法
            //firsetElement、lastElement、elementAt();        
        }
    }

### 8.Stack ###

*  模拟 栈 的实现 —— 底层用数组存储数据
 *  特点是：先进后出

public class Demo05 {
        
        public static void main(String[] args) {
        
            Stack stack = new Stack();
            // 添加元素
            // Stack类的add方法与push方法区别：
            //         add方法返回的是boolean类型的值
            //         push方法返回的是当前添加的元素
            stack.push("a");
            stack.push("b");
            stack.add("c");
            stack.push("d");
            // 集合中的元素个数
            System.out.println(stack.size());
            // 弹出栈顶元素
            System.out.println(stack.pop());
            System.out.println(stack.pop());
        }
    }

## 三、Queue ##

### 1.队列的定义 ###

*  队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。
 *  队列是一种先进先出（First In First Out）的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端称为队头。
 *  队头（first）：允许删除的一端，又称队首。
 *  队尾（Rearlsat：允许插入的一端。
 *  空队列：不包含任何元素的空表。

### 2.队列的使用 ###

public class Demo01 {
        
        public static void main(String[] args) {
        
            Queue<String> queue = new LinkedList<>();
            queue.add("小明"); // 向队列添加元素，当队列满时，add方法抛出unchecked异常，而offer方法返回false。
            queue.offer("小黑");
            queue.offer("小蓝");
            queue.offer("小而");
            // 集合中的个数 
            System.out.println(queue.size()); // 4
            // 查询头部元素:如果队列为空，element方法会抛出异常，peek方法会返回null
            System.out.println(queue.element()); // 小明
            System.out.println(queue.peek()); // 小明
            // 打印队列头  
            System.out.println(queue.poll()); // 小明 ,如果队列为空，remove方法会抛出异常，poll方法会返回null。
            System.out.println(queue.size()); // 3
            System.out.println(queue.remove()); // 小黑
        }
    }

## 四、Set ##

### 1.TreeSet ###

**定义：**

*  可排序的集合；
 *  不能存储空对象；
 *  底层是红黑树；
 *  使用TreeSet 存储对象必须要使用自然排序或者比较器

**自然排序**

*  要存储的对象 必须实现了 Comparable 接口，并重写了 compareTo()
 *  在 compareTo() 方法中 制定了比较规则
 *  存储的对象 通过 与 之前的节点对比，返回正数则在 节点的右子树；负数则存储在左子数；返回 0 不存储对象（重复了）

// 实体类实现接口
    public class Person implements Comparable<Person> {
        
        private int id;
        private String name;
        private int age;
        /**
         * 重写CompereTo 接口
         *      要求：  id 从大到小
         *             id相同，age从小到大
         * @param o
         * @return
         */
        @Override
        public int compareTo(Person o) {
        
            if (this.id == o.getId()){
        
                return this.age-o.getAge() ;
            }
            return o.getId() - this.id ;
        }
    }
    // 测试
    public class Demo02 {
        
        public static void main(String[] args) {
        
            TreeSet<Person> people = new TreeSet<>();
            people.add(new Person(1,"ls",44));
            people.add(new Person(1,"zs",12));
            people.add(new Person(8,"t7",14));
            people.add(new Person(7,"t7",14));
            people.forEach(item -> System.out.println(item));
        }
    }

**比较器**

*  在创建TreeSet集合的时候，通过构造方法传递实现了Comparator接口的实现类对象
 *  实现类对象要重写了compare()方法，在方法里面制定排序规则

// 比较器
    public class MyCompartor implements Comparator<Person> {
        
        /**
         * id从小到大
         * id相同，age从大到小
         * @param o1 存储的对象
         * @param o2 上一个节点的对象
         * @return
         */
        @Override               // 11         88
        public int compare(Person o1, Person o2) {
        
            if (o1.getId() != o2.getId())
                return o1.getId()-o2.getId();
            return o2.getAge()-o1.getAge();
        }
    }
    // 测试
    public class Demo03 {
        
        public static void main(String[] args) {
        
            // 通过构造方法传入 比较器
    /*
            TreeSet<Person> people = new TreeSet<>(new MyCompartor());
            people.add(new Person(1,"ls",44));
            people.add(new Person(1,"zs",12));
            people.add(new Person(8,"t7",14));
            people.add(new Person(7,"t7",14));
            people.forEach(item -> System.out.println(item));
    */
            // 匿名内部类
            TreeSet<Person> people = new TreeSet<>(new Comparator<Person>(){
        
                @Override
                public int compare(Person o1, Person o2) {
        
                    if (o1.getId() != o2.getId())
                        return o1.getId()-o2.getId();
                    return o2.getAge()-o1.getAge();
                }
            });
            people.add(new Person(1,"ls",44));
            people.add(new Person(1,"zs",12));
            people.add(new Person(8,"t7",14));
            people.add(new Person(7,"t7",14));
            people.forEach(item -> System.out.println(item));
        }
    }

**自然排序 VS 比较器**

*  比较器的优先级别高于自然排序
 *  自然排序需要存储的对象类结构发生改变（实现了 Comparable 接口，并重写compereTo方法）
 *  自然排序的可读性更高，并且排序规则不可见
 *  比较器会创建多一个类

### 2.HashSet ###

**什么是有序和无序？**

*  有序： 根据添加的顺序先后，遍历时以同样的顺序输出
 *  无序： 遍历输出 与 添加时的顺序无关（**HashSet是无序的**）

**版本：**

*  JDK1.7 : 底层 hash表（不可变） + 链表
 *  JDK1.8 : 底层 hash表（动态数组） + 链表 + 红黑树

**重点:**

*  存储的对象通过hashCode（）得到hash值，根据hash值找到在hash表中对应的位置
 *  再根据equals() 判断是否内容相等，内容相等则不存储
 *  当hash表中的对象超过容量的负载因子数时，进行数组扩容，容量为原来的2倍
 *  当一个链表中的对象超过8个，则会转换为红黑树

public class Demo02 {
        
        public static void main(String[] args) {
        
            HashSet<Integer> hashSet = new HashSet<>();
            hashSet.add(12);
            hashSet.add(11);
            hashSet.add(22);
            hashSet.add(22);
            // lambda表达式 ，打印结果
            hashSet.forEach(item -> System.out.println(item));
            // 输出：22 11 12 ，说明HashSet是无序的
        }
    }

## 五、Map ##

### 1.HashMap ###

**特点：**

*  无序，key不可重复  
    **简单使用：**
 *  key，value都可以为null， key为null的时候存储在HashMap的第一个位置
 *  当key相同时，新的value会覆盖旧的value

public class Demo01 {
        
        public static void main(String[] args) {
        
            HashMap<String, Integer> map = new HashMap<>();
            // 1、添加
            map.put("a",13);
            map.put("b",12);
            map.put("c",11);
            map.put("d",678);
            map.put("a",99);  // key重复，后面添加的会覆盖前面的
            System.out.println(map); //{a=99, b=12, c=11, d=678}
            // 2、删除
            // 根据key删除
            map.remove("a");
            // 根据key value 删除
            map.remove("c",11);
            // 3、修改
            // 根据key 修改value
            map.replace("b",88);
            // 4、打印
            System.out.println(map); //{b=88, d=678}
            // 5、遍历 for不可用
            System.out.println("----------- 使用keyset方法转换为保存key值的set集合 ------------");
            // 将 map 中的key值存储到 set集合中，set能调用的遍历方法他也能
            Set<String> set1 = map.keySet();
            Iterator<String> iterator1 = set1.iterator();
            while (iterator1.hasNext()){
        
                String key = iterator1.next();
                System.out.println("key:"+key +",value:"+map.get(key));
            }
            System.out.println("----------- 使用entrySet方法转换为保存key，value 的Set集合 ------------");
            // 将key，value 保存再Map类的内部类 Entry 类中
            Set<Map.Entry<String, Integer>> set2 = map.entrySet();
            Iterator<Map.Entry<String, Integer>> iterator2 = set2.iterator();
            while (iterator2.hasNext()){
        
                Map.Entry<String, Integer> entry = iterator2.next();
                System.out.println("key:"+entry.getKey() + ",value:"+entry.getValue());
            }
        }
    }

### 2.TreeMap ###

**特点：**

*  底层是红黑树 ，无序 key不可重复  
    **简单使用：**
 *  存储映射的关系过程中，需要key使用 自然排序或传递比较器（比较器根据key进行排序）
 *  key不能为null ，value可以为null
 *  添加相同 key 时，新的value会覆盖旧的value（底层：自然排序的compareTo() 或比较器compare()  
    方法返回值为0，调用t.setValue(value),实现新的值覆盖旧的值）

public class Demo02 {
        
        public static void main(String[] args) {
        
            System.out.println("--------------TreeMap-----------------");
            TreeMap<String, Integer> treeMap = new TreeMap<>();
            treeMap.put("a",1);
            treeMap.put("a",2);
            // treeMap.put(null,1);
            treeMap.put("b",null);
            System.out.println(treeMap);
            //{a=2, b=null}
            System.out.println("--------------HashMap-----------------");
            HashMap<String, Integer> hashMap = new HashMap<>();
            hashMap.put("a",11);
            hashMap.put(null,11);
            hashMap.put("b",null);
            System.out.println(hashMap);
            //{null=11, a=11, b=null}
        }
    }

### 3.HashTabl ###

**特点：**

*  无序，key不可重复

**简单使用：**

*  key，value都不能为空

public class Demo03 {
        
        public static void main(String[] args) {
        
            Hashtable<String, Integer> hashtable = new Hashtable<>();
            hashtable.put("a",1);
            hashtable.put("c",2);
            //hashtable.put(null,2);    NullPointerException
            //hashtable.put("d",null);  NullPointerException
            System.out.println(hashtable);
        }
    }

### 六.集合工具类Collections ###

Java提供了一个操作Set、List和Map等集合的工具类：Collections，该工具类里提供了大量方法对集合元素进行排序、查询和修改等操作，还提供了对集合对象实现同步控制等方法。

**排序操作：排序相关的、顺序相关的功能**

*  reverse()：反转指定列表中元素的顺序
 *  shuffle()：使用默认随机源对指定列表进行置换(每一次的顺序都不一样)或者打乱顺序 :打乱集合顺序
 *  sort()：根据指定比较器产生的顺序对指定列表进行排序(默认从小到大)或者在指定列表的指定位置处交换元素。注意：sort(list)有使用前提：被排序的集合元素必须实现了Comparable接口，重写接口中的compareTo方法定义排序的规则；
 *  swap()：交换一下顺序 rotate()：根据指定的距离轮换指定列表中的元素

**查找和替换操作**

*  max()：根据元素的自然顺序，返回给定 collection 的最大元素
 *  min()：根据元素的自然顺序，返回给定 collection 的最小元素
 *  replaceAll()：使用另一个值替换列表中出现的所有某一指定值 frequency()返回指定 collection中等于指定对象的元素数
 *  binarySearch()：使用二分搜索法搜索指定列表，以获得指定对象。
 *  indexOfSubList()：查找子列表在列表中第一次出现的位置，没有返回-1
 *  lastIndexOfSubList()：查找子列表在列表中最后一次出现的位置，没有返回-1
 *  fill()：使用指定元素替换指定列表中的所有元素

**同步控制**

*  Collections类中提供了多个synchronized…()方法，这些方法可以将指定集合包装成线程同步（线程安全）的集合，从而可以解决多线程并发访问集合时的线程安全问题。
 *  Java中常用的集合框架中的实现类 ArrayList、Linkedlist、 HashSet、TreeSet、HashMap和TreeMap 都是线程不安全的。如果有多个线程访问它们，而且有超过一个的线程试图修改它们，则存在线程安全的问题。
 *  Collections提供了多个类方法可以把它们包装成线程同步的集合。

**代码示例：**

public class CollectionsTest {
        
        public static void main(String[] args) {
        
            ArrayList<Integer> list1 = new ArrayList<>();
            list1.add(9);
            list1.add(2);
            list1.add(2);
            Integer[] arr = {
        7,6,9};
    // addAll(Collection<? super T> c, T... elements) 将所有指定的元素添加到指定的集合。
            Collections.addAll(list1,4,5,6);
            Collections.addAll(list1,arr);
            // 打印集合
            System.out.println(list1);//[9, 2, 2, 4, 5, 6, 7, 6, 9]
            // 对集合元素进行排序
            Collections.sort(list1);
            System.out.println(list1);//[2, 2, 4, 5, 6, 6, 7, 9, 9]
        }
    }

## 后记 ##

**Java全栈学习路线可参考：**[【Java全栈学习路线】最全的Java学习路线及知识清单，Java自学方向指引][Java_Java_Java]，内含最全Java全栈学习技术清单~

[Java_Java_Java]: https://blog.csdn.net/qq_42146402/article/details/127133435
[02b4e62d56c64e8fb3d41d42238b05a9.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/658e013adc9447c6bb91e3b11812e03c.png
[ef1a26e67a3348fea60ea18fc87d7c7a.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/445b2b7376c84e38ada24b2c64ca1312.png