• Java集合--Collection、Map、List、Set、Iterator、Collections工具类

    文章目录

    一、Java集合框架概述

    1. 集合、数组都是对多个数据进行存储从左的结构，简称Java容器

    说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储（.txt, .jpg, .avi，数据库中）

    2.1 数组在存储多个数据方面的特点：

    1. 一旦初始化以后，其长度就确定了。

    2. 数组一旦定义好，其元素的类型就确定了。我们也就只能操作指定类型的数据了。

      比如：String[] arr; int[] arr1; Object[] arr2；

    2.2 数组在存储多个数据方面的缺点：

    1. 一旦初始化以后，其长度就不可修改
    2. 数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高
    3. 获取数组中实际元素的个数的需求，数组没有线程的属性或方法可用
    4. 数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。

    二、Collection接口方法

    单列数据（List、Set），定义了存取一组对象的方法的集合

    image.png 
    结论：
* 向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals()

    • 1
    • 2

    常用的15个方法：

    //1.add(Object e)：将元素 e 添加到集合 coll中
Collection coll = new ArrayList();
coll.add("AA");
coll.add(55);//自动装箱
coll.add(new Date());//添加对象

    • 1
    • 2
    • 3
    • 4
    • 5
    //2.size()://获取添加元素的个数
System.out.println(coll.size());

    • 1
    • 2
    //3.addAll(Collection c)：将c集合中的元素添加到当前的集合中
Collection coll1 = new ArrayList();
coll1.add("SS");
coll1.addAll(coll);

    • 1
    • 2
    • 3
    • 4
    //4.clear():清空集合元素
System.out.println(coll1.isEmpty());
coll1.add(new String("Jerry"));

    • 1
    • 2
    • 3
    //5.contains(Object obj)//判断当前集合中是否包含obj,我们在判断时会调用obj对象所在类的equals()
boolean contains = coll1.contains("abc");

    • 1
    • 2
    // 6.containsAll(Collection coll1)//判断形参coll1中的所有元素是否都在当前集合中
boolean b = coll1.containsAll(coll);

    • 1
    • 2
    //7.remove(Object obj):从当前集合中移除obj元素
coll.remove("BB");
coll.remove("CC");
coll.remove(5);

    • 1
    • 2
    • 3
    • 4
    //8.removeAll(Collection coll1)：从当前集合中移除coll1中的所有元素
Collection coll = new ArrayList();
coll.add(123);
coll.add("AA");
coll.add(987);//自动装箱
coll.add("SS");
coll.add("CC");

Collection coll1 = Arrays.asList(123,456,987);
coll.removeAll(coll1);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    Collection coll = new ArrayList();
coll.add(123);
coll.add(456);
coll.add(false);
Collection coll1 = Arrays.asList(123,456,987);

//9.retainAll(Collection coll1):交集：获取当前集合和coll1集合的交集，并返回给当前集合
coll.retainAll(coll1);
System.out.println(coll);//[123, 456]

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    //10.equals(Object obj)：要想返回true,需要当前集合和形参集合的元素都相同
Collection coll1 = new ArrayList();//List，顺序是有序的，顺序不同就是false
coll1.add(123);
coll1.add(456);
coll1.add(false);
boolean equals = coll.equals(coll1);
System.out.println(equals);//true

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    //11.hashCode():返回当前对象的哈希值
System.out.println(coll1.hashCode());

    • 1
    • 2
    //12.集合-->数组toArray()
Object[] array = coll1.toArray();
for (int i=0;i<array.length;i++){
    System.out.println(array[i]);
}
//数组-->集合: 调用Arrays的静态方法asList()
List<String> list = Arrays.asList(new String[]{"AA","BB","CC"});
System.out.println(list);
List<Integer> list1 = Arrays.asList(new Integer[]{123, 456});
System.out.println(list1.size());//2

