Java集合开荒

喜欢ヅ旅行 2022-12-29 00:16 30阅读 0赞

### 文章目录 ###

*  1 Java集合框架概述
 *  2 Collection接口方法
 *  3 iterator迭代器接口
 *   *   *  3.2 iterator接口的方法
 *  4 Collection子接口一：List
 *   *   *  4.1 ArrayList
         *   *  ArrayList常用方法
             *  ArrayList遍历方法
         *  4.2 LinkedList
 *  5 Collection子接口二：Set
 *   *  5.1 HashSet
     *   *   *  Set add过程
     *  5.2 LinkedHashSet
     *  5.3 TreeSet
 *  6 Map接口
 *   *   *   *  Map结构的理解
             *  HashMap底层实现原理7.0
         *  6.3 TreeMap
         *  6.4 Hashtable
         *  6.5 Properties
 *  7 Collections工具类

# 1 Java集合框架概述 #

**数组的特点**

*  初始化之后，长度就确定了
 *  声明地类型，就决定了进行元素初始化时的类型

**数组存储方面的弊端**

*  初始化之后，长度就不可变了，不利于扩展
 *  数组提供的方法 & 属性都相对较少，不便于进行添加、删除、插入等操作，效率不高
 *  数组存储的数据是有序的，可以重复的

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 2]

# 2 Collection接口方法 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 3]

public class CollectionTest {
        
    
        @Test
        public void test1(){
        
            Collection coll = new ArrayList();
    
            //1 add(Object e) 将元素e添加到集合coll中
            coll.add("AA");
            coll.add("BB");
            coll.add("123");
            coll.add(new Date());
    
            //2 size() 获取添加的元素的个数
            System.out.println(coll.size());
    
            //3 addAll() 将coll1 中的元素添加到集合中
            Collection coll1 = new ArrayList();
            coll1.add("456");
            coll1.add("CC");
    
            coll.addAll(coll1);
            System.out.println(coll.size());//6
    
            //4 isEmpty() : 判断集合是否为空
            System.out.println(coll.isEmpty());
    
            //5 contains(Object obj):判断当前集合中是否包含obj , 会调用obj所在类的equls()
            boolean contains = coll.contains(123);
            System.out.println(contains);
            System.out.println(coll.contains(new String("Tom")));//true 说明调用的是equls
            System.out.println(coll.contains(new Person("Jerry",23)));//需要Person类重写equls
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 4]

@Test
        public void remove(){
        
            // 3 remove(Objcet obj)
            Collection coll = new ArrayList();
            coll.add(123);
            coll.add(456);
            coll.add(43);
            coll.add(new Person("Jerry",23));
    
            coll.remove(23);
            System.out.println(coll);
    
            //6 remove(Object obj)
            coll.remove(new Person("Jerry",23));
    
            // removeAll(Collection coll1):从当前集合中移除coll1 中所有的元素
    //        coll.removeAll(coll);//差集  自己删除自己 就空了
    //        System.out.println(coll);
    
            //7 retainAll：求交集,删掉不一样的
    //        System.out.println(coll.retainAll(coll));
    
            //8 equals(Object obj):一个一个的对象进行比较，有序的
    
            //9 转换成数组 toArray()
            System.out.println(coll.toArray());
            Object[] objects = coll.toArray();
            for(int i = 0 ;i < objects.length;i ++){
        
                System.out.println(objects[i]);
            }
    
            //10 hashCode():返回当前对象的hash
            System.out.println(coll.hashCode());

# 3 iterator迭代器接口 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 5]

### 3.2 iterator接口的方法 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 6]

//方式1
    //        System.out.println(iterator.next());
    //        System.out.println(iterator.next());
    //        System.out.println(iterator.next());
    //        System.out.println(iterator.next());
    //        System.out.println(iterator.next());//NoSuchElementException
            //方式二
    //        for(int i = 0 ;i < coll.size();i++){
        
    //            System.out.println(iterator.next());
    //        }
            //方式三 推荐
            while (iterator.hasNext()){
        
                System.out.println(iterator.next());
            }

![在这里插入 图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 7]

//增强for(集合元素的类型：集合对象)
            for(Object obj : coll){
        
                System.out.println(obj);
            }

# 4 Collection子接口一：List #

*  Java的数组用来存储数据的局限性，通常使用List替代接口
 *  List 元素有序、且可重复，集合中的每个元素都有对应的顺序索引
 *  每个元素都有对应的序号

*   |-----collection接口：单列集合，用来存储一个一个的对象
    *       |-----List接口：存储有序的、可重复使用的数据  -> "动态数组"，替换原有数组（1.2）
    *           |-----ArrayList (List接口的主要实现类)（1.2）线程不安全 底层使用Obj[]存储
    *           |-----LinkedList（1.2）频繁插入删除操作，效率高   底层使用双向链表存储
    *           |-----Vector (List接口的古老实现类1.0 )线程安全 底层使用Obj[]存储

### 4.1 ArrayList ###

#### ArrayList常用方法 ####

源码分析：JDK7 & JDK8 稍有不同
     *   2.1 jdk 7情况下
     *      ArrayList list = new ArrayList();//底层创建了长度是10的Object[]数组elementData
     *      list.add(123);//elementData[0] = new Integer(123);
     *      ...
     *      list.add(11);//如果此次的添加导致底层elementData数组容量不够，则扩容。
     *      默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中。
     *
     *      结论：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity)
     *
     *   2.2 jdk 8中ArrayList的变化：
     *      ArrayList list = new ArrayList();//底层Object[] elementData初始化为{}.并没有创建长度为10的数组
     *
     *      list.add(123);//第一次调用add()时，底层才创建了长度10的数组，并将数据123添加到elementData[0]
     *      ...
     *      后续的添加和扩容操作与jdk 7 无异。
     *   2.3 小结：jdk7中的ArrayList的对象的创建类似于单例的饿汉式，而jdk8中的ArrayList的对象
    
