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

文章目录

一、Java集合框架概述
二、Collection接口方法
三、Map接口
四、Iterator迭代器接口
- 4.1、hasNext() 和 next()
- 4.2、remove()
五、Collections工具类
- 5.1、Collections常用方法

一、Java集合框架概述

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

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

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

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

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

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

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

一旦初始化以后，其长度就不可修改

数组中提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高

获取数组中实际元素的个数的需求，数组没有线程的属性或方法可用

数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。

二、Collection接口方法

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

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

常用的15个方法：

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

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

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

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

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

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

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

//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);

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]

//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

//11.hashCode():返回当前对象的哈希值
System.out.println(coll1.hashCode());

//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]，识别成一个元素

//13.返回iterator接口的实例,用于遍历集合元素。放在TteratorTest.java中测试

2.1、Collection子接口一：List

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

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

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

异：

ArrayList：作为List接口的主要实现类：线程不安全的，效率高；底层使用Object[] 存储

LinkedList：对于频发的插入、删除操作，使用此类的效率比ArrayList高；底层使用的双向链表存储

Vector：作为List接口的古老实现类：线程安全的，效率低；底层使用Object[] 存储

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的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。

2.1.2、LinkedList的源码分析

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

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));
}

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);//左闭右开

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

2.2.1、Set接口的无序性

以HashSet为例说明：

无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值。

不可重复性：保证添加的元素按照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

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

LinkedHashSet的使用

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

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

2.2.4、Set实现类之三：TreeSet

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

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

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

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

三、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

Map中的key value的图示：

高频面试考点：

HashMap的基层原理是什么？

HashMap和Hashtable的异同？

补充：

HashMap的底层：

数组+链表（jdk7及之前）

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

3.1、HashMap

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

3.1.1、HashMap的底层实现原理？

以jdk7 为例说明：

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类型

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()

 添加、删除、修改操作：
 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集合

//遍历所有的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);
}

四、Iterator迭代器接口

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

重点掌握：

内部的方法：hasNext() 和 next()

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

内部定义了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<coll.size();i++){
    
    
//            System.out.println(iterator.next());
//        }

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

迭代器的执行原理如下：

说明：

调用hasNext()的时候指针没有下移，调next()的时候指针才下移。

iterator只是迭代的，用于遍历，不是容器，当前集合coll是一个容器

next()：① 指针下移； ② 讲下移后的集合位置上的元素返回

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

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());
    }
}

五、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.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 对象的所有旧值

//对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);
    }

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

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

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