集合复习

ZZ?R

已于 2022-07-27 23:25:00 修改

阅读量170

点赞数

文章标签： java

于 2021-09-14 17:40:54 首次发布

本文链接：https://blog.csdn.net/zzr_zzr_/article/details/120292711

版权

title: 集合复习
date: 2020/8/10

1.集合框架

|----Collection接口：单列集合，用来存储一个一个的对象

|----List接口：存储序的、可重复的数据。 -->“动态”数组

|----ArrayList、LinkedList、Vector

|----Set接口：存储无序的、不可重复的数据 -->高中讲的“集合”

|----HashSet、LinkedHashSet、TreeSet

|----Map接口：双列集合，用来存储一对（key-value）一对的数据 -->高中函数：y=f（x）

|—HashMap、LinkedHashMap、TreeMap、Hashtable、Properties

注：不同的key可以对应同一个value

2. List

2.1 ArrayList

public class CollectionTest {

    @Test
    public void test1(){
        Collection coll = new ArrayList<>();

        //add(Object e)：将元素e添加到结合coll中
        coll.add("AA");
        coll.add("BB");
        coll.add(123);
        coll.add(new Date());
        coll.add(new person("zzr",20));

        //contains判断是否包含"AA",判断的是内容
        System.out.println(coll.contains("AA"));

        //addAll():将coll1集合中的元素添加到当前集合中
        Collection coll1 = new ArrayList<>();
        coll1.add(456);
        coll1.add("cc");
        coll.addAll(coll1);

        System.out.println(coll.size());
        System.out.println(coll);

        //isEmpty():判断结合是否为空
        System.out.println(coll1.isEmpty());

        //clear():清空集合元素
        coll.clear();
    }
}

2.2 Iterator迭代器（不是容器）

2.2.1 三种遍历方法

public class IteratorTest {
    @Test
    public void test1(){

        Collection coll = new ArrayList<>();
        coll.add("AA");
        coll.add("BB");
        coll.add(123);
        coll.add(new Date());
        coll.add(new person("zzr",20));
        coll.add(new String("Tom"));

        Iterator iterator = coll.iterator();

//        //方式一
//        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());
//        System.out.println(iterator.next());


        System.out.println("-----------------------------");
//        //方式二
//        for (int i = 0; i < coll.size(); i++) {
//            System.out.println(iterator.next());
//        }

        //方式三:hasNext如果集合李还有元素，则继续遍历
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }
}

2.2.2 原理

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

2.3 增强for循环遍历集合和数组

public class ForeachTest {
    @Test
    public void test(){

        Collection coll = new ArrayList<>();
        coll.add("AA");
        coll.add("BB");
        coll.add(123);
        coll.add(new Date());
        coll.add(new person("zzr",20));
        coll.add(new String("Tom"));


        //for(coll集合中元素的类型 局部变量（随便取名字） :  集合对象)
        //内部调用的是迭代器Iterator
        for(Object obj : coll){
            System.out.println(obj);
        }

        //遍历数组
        int[] arr = new int[]{1,2,3,4,5,6};
        for (int i: arr) {
            System.out.println(i);
        }
    }
}

2.4 List接口常用方法

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

分析：对数组的删除，需要被删除元素后的所有元素前移，对数组的增加，需要被添加元素后的所有元素后移，效率低

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

分析：双向链表的删除和增加元素，只跟该元素的前后位置有关

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4TxptgNF-1631612437008)(C:\Users\ZZR\AppData\Roaming\Typora\typora-user-images\image-20210902153936047.png)]

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

相同点：三个类都是实现了List接口，存储数据的特点相同：存储序的、可重复的数据

2.4.1 ArrayList的源码分析

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

当不涉及大量插入和删除时候，用ArrayList，不用维护指针，有下标，查找更简单

2.4.2 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;
 }