     *            的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。

*  void add(int index, Object ele):在index位置插入ele元素
 *  boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
 *  Object get(int index):获取指定index位置的元素
 *  int indexOf(Object obj):返回obj在集合中首次出现的位置
 *  int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
 *  Object remove(int index):移除指定index位置的元素，并返回此元素
 *  Object set(int index, Object ele):设置指定index位置的元素为ele
 *  List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合

//1 add
            list.add(0,45);
            System.out.println(list);
    
            //2 addAll
            List<Integer> list1 = Arrays.asList(1, 2, 3);
            list.addAll(list1);
            System.out.println(list.size());
    
            //3 get
            System.out.println(list.get(3));
    
            //4 indexOf 返回第一次出现的索引位置
            int i = list.indexOf(456);
            System.out.println(i);
    
            //5 lastindexOf 返回最后一次出现的索引位置
    
            //6 remove(int index):移除指定位置的元素，并返归该元素
            System.out.println(list.remove(4));
            System.out.println(list);
    
            //7 set
            list.set(1,"CC");
            
            //8 sublist(int fromIndex,int endIndex):返回左闭右开的子集合
            List list2 = list.subList(2, 5);
            System.out.println(list2);

#### ArrayList遍历方法 ####

**// 方式1 ： iterator迭代器**

// 方式1 ： iterator迭代器
            Iterator iterator = list.iterator();
            while (iterator.hasNext()){
        
                System.out.println(iterator.next());
            }

**// 方式2 ：增强for循环**

// 方式2 ：增强for循环
            for(Object obj : list){
        
                System.out.println(obj);
            }

**//方式3：普通for循环**

//方式3：普通for循环
            for(int i = 0; i < list.size();i++){
        
                System.out.println(list.get(i));
            }

### 4.2 LinkedList ###

*  3. LinkedList的源码分析：
     *      LinkedList list = new LinkedList(); 内部声明了Node类型的first和last属性，默认值为null
     *      list.add(123);//将123封装到Node中，创建了Node对象。
     *
     *      其中，Node定义为：体现了LinkedList的双向链表的说法
     *      private static class Node<E> {
        
                 E item;
                 Node<E> next;
                 Node<E> prev;
    
                 Node(Node<E> prev, E element, Node<E> next) {
        
                 this.item = element;
                 this.next = next;
                 this.prev = prev;
                 }
             }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 8]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 9]

# 5 Collection子接口二：Set #

## 5.1 HashSet ##