List list2 = Arrays.asList(new int[]{123, 456});
System.out.println(list2.size());//1
System.out.println(list2);//[[I@7dc36524]，识别成一个元素

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    //13.返回iterator接口的实例,用于遍历集合元素。放在TteratorTest.java中测试

    • 1

    2.1、Collection子接口一：List

    List：元素有序、可重复的集合。---->”动态数组“

    经典面试题：ArrayList、LinkedList、Vector三者的异同？

    同：实现了List接口，存储数据的特点相同：存储有序的、可重复的数据

    异：

    • ArrayList：作为List接口的主要实现类：线程不安全的，效率高；底层使用Object[] 存储
    • LinkedList：对于频发的插入、删除操作，使用此类的效率比ArrayList高；底层使用的双向链表存储
    • Vector：作为List接口的古老实现类：线程安全的，效率低；底层使用Object[] 存储

    image.png

    2.1.1、ArrayLIst的源码分析

    2.1 jdk7情况下
ArrayList list = new ArrayList();//底层创建了长度是10的object[]数组eLementData
list.add(123); //eLementData[e] = 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初始化为{}.并没有创建长
list.add(123);//第一次调用add()时，底层才创建了长度1e的数组，并将数据123添加到eLemer
后续的添加和扩容操作与jdk 7无异。


2.3小结: jdk7中的ArrayList的对象的创建类似于单例的饿汉式，而jdk8中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    2.1.2、LinkedList的源码分析

    LinkedList list = new LinkedList();内部声明了Node类型的first和last属性，默认值为null
List.add(123);//将123封装到Node中，创建了Node对象。
// 其中，Node定义为:体现了LinkedList的双向链表的说法

    • 1
    • 2
    • 3

    2.1.3、List接口中的常用方法

    List除了从Collection集合继承的方法外，List 集合里添加了一些根据索引来
    操作集合元素的方法。

    总结：常用方法

    增：add(Object obj)

    删：remove(int index) / remove(Object obj)//一个按照索引删除；一个直接删除对象（元素）

    改：set(int index, Object ele)

    查：get(int index)

    插：add(int index, Object ele)

    长度：size()

    遍历：① Iterator 迭代器方法；② 增强for循环；③ 普通的for循环

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

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

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    ArrayList list = new ArrayList();
list.add(123);
list.add(465);
list.add("AA");
list.add(new Date());
list.add("BB");
list.add("CC");

//1.void add(int index, Object ele):在index位置插入ele元素
    list.add(1,"BB");
    
//2.boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
List list1 = Arrays.asList(1,2,3);
list.addAll(list1);
System.out.println(list.size());

//3.Object get(int index):获取指定index位置的元素
Object o = list.get(0);//123
Object o1 = list.get(6);//2

//4.int indexOf(Object obj):返回obj在集合中首次出现的位置
int index = list.indexOf(465);//1

//5.int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
int lastIndexOf = list.lastIndexOf("AA");//2

//6.Object remove(int index):移除指定index位置的元素，并返回此元素
Object obj = list.remove(0);
System.out.println(obj);//123

//7.Object set(int index, Object ele):设置指定index位置的元素为ele
list.set(1,"XX");