```
 }

2.4.3 Vector的源码分析：

jdk7和jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组。在扩容方面，默认扩容为原来的数组长度的2倍。

2.5 List遍历及方法

增删改查、插入、遍历、长度

public class ListTest {
    @Test
    public void test(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(new person("zzr",20));

        System.out.println(list);

        //1.void add(int index,Object ele):在index位置插入ele元素
        list.add(1,"BB");

        System.out.println(list);


        List list1 = Arrays.asList(1, 2, 3);
        list.addAll(list1);
        System.out.println(list);

        //2.Object get(int index):获取指定index位置的元素
        System.out.println(list.get(2));

        //3.int indexof(Object obj):返回obj在集合中首次出现的位置,不存在则返回-1
        int index = list.indexOf(456);
        System.out.println(index);

        //4.Object remove(int index):移除指定index位置的元素，并返回此元素
        list.remove(1);
        //按照对象删除
        list.remove("AA");
        list.remove(new Integer(123));
        System.out.println(list);

        //5.Object set(int index,Object ele):设置指定index位置的元素为ele
        list.set(2,"张子然");
        System.out.println(list);

        //6.List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的左闭右开区间的子集合
        List subList = list.subList(2, 4);
        System.out.println(subList);
    }
}

3. set接口

|----Collection接口：单列集合，用来存储一个一个的对象

|----Set接口：存储无序的、不可重复的数据 -->高中讲的“集合”

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

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

在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据。对于频繁的遍历操作，LinkedHashSet效率高于HashSet.

|----TreeSet：可以照添加对象的指定属性，进行排序。（必须是相同类型）

3.1 元素添加的过程

例如：插入数据a：计算a所在类的哈希值->某种算法计算位置->若该位置上为空，则直接插入成功，若位置上已经有元素b（此时a和b的哈希值不一定一样）->比较a和b的哈希值->若a和b的哈希值不一样则通过链表的形式添加a，若哈希值一样，则调用equals方法，若返回TRUE，则添加失败，若返回false，则添加成功

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

元素添加过程：(以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底层：数组+链表的结构。（前提：jdk7)

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

3.2 Treeset的排序

3.2.1 自然排序（对象User实现Comparable接口，重写compareTo方法）

3.2.2 定制排序（重写compare方法如果没写定制排序，则默认自然排序）

    @Test
    public void test2(){
        Comparator com = 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());
                }else{
                    throw new RuntimeException("输入的数据类型不匹配");
                }
            }
        };
    
     TreeSet set = new TreeSet(com);
    set.add(new User("Tom",12));
    set.add(new User("Jerry",32));
    set.add(new User("Jim",2));
    set.add(new User("Mike",65));
    set.add(new User("Mary",33));
    set.add(new User("Jack",33));
    set.add(new User("Jack",56));
    
     Iterator iterator = set.iterator();
    while(iterator.hasNext()){
        System.out.println(iterator.next());
    }
}

注：

TreeSet:
1.自然排序中，比较两个对象是否相同的标准为：compareTo()返回0.不再是equals().
2.定制排序中，比较两个对象是否相同的标准为：compare()返回0.不再是equals().

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

4.1 key-value的特点

key用set存储，无序，不可重复

value用collection存储，无序可重复

Entry=key+value，无序，不可重复，用set存储

Map中的key:无序的、不可重复的，使用Set存储所的key —> key所在的类要重写equals()和hashCode() （以HashMap为例)
Map中的value:无序的、可重复的，使用Collection存储所的value —>value所在的类要重写equals()
一个键值对：key-value构成了一个Entry对象。
Map中的entry:无序的、不可重复的，使用Set存储所的entry

4.2 HashMap

4.2.1 HashMap在jdk7中实现原理

HashMap map = new HashMap():

在实例化以后，底层创建了长度是16的一维数组Entry[] table。

…可能已经执行过多次put…

map.put(key1,value1):

首先，调用key1所在类的hashCode()计算key1哈希值，此哈希值经过某种算法计算以后，得到在Entry数组中的存放位置。

如果此位置上的数据为空，此时的key1-value1添加成功。 ----情况1

如果此位置上的数据不为空，(意味着此位置上存在一个或多个数据(以链表形式存在)),比较key1和已经存在的一个或多个数据的哈希值：

如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key1-value1添加成功。----情况2

如果key1的哈希值和已经存在的某一个数据(key2-value2)的哈希值相同，继续比较：调用key1所在类的equals(key2)方法，比较：

如果equals()返回false:此时key1-value1添加成功。----情况3

如果equals()返回true:使用value1替换value2。

补充：关于情况2和情况3：此时key1-value1和原来的数据以链表的方式存储。

在不断的添加过程中，会涉及到扩容问题，当超出临界值(且要存放的位置非空)时，扩容。默认的扩容方式：扩容为原来容量的2倍，并将原的数据复制过来。

4.2.2 HashMap在jdk8中实现原理

HashMap在jdk8中相较于jdk7在底层实现方面的不同：

new HashMap():底层没创建一个长度为16的数组
jdk 8底层的数组是：Node[],而非Entry[]
首次调用put()方法时，底层创建长度为16的数组
jdk7底层结构只：数组+链表。jdk8中底层结构：数组+链表+红黑树。
4.1 形成链表时，七上八下（jdk7:新的元素指向旧的元素。jdk8：旧的元素指向新的元素）
4.2 当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64时，此时此索引位置上的所数据改为使用红黑树存储。

4.2.3 HashMap底层典型属性的属性的说明

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

4.3 LinkedHashMap的底层实现原理

LinkedHashMap底层使用的结构与HashMap相同，因为LinkedHashMap继承于HashMap.
区别就在于：LinkedHashMap内部提供了Entry，替换HashMap中的Node.

4.4 TreeMap的使用

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

4.5 Map的使用

增删改查长遍

@Test
public void test1(){
    Map map = new HashMap();

    //添加Object put(Object key,Object value):将指定key-value添加到（或修改）当前map对象中
    map.put("AA", 123);  //key一般是String，value一般是Integer
    //key一样，体现为修改
    map.put("AA", 130);
    map.put(123, "AA");
    System.out.println(map);

    Map map1 = new HashMap();
    map.put("CC", 123);
    map.put("DD", 123);
    //void putAll(Map m);将m中的所有key-value对存放到当前map中
    map.putAll(map1);
    System.out.println(map);

    //remove按key删除
    Object value = map.remove("CC");
    System.out.println(value);

    System.out.println(map);

    //clear清空
    map.clear();
    System.out.println(map);
}

@Test
public void test2(){
    Map map = new HashMap();
    map.put("AA", 123);
    map.put(45, 123);
    map.put("BB", 123);

    System.out.println(map);

    // Object get(Object key):获取指定key对应的value
    System.out.println(map.get(45));

    //containsKey(Object key):找key是否存在
    boolean bb = map.containsKey("BB");
    System.out.println(bb);

    //
    boolean b = map.containsValue(123);
    System.out.println(b);
}

@Test
public void test3(){
    Map map = new HashMap();
    map.put("AA", 123);
    map.put(45, 123);
    map.put("BB", 123);

    //遍历所有的key集：keySet()
    Set set = map.keySet();
    Iterator iterator = set.iterator();

    while (iterator.hasNext()){
        System.out.println(iterator.next());
    }

    //遍历所有的value集：values()
    Collection values = map.values();

    for ( Object obj: values) {
        System.out.println(obj);
    }

    //遍历所有的key-value
    //entrySet():
    Set entrySet = map.entrySet();

    for (Object obj:entrySet
         ) {
        System.out.println(obj);
    }
}

5.Collections工具类

5.1.作用：

操作Collection和Map的工具类

5.2.常用方法：

reverse(List)：反转 List 中元素的顺序
shuffle(List)：对 List 集合元素进行随机排序
sort(List)：根据元素的自然顺序对指定 List 集合元素升序排序
sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
Object min(Collection)
Object min(Collection，Comparator)
int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
void copy(List dest,List src)：将src中的内容复制到dest中
boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所旧值

5.3 Collection 和 Collections的区别？

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

Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作，

还提供了对集合对象设置不可变、对集合对象实现同步控制等方法
st，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
Object min(Collection)
Object min(Collection，Comparator)
int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
void copy(List dest,List src)：将src中的内容复制到dest中
boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换 List 对象的所旧值