Java集合总结

最新推荐文章于 2023-12-14 10:26:16 发布

别怕、斯坦森在

最新推荐文章于 2023-12-14 10:26:16 发布

阅读量225

点赞数 2

本文链接：https://blog.csdn.net/gg100wan/article/details/105463683

版权

一、集合与数组的比较

1.集合与数组储存数据概述：

集合和数组都是对多个数据进行储存操作的结构，简称Java容器。
（说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储（.txt,.jpg,.avi，数据库中)。）

1.数组存储的特点与弊端：

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

1.集合储存的优点：

与数组以上特点恰恰相反。

二、Java集合框架概述：

Java 集合可分为 Collection 和 Map 两种体系
1.Collection接口：单列数据，定义了存取一组对象的方法的集合。有如下两种：
（1）List：元素有序、可重复的集合
（2）Set：元素无序、不可重复的集合
2.Map接口：双列数据，保存具有映射关系“key-value对”的集合
Collection接口继承树：
在这里插入图片描述
Map接口继承树：

三、Collection接口：

1.Collection接口常用的方法：

Collection 接口是 List、Set 和 Queue 接口的父接口，该接口里定义的方法既可用于操作 Set 集合，也可用于操作 List 和 Queue 集合。 JDK不提供此接口的任何直接实现，而是提供更具体的子接(如：Set和List)实现。
方法：
例：
Collection coll=new ArrayList（）；
添加：
**add(Object obj)：**将obj添加到集合coll中。
coll.add(“AA”);
coll.add(“BB”);
coll.add(123);//自动装箱
coll.add(new Date());
**addAll(Collection c)😗*将c集合中的元素添加到当前的集合中
Collection coll1 = new ArrayList();
coll1.add(456);
coll1.add(“CC”);
coll.addAll(coll1);
clear() 将集合清空
coll.clear();
**isEmpty()**判断集合是否为空，返回Boolean
contains(Object obj) 判断集合是否包含obj对象，会调用obj对象所在的类的equals（），返回Boolean。
remove(Object obj):从当前集合中移除obj元素
removeAll(Collection coll1):差集：从当前集合中移除coll1中包含的所有的元素。
retainAll(Collection coll1):交集：获取当前集合和coll1集合的交集，并返回给当前集合
coll.retainAll(coll1);
equals(Object obj):要想返回true，需要当前集合和形参集合的元素都相同
**hashCode()😗*返回当前对象的哈希值
size()
**iterator();**迭代器，下面会讲。

2.Collection集合和数组间的转换：

//集合 --->数组：toArray()
Collection coll=new Arraylist();
coll.add(...);
.
.
.
Object[] arr = coll.toArray();

//数组 --->集合:调用Arrays类的静态方法asList(T ... t)
List<String> list = Arrays.asList(new String[]{"AA", "BB", "CC"});
System.out.println(list);

List arr1 = Arrays.asList(new int[]{123, 456});
System.out.println(arr1.size());//1,将interesting[]看作了一个对象

List arr2 = Arrays.asList(new Integer[]{123, 456});
System.out.println(arr2.size());//2，使用int的包装类

4.使用Collection集合存储对象，要求对象所属的类满足：

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

四、Iterator接口和for—each循环：

1.遍历Collection的两种方式

① 使用迭代器Iterator ② foreach循环（或增强for循环）

2…Iterator的使用：

**作用：**遍历集合Collectiton元素
获取实例： coll.iterator()返回一个迭代器实例
遍历的代码实现：

Iterator iterator = coll.iterator();
//hasNext():判断是否还下一个元素
while(iterator.hasNext()){
    //next():①指针下移 ②将下移以后集合位置上的元素返回
    System.out.println(iterator.next());
}

iterator.remove()的使用：
如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法，再调用remove都会报IllegalStateException。内部定义了remove(),可以在遍历的时候，删除集合中的元素。此方法不同于集合直接调用remove()

      while (iterator.hasNext()){
            Object obj = iterator.next();
            if("Tom".equals(obj)){
                iterator.remove();
            }
        }

3.for—each的使用：

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

五、Collection接口之List接口：

1.存储数据特点：有序的的、可重复的数据。

2.常用方法：（重要）

增：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循环
③ 普通的循环

3. 常用实现类：

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

|----List接口：存储序的、可重复的数据。

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

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

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

4.源码分析（难）：

4.1 ArrayList的源码分析：
（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）jdk 8中ArrayList的变化：
A

     ArrayList list = new ArrayList();//底层Object[] elementData初始化为{}.并没创建长度为10的数组
     list.add(123);//第一次调用add()时，底层才创建了长度10的数组，并将数据123添加到elementData[0]
      ...
     //后续的添加和扩容操作与jdk 7 无异。

（3）小结：jdk7中的ArrayList的对象的创建类似于单例的饿汉式，而jdk8中的ArrayList的对象
的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。
4.2 LinkedList的源码分析：

LinkedList list = new LinkedList(); //内部声明了Node类型的first和last属性，默认值为null
ist.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;
            }
        }

~~4.3 Vector的源码分析（古老）：~~
jdk7和jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组。在扩容方面，默认扩容为原来的数组长度的2倍。
[面试题]

面试题：ArrayList、LinkedList、Vector者的异同？
同：三个类都是实现了List接口，存储数据的特点相同：存储序的、可重复的数据
不同：从底层和优缺点来分析。

六、Collection接口之Set接口：

1. 存储的数据特点：无序的、不可重复的元素

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

2. 元素添加过程、底层：(以HashSet为例)