*  Set接口是Collection的子接口，没有提供额外的方法
 *  不允许包含相同的元素，会添加失败
 *  Set 判断两个对象是否相等用的是 equls()

public class SetTest {
        
        /*
        * Set ： 存储无序 不可重复
        *   1 无序
        *       ！=随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据Hash值决定
        *   2 不可重复
        *       保证添加元素按照equals()判断时，若为true 则只能添加一个元素
        * */
        @Test
        public void test(){
        
            HashSet Set = new HashSet();
            Set.add("123");
            Set.add("456");
            Set.add("789");
            Set.add("AA");
            Set.add("BB");
            Set.add("BB");
            Set.add(new Person("Jerry",23));
            Set.add(new Person("Jerry",23));
            System.out.println(Set);

#### Set add过程 ####

二、添加元素的过程：以HashSet为例：
            我们向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，
            此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为：索引位置），判断
            数组此位置上是否已经有元素：
                如果此位置上没有其他元素，则元素a添加成功。 --->情况1
                如果此位置上有其他元素b(或以链表形式存在的多个元素），则比较元素a与元素b的hash值：
                    如果hash值不相同，则元素a添加成功。--->情况2
                    如果hash值相同，进而需要调用元素a所在类的equals()方法：
                           equals()返回true,元素a添加失败
                           equals()返回false,则元素a添加成功。--->情况2
    
            对于添加成功的情况2和情况3而言：元素a 与已经存在指定索引位置上数据以链表的方式存储。
            jdk 7 :元素a放到数组中，指向原来的元素。
            jdk 8 :原来的元素在数组中，指向元素a
            总结：七上八下
    
            HashSet底层：数组+链表的结构。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 10]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 11]

## 5.2 LinkedHashSet ##

LinkedHashSet是HashSet的子类  
根据元素hashCode值来决定元素的存储位置，同时使用双向链表维护元素的顺序

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 12]

## 5.3 TreeSet ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 13]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 14]

//举例二：添加Person  需要Person实现compareable接口
            TreeSet Set2 = new TreeSet();
            Set2.add(new Person("Jerry",23));
            Set2.add(new Person("Jerry",24));
            System.out.println(Set2);
            //Person cannot be cast to java.lang.Comparable

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 15]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 16]

# 6 Map接口 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 17]

* 一、Map的实现类的结构：
     *  |----Map:双列数据，存储key-value对的数据   ---类似于高中的函数：y = f(x)
     *         |----HashMap:作为Map的主要实现类；线程不安全的，效率高；存储null的key和value
     *              |----LinkedHashMap:保证在遍历map元素时，可以按照添加的顺序实现遍历。
     *                      原因：在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素。
     *                      对于频繁的遍历操作，此类执行效率高于HashMap。
     *         |----TreeMap:保证按照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然排序或定制排序
     *                      底层使用红黑树
     *         |----Hashtable:作为古老的实现类；线程安全的，效率低；不能存储null的key和value
     *              |----Properties:常用来处理配置文件。key和value都是String类型
     *
     *
     *      HashMap的底层：数组+链表  （jdk7及之前）
     *                    数组+链表+红黑树 （jdk 8）

#### Map结构的理解 ####

*  Map中的key：无序的、不可重复，使用Set来存储所有key—>key所在的类要重写equals() hashcode()
 *  Map中的value：无序的、不可重复的，使用Collection存储所有的value —>value所在的类要重写equals()
 *  一个键值对：kv 构成了一个Entry对象
 *  Mao中的entry ： 无序的、不可重复的，使用Set存储所有的entry

#### HashMap底层实现原理7.0 ####

*  new HashMap():实例化之后，底层创建了长度16的一维数组Entry\[\] table
 *  map.put(k,v) : 计算hash值，得到放在entry中的位置  
    \+ 如果位置为空，kv添加成功  
    \+ 不为空，(链表存储) ，进行hash值判断  
    \+ hash值不同，kv添加成功  
    \+ hash值相同，用 新的替换旧的 (旧的删除)

扩容机制：扩容为二倍

**JDK8.0的不同点**