//8.List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
List subList = list.subList(1, 4);//左闭右开


    • 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

    2.2、Collection子接口二：Set

    Set接口的概述

    • Set接口是Collection的子接口，set接口没有提供额外的方法
    • Set 判断两个对象是否相同不是使用 == 运算符，而是根据 equals() 方法
    • Set 集合不允许包含相同的元素，如果试把两个相同的元素加入同一个 Set 集合中，则添加操作失败。

    Set接口中没有额外定义新的方法，使用的都是Collection中声明过的方法。

    HashSet：作为Set接口的主要实现类；线程不安全的；可以存储null值

    LinkedHashSet：作为HashSet的子类；遍历其内部数据时，可以按照添加的

    TreeSet：可以按照添加对象的指定属性。进行排序

    Set接口：元素无序、不可重复的集合。---->高中将的”集合“

    HashSet、LinkedHashSet（是HashSet的子类）、TreeSet

    image.png image.png 1683817191392.jpg

    2.2.1、Set接口的无序性

    以HashSet为例说明：

    1. 无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值。
    2. 不可重复性：保证添加的元素按照equals()判断时，不能返回true。即：相同的元素只能添加一个。

    2.2.2、添加元素的过程：以HashSet为例

    我们向HashSet中添加元素a，首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为：索引位置），判断数组此位置上是否已经有元素；
    如果此位置上没有其他元素，则元素a添加成功。—>情况1
    如果此位置上有其他元素(或以链表形式存在的多个元素），则比较元素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底层：数组+链表的结构。

    2.2.3、Set实现类之二：LinkedHashSet

    1. LinkedHashSet 是 HashSet 的子类
    2. LinkedHashSet 根据元素的 hashCode 值来决定元素的存储位置，但它同时使用双向链表维护元素的次序，这使得元素看起来是以插入顺序保存的。
    3. LinkedHashSet插入性能略低于 HashSet，但在迭代访问 Set 里的全部元素时有很好的性能。
    4. LinkedHashSet 不允许集合元素重复。
    image.png

    LinkedHashSet的使用

    LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据。

    优点：对于频繁的遍历操作，LinkedHashSet效率高于Hashset

    2.2.4、Set实现类之三：TreeSet

    向TreeSet中添加的数据，要求是相同类的对象。

    TreeSet 是 SortedSet 接口的实现类，TreeSet 可以确保集合元素处于排序状态。

    TreeSet底层使用红黑树结构存储数据

    TreeSet 两种排序方法：自然排序和定制排序。默认情况下，TreeSet 采用自然排序。

    image.png

    三、Map接口

    List ：单列数据

    Map：双列数据

    List 和 Map都可以看作是 key-value的形式，只不过 List的key是 index，是索引，自动生成的，而Map的key可以是任意类型。

    Map：双列数据，保存具有映射关系“key-value对”键值对的集合。---->高中函数：y=f(x)。x：key ； y：value

    HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

    image.png

    image.png

    Map中的key value的图示：

    image.png

    高频面试考点：

    1. HashMap的基层原理是什么？
    2. HashMap和Hashtable的异同？

    补充：

    HashMap的底层：

    数组+链表 （jdk7及之前）

    数组+链表+红黑树 （jdk8）

    3.1、HashMap

    作为Map的主要实现类；线程不安全的，效率高；可以存储null的key和value

    3.1.1、HashMap的底层实现原理？

    以jdk7 为例说明：

    1684381708053.jpg

    1684381673111.jpg

    image.png

    3.1.2、LinkedHashMap

    LinkedHashMap是HashMap的一个子类：保证在遍历map元素时，可以按照添加的顺序实现遍历。

    原因：在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素。

    对于频繁的遍历操作，此类执行效率高于HashMap。

    3.2、TreeMap

    保证按照添加的key-value对进行排序，实现排序遍历。此时考虑key的自然排序或定制排序。

    底层使用红黑树。

    Properties 类是 Hashtable 的子类，该对象用于处理属性文件

    由于属性文件里的 key、value 都是字符串类型，所以 Properties 里的 key 和 value 都是字符串类型

    存取数据时，建议使用setProperty(String key,String value)方法和 getProperty(String key)方法

    3.3、Hashtable

    作为古老的实现类，线程安全的，效率低；不能存储null的key和value

    3.3.1、Properties

    Properties是Hashtable的一个子类：常用来处理配置文件。key和vaLue都是String类型

    image.png

    3.4、Map中的常用方法

    总结：常用方法：
1.添加：put(Object key,Object value)
2.删除：remove(Object key)
3.修改：put(Object key,Object value)
4.查询：get(Object key)
5.长度：size()
6.遍历：keySet()	/ values()	/ entrySet()

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
     添加、删除、修改操作：
 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集合


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    //遍历所有的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("**********");

//方式二:自己根据已有的方法(keySet())自己拼凑
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);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    四、Iterator迭代器接口

    集合元素的遍历操作，使用迭代器Iterator接口

    重点掌握：

    1. 内部的方法：hasNext() 和 next()
    2. 集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合 的第一个元素之前。
    3. 内部定义了remove()，可以在遍历的时候，删除集合中的元素。此方法不同于集合直接调用remove()

    4.1、hasNext() 和 next()

    public void test(){
        Collection coll = new ArrayList();
        coll.add("AA");
        coll.add(55);//自动装箱
        coll.add("SS");
        coll.add(new Date());
        Iterator iterator = coll.iterator();

        //方式一：
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
//        System.out.println(iterator.next());
        //报异常：NoSuchElementException
//        System.out.println(iterator.next());

        //方式二：
//        for (int i=0;i
//            System.out.println(iterator.next());
//        }

        //方式三:推荐
        while (iterator.hasNext()){//使用hasNext()，查看下一个是否为空
            System.out.println(iterator.next());
        }
    }

    • 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

    迭代器的执行原理如下：

    说明：

    • 调用hasNext()的时候指针没有下移，调next()的时候指针才下移。
    • iterator只是迭代的，用于遍历，不是容器，当前集合coll是一个容器
    • next()：① 指针下移； ② 讲下移后的集合位置上的元素返回

    集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合 的第一个元素之前。

    image.png

    4.2、remove()

    如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法， 再调用remove都会报IllegalStateException。

    @Test