我们向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置（即为：索引位置），判断数组此位置上是否已经元素：
1.如果此位置上没其他元素，则元素a添加成功。 —>情况1
2.如果此位置上其他元素b(或以链表形式存在的多个元素，则比较元素a与元素b的hash值：
2.1 如果hash值不相同，则元素a添加成功。
2.2如果hash值相同，进而需要调用元素a所在类的equals()方法：

          若equals()返回true,元素a添加失败
          若 equals()返回false,则元素a添加成功。

对于添加成功元素a 与已经存在指定索引位置上数据以链表的方式存储。
jdk 7 :元素a放到数组中，指向原来的元素。
jdk 8 :原来的元素在数组中，指向元素a
（七上八下）
在这里插入图片描述

HashSet底层：数组+链表的结构。（前提：jdk7)

3. 常用方法

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

4. 常用实现类：

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

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

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

             |----LinkedHashSet：作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据。对于频繁的遍历操作，LinkedHashSet效率高于HashSet.

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

5. 存储对象所在类的要求：

HashSet/LinkedHashSet:
要求：向Set(主要指：HashSet、LinkedHashSet)中添加的数据，其所在的类一定要重写hashCode()和equals()
要求：重写的hashCode()和equals()尽可能保持一致性：相等的对象必须具有相等的散列码;
重写两个方法的小技巧：对象中用作 equals() 方法比较的 Field，都应该用来计算 hashCode 值。
TreeSet:
1.自然排序中，比较两个对象是否相同的标准为：compareTo()返回0.不再是equals().
2.定制排序中，比较两个对象是否相同的标准为：compare()返回0.不再是equals().

6.面试题：

HashSet set = new HashSet();
Person p1 = new Person(1001,"AA");
Person p2 = new Person(1002,"BB");
set.add(p1);
set.add(p2);
p1.name = "CC";
set.remove(p1);
System.out.println(set);//{1001，CC，1002BB
set.add(new Person(1001,"CC"));
System.out.println(set);//1001CC，1001CC,1002BB
set.add(new Person(1001,"AA"));
System.out.println(set);//1001AA,1001CC,1001CC,1002BB

从哈希值的角度考虑

2.练习：在List内去除重复数字值，要求尽量简单


public static List duplicateList(List list) {
HashSet set = new HashSet();
set.addAll(list);
return new ArrayList(set);
}
public static void main(String[] args) {
List list = new ArrayList();
list.add(new Integer(1));
list.add(new Integer(2));
list.add(new Integer(2));
list.add(new Integer(4));
list.add(new Integer(4));
List list2 = duplicateList(list);
for (Object integer : list2) {
System.out.println(integer);
} }

七、Map接口：

1.常用实现类结构

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

2.存储结构的理解：

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

3.常用方法：

添加：put(Object key,Object,value)
删除：remove（Object key）
修改：put（Object key,Object value)
查询：get（Object key)
长度：size（）
遍历：keySet（）/values（）/entrySet（）

内存结构：

1.HashMap在jdk7中的实现原理：
（1)HashMap map=new HashMap()：在实例化以后，底层创建了长度是16的一维数组Entry[] table。
（2）…（多次进行map.put(key,value)后）…
map.put(key1,value1):首先调用key1所在类的hashCode（）计算key1的哈希值（散列码），此哈希值经过某种算法以后，得到在Entry数组中的存放位置。
2.1如果此位置上的数据为空，此时的key1-hvalue1添加成功；
2.2如果此位置上的数据不为空，（意味着此位置上存在一个或多个数据，以链表的形式存在），比较key1和已经存在的一个或多个数据的哈希值；
2.2.1如果key1的哈希值与已经存在的数据的哈希值都不同，此时的key1-hvalue1添加成功；
2.2.2如果key1的哈希值和某个数据的（key2-value2）的哈希值相同，继续比较：调用key1所在的类的equals（key2）进行比较：
2.2.2.1false：成功；
2.2.2.2true使用value1替换value2；
（3）在不断的添加过程中，会涉及到扩容问题，当超出临界值(且要存放的位置非空)时，扩容。默认的扩容方式：扩容为原来容量的2倍，并将原的数据复制过来。
2. HashMap在jdk8中相较于jdk7在底层实现方面的不同：

new HashMap():底层没创建一个长度为16的数组
jdk 8底层的数组是：Node[],而非Entry[]
首次调用put()方法时，底层创建长度为16的数组
jdk7底层结构只：数组+链表。jdk8中底层结构：数组+链表+红黑树。
4.1 形成链表时，七上八下（jdk7:新的元素指向旧的元素。jdk8：旧的元素指向新的元素）
4.2 当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64时，此时此索引位置上的所数据改为使用红黑树存储。
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.LinkedHashMap的底层实现原理(了解)
LinkedHashMap底层使用的结构与HashMap相同，因为LinkedHashMap继承于HashMap.
区别就在于：LinkedHashMap内部提供了Entry，替换HashMap中的Node.

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

[面试题]

1. HashMap的底层实现原理？
1. HashMap 和 Hashtable的异同？

别怕、斯坦森在

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
4
评论
Java集合总结

一、集合与数组的比较1.集合与数组储存数据概述：集合和数组都是对多个数据进行储存操作的结构，简称Java容器。（说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储（.txt,.jpg,.avi，数据库中)。）1.数组存储的特点与弊端：（1）一旦初始化以后，其长度就不可修改。（2）数组中提供的方法非常限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。（3）获取数...
复制链接

扫一扫