*  new HashMap()：底层并没有创建一个长度为16的数组
 *  jdk 8 底层的数组为Node\[\] 而不是Entry\[\]
 *  首次调用put发方法时，创建16的数组
 *  jdk 7 底层 数组 + 链表 。jdk 8 底层 ：数组 + 链表 + 红黑树  
    \+ 形成链表时，七上八下(7.0 指向新元素指向旧元素，8.0旧元素指向新元素)  
    \+ 当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64时，此时此索引位置上的所数据改为使用红黑树存储。

*      DEFAULT_INITIAL_CAPACITY : HashMap的默认容量，16
     *      DEFAULT_LOAD_FACTOR：HashMap的默认加载因子：0.75
     *      threshold：扩容的临界值，=容量*填充因子：16 * 0.75 => 12
     *      TREEIFY_THRESHOLD：Bucket中链表长度大于该默认值，转化为红黑树:8
     *      MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量:64

添加、删除、修改操作：
     Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
     void putAll(Map m):将m中的所有key-value对存放到当前map中
     Object remove(Object key)：移除指定key的key-value对，并返回value
     void clear()：清空当前map中的所有数据
     元素查询的操作：
     Object get(Object key)：获取指定key对应的value
     boolean containsKey(Object key)：是否包含指定的key
     boolean containsValue(Object value)：是否包含指定的value
     int size()：返回map中key-value对的个数
     boolean isEmpty()：判断当前map是否为空
     boolean equals(Object obj)：判断当前map和参数对象obj是否相等
     元视图操作的方法：
     Set keySet()：返回所有key构成的Set集合
     Collection values()：返回所有value构成的Collection集合
     Set entrySet()：返回所有key-value对构成的Set集合
    
     *总结：常用方法：
     * 添加：put(Object key,Object value)
     * 删除：remove(Object key)
     * 修改：put(Object key,Object value)
     * 查询：get(Object key)
     * 长度：size()
     * 遍历：keySet() / values() / entrySet()
     *

/*
     元视图操作的方法：
     Set keySet()：返回所有key构成的Set集合
     Collection values()：返回所有value构成的Collection集合
     Set entrySet()：返回所有key-value对构成的Set集合
    
         */
    
    
        @Test
        public void test5(){
        
            Map map = new HashMap();
            map.put("AA",123);
            map.put(45,1234);
            map.put("BB",56);
    
            //遍历所有的key集：keySet()
            Set set = map.keySet();
                Iterator iterator = set.iterator();
                while(iterator.hasNext()){
        
                    System.out.println(iterator.next());
            }
            System.out.println();
            //遍历所有的value集：values()
            Collection values = map.values();
            for(Object obj : values){
        
                System.out.println(obj);
            }
            System.out.println();
            //遍历所有的key-value
            //方式一：entrySet()
            Set entrySet = map.entrySet();
            Iterator iterator1 = entrySet.iterator();
            while (iterator1.hasNext()){
        
                Object obj = iterator1.next();
                //entrySet集合中的元素都是entry
                Map.Entry entry = (Map.Entry) obj;
                System.out.println(entry.getKey() + "---->" + entry.getValue());
    
            }
            System.out.println();
            //方式二：
            Set keySet = map.keySet();
            Iterator iterator2 = keySet.iterator();
            while(iterator2.hasNext()){
        
                Object key = iterator2.next();
                Object value = map.get(key);
                System.out.println(key + "=====" + value);
    
            }
    
        }

### 6.3 TreeMap ###

//向TreeMap中添加key-value，要求key必须是由同一个类创建的对象
    //因为要按照key进行排序：自然排序 、定制排序

public class TreeMapTest {
        
    
        //向TreeMap中添加key-value，要求key必须是由同一个类创建的对象
        //因为要按照key进行排序：自然排序 、定制排序
        //自然排序
        @Test
        public void test1(){
        
            TreeMap map = new TreeMap();
            User u1 = new User("Tom",23);
            User u2 = new User("Jerry",32);
            User u3 = new User("Jack",20);
            User u4 = new User("Rose",18);
    
            map.put(u1,98);
            map.put(u2,89);
            map.put(u3,76);
            map.put(u4,100);
    
            Set entrySet = map.entrySet();
            Iterator iterator1 = entrySet.iterator();
            while (iterator1.hasNext()){
        
                Object obj = iterator1.next();
                Map.Entry entry = (Map.Entry) obj;
                System.out.println(entry.getKey() + "---->" + entry.getValue());
    
            }
        }
    
        //定制排序
        @Test
        public void test2(){
        
            TreeMap map = new TreeMap(new Comparator() {
        
                @Override
                public int compare(Object o1, Object o2) {
        
                    if(o1 instanceof User && o2 instanceof User){
        
                        User u1 = (User)o1;
                        User u2 = (User)o2;
                        return Integer.compare(u1.getAge(),u2.getAge());
                    }
                    throw new RuntimeException("输入的类型不匹配！");
                }
            });
            User u1 = new User("Tom",23);
            User u2 = new User("Jerry",32);
            User u3 = new User("Jack",20);
            User u4 = new User("Rose",18);
    
            map.put(u1,98);
            map.put(u2,89);
            map.put(u3,76);
            map.put(u4,100);
    
            Set entrySet = map.entrySet();
            Iterator iterator1 = entrySet.iterator();
            while (iterator1.hasNext()){
        
                Object obj = iterator1.next();
                Map.Entry entry = (Map.Entry) obj;
                System.out.println(entry.getKey() + "---->" + entry.getValue());
    
            }
        }
    
    
    }

### 6.4 Hashtable ###

 Hashtable是个古老的 Map 实现类，JDK1.0就提供了。不同于HashMap，  
Hashtable是线程安全的。  
 Hashtable实现原理和HashMap相同，功能相同。底层都使用哈希表结构，查询  
速度快，很多情况下可以互用。  
 与HashMap不同，Hashtable 不允许使用 null 作为 key 和 value  
 与HashMap一样，Hashtable 也不能保证其中 Key-Value 对的顺序  
 Hashtable判断两个key相等、两个value相等的标准，与HashMap一致。

### 6.5 Properties ###

Properties 类是 Hashtable 的子类，该对象用于处理属性文件  
由于属性文件里的 key、value 都是字符串类型，所以 Properties 里的 key  
和 value 都是字符串类型  
存取数据时，建议使用setProperty(String key,String value)方法和  
getProperty(String key)方法

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 18]

Properties pros = new Properties();
            FileInputStream fis = new FileInputStream("jdbc.properties");
            pros.load(fis);
            String name = pros.getProperty("name");
            String password = pros.getProperty("password");
            System.out.println(name +":"+ password);
            fis.close();

# 7 Collections工具类 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 19]  
Collections 类中提供了多个 synchronizedXxx() 方法，该方法可使将指定集  
合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全  
问题

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 20]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70]: /images/20221120/1283caea5d7a48c293326eea206e2464.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 1]: /images/20221120/b6bf75bba78b4ef3b4119d4cf2a670cd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 2]: /images/20221120/84995b758869495ab873b5718f2eddf2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 3]: /images/20221120/b422a5ae48204d9bb4ff283d2a594393.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 4]: /images/20221120/dd70d29a71f64da2aadd5d4b08286741.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 5]: /images/20221120/081675cc8432491f8af79d8f8d7403de.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 6]: /images/20221120/70b130abb0464726902017bd093bcca8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 7]: /images/20221120/d2c8a937610f40518bf24a342f869bea.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 8]: /images/20221120/b7fa068a16b043d89eda222a3d0f3f39.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 9]: /images/20221120/6ab2b7b3c97b484fb6445a4b94f215b0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 10]: /images/20221120/187130acc3394d78ad725983c81ccdaf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 11]: /images/20221120/a056e78ca32240beb1d29ff9ac1177ca.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 12]: /images/20221120/e16849b2223f4314aff19ff8a423681e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 13]: /images/20221120/1f3a660e888b4c28b457a8ab49028511.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 14]: /images/20221120/6b39f50171b44fa3bd6132922e39334b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 15]: /images/20221120/1794570ed51546729690027cf4cf6afd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 16]: /images/20221120/0058eb54982341d59b8ea7dc10ec4b6f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 17]: /images/20221120/c7b792d2d6a24376bbccda4d091bb246.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 18]: /images/20221120/cc87ffd39acb47abb120b3bbea9814b0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 19]: /images/20221120/7d35257fae064a4d9743d394075c385a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTM4MTgzMw_size_16_color_FFFFFF_t_70 20]: /images/20221120/ea0c1f75bf41480dba5c833e87087758.png