public void test3(){
    Collection coll = new ArrayList();
    coll.add("AA");
    coll.add(55);//自动装箱
    coll.add("SS");
    coll.add(new Date());

    //iterator.remove(): 删除集合中的"AA"
    Iterator iterator = coll.iterator();
    while (iterator.hasNext()){
        Object obj = iterator.next();
        if ("AA".equals(obj)){
            iterator.remove();
        }
    }

    Iterator iterator1 = coll.iterator();
    while (iterator1.hasNext()){
        System.out.println(iterator1.next());
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    五、Collections工具类

    作用：操作Collection和Map的工具类

    Collections 是一个操作 Set、List 和 Map 等集合的工具类

    Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作， 还提供了对集合对象设置不可变、对集合对象实现同步控制等方法

    面试题：Collection 和 Collections 的区别？

    Collection是一个接口；Collections 是一个操作 Set、List 和 Map 等集合的工具类

    5.1、Collections常用方法

    排序操作：（均为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 处元素进行交换

    • 1
    • 2
    • 3
    • 4
    • 5
    查找、替换
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 对象的所有旧值

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    //对6.void copy(List dest,List src)，的详细使用说明
@Test
    public void test2() {
        List list = new ArrayList();
        list.add(123);
        list.add(33);
        list.add(45);
        list.add(-52);

//        List dest = new ArrayList();//错误的，会报异常
        List dest = Arrays.asList(new Object[list.size()]);//更健壮
        System.out.println(dest.size());
        System.out.println(dest);
        Collections.copy(dest, list);
        System.out.println(dest);
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    说明：ArrayList和HashMap都是线程不安全的，如果程序要求线程安全，我们可以将ArrayList、HashMap转为线程安全的。

    使用synchronizedList(List list) 和 synchronziedMap( Map map)

    同步控制
Collections 类中提供了多个 synchronizedXxx() 方法，该方法可使将指定集
合包装成线程同步的集合，从而可以解决多线程并发访问集合时的线程安全
问题
    
    //返回的list1即为线程安全的list
    List list1 = Collections.synchronizedList(list);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
  • 相关阅读:
    数组的相关知识
    【boot loader】Aurix TC3xx用户手册解读--CAN Bootstrap loader
    Ubuntu下jax安装与使用
    Nacos配置中心HelloWorld入门实例
    六级作文---3.图画类
    Redis—问题（1）
    华理生物冲刺科创板：年营收2.26亿 拟募资8亿
    组件库开发
    实战演练 | Navicat 安全可靠的数据传输功能
    【css | loading】各种简单的loading特效
  • 原文地址：https://blog.csdn.net/Miss_croal/article/details/132953751