Collection接口总结

最新推荐文章于 2024-05-29 21:50:07 发布

是小葱哦

最新推荐文章于 2024-05-29 21:50:07 发布

阅读量513

点赞数

本文链接：https://blog.csdn.net/weixin_43804406/article/details/109404167

版权

1、单列集合框架结构

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

List接口：存储有序的、可重复的数据。（“动态”数组）
- ArrayList
- LinkedList
- Vector
Set接口：存储无序的、不可重复的数据。（数学中的集合）
- HashSet
- LinkedHashSet
- TreeSet

对应图示：（实线是继承，虚线是实现）

2、Collection接口中的常用方法

add(Object obj); 向集合中添加元素
addAll(Collection coll1); 将coll1集合中的元素添加到当前的集合中
size(); 获取添加元素的个数
isEmpty(); 判断当前集合是否为空
clear(); 清空集合元素
contains(Object obj); 判断当前集合是否包含obj
containsAll(Collection coll1); 判断形参coll1中的所有元素是否都存在于当前集合中
remove(Object obj); 移除某个元素，会先进行equals()判断
removeAll(Collection coll1); 从当前集合中移除与coll1中相同的元素
retainAll(Collection coll1); 获取当前集合和coll1集合的交集，并修改当前集合
equals(Object obj); 判断当前集合和形参集合的元素是否相同
hashCode(); 返回当前对象的哈希值
toArray(); 集合转换为数组
iterator(); 返回Iterator接口的实例，用于遍历集合元素。

3、Collection集合与数组间的转换

public void test4(){
        Collection coll=new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add("abc");
        coll.add(new String("Jerry"));

        //集合--》数组 toArray()
        Object[] array = coll.toArray();
        for (Object o : array) {
            System.out.println(o);
        }

        //扩展：数组--》集合  调用Arrays类的静态方法asList(T ... t)
        List<String> list = Arrays.asList(new String[]{"AA", "bb", "cc"});
        //等价于：List<String> list = Arrays.asList("AA", "bb", "cc");
        System.out.println(list);

        List<int[]> list1 = Arrays.asList(new int[]{123, 456});
        System.out.println(list1.size());//1（会把int类型数组看成一个对象）

        List<Integer> list2 = Arrays.asList(new Integer[]{123, 456});
        System.out.println(list2.size());//2
    }

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

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

4、集合的遍历

4.1、遍历Collection的两种方式

1.使用迭代器Iterator

	@Test
    public void test1(){
        Collection coll=new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add("abc");
        coll.add(new Person("Tom",20));
        coll.add(new String("Jerry"));

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

2.foreach循环（增强for循环）

	@Test
    public void test1(){
        Collection coll=new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add("abc");
        coll.add(new Person("Tom",20));
        coll.add(new String("Jerry"));

        //for(集合元素的类型 局部变量:集合对象)
        //内部仍然调用了迭代器
        for(Object obj:coll){
            System.out.println(obj);
        }
    }

还可以调用forEach()方法

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

        coll.add(12);
        coll.add(34);
        coll.add(56);
        coll.add(78);

        coll.forEach(System.out::println);
    }

4.2、 java.utils包下定义的迭代器接口Iterator

说明

Iterator对象称为迭代器(设计模式的一种)，主要用于遍历 Collection 集合中的元素。
GOF给迭代器模式的定义为：提供一种方法访问一个容器(container)对象中各个元
素，而又不需暴露该对象的内部细节。迭代器模式，就是为容器而生。

图示说明：

remove()方法的使用

Iterator可以删除集合的元素，遍历过程中通过迭代器对象的remove方法

 	@Test
    public void test2(){
        Collection coll=new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add("abc");
        coll.add(new Person("Tom",20));
        coll.add(new String("Jerry"));

        //测试Iterator中的remove()
        Iterator iterator = coll.iterator();
        while(iterator.hasNext()){
            Object obj = iterator.next();
            if("Jerry".equals(obj)){
                iterator.remove();
            }
        }

        //遍历集合
        iterator = coll.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

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

5、List接口

5.1、存储数据的特点

List接口：存储有序的、可重复的数据。（“动态”数组）

5.2、常用实现类

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

5.3、常用方法

增：add(Object obj)
删：remove(int index)/remove(Object obj)
改：set(int index,Object ele)
查：get(int index)
插：add(int index,Object ele)
长度：size()
遍历：1.iterator迭代器
    2.增强for循环
    3.普通的循环（有索引）

5.4、源码分析

1.ArrayList的源码分析：

1.1 jdk 1.7情况下

     ArrayList list=new ArrayList();//底层创建了长度是10的Object[]数组elementData

     list.add(123);//elementData[0] = new Integer(123);

```
     ...
```

     list.add(11);//如果此次的添加导致底层elementData数组容量不够，则扩容

     默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中。

1.2 jdk 1.8中ArrayList的变化

     ArrayList list=new ArrayList();//底层Object[] elementData初始化为{}，并没有创建长度为10的数组

     list.add(123);//第一次调用add()时，底层才创建了长度10的数组，并将数据123添加到elementData[0]

```
     ...
```

     后续的添加和扩容操作与jdk 7无异。

1.3 小结

     jdk7中的ArrayList的对象创建类似于单例的饿汉式，而jdk8中的ArrayList的对象的创建类似于单例的懒汉式，

     延迟了数组的创建，节省了内存。

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

3.Vector的源码分析：

     jdk7和jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组。

     在扩容方面，默认扩容为原来的数组长度的2倍。

5.5、存储元素的要求

添加的对象所在的类，需要重写equals()方法。

6、Set接口

6.1、存储数据的特点

存储无序的、不可重复的数据

以HashSet为例说明：

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

6.2、元素添加过程

以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添加成功。—》情况3

对于添加成功的情况2和情况3而言：元素a 与已经存在指定索引位置上数据以链表的方式存储。

jdk 7与jdk 8的区别：

jdk 7：元素a放到数组中，指向原来的元素。
jdk 8：原来的元素放到数组中，指向元素a
总结：七上八下

HashSet底层：（调用的HashMap）
jdk 7：数组+链表的结构。
jdk 8：数组+链表+红黑树。

6.3、常用方法

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

6.4、常用实现类

HashSet：作为Set接口的主要实现类，线程不安全，可以存储null值。
- LinkedHashSet：作为HashSet的子类；遍历其内部数据时，可以按照添加的顺序遍历。
TreeSet：可以按照添加对象的指定属性，进行排序。

HashSet与LinkedHashSet比较：

对于频繁的遍历操作，LinkedHashSet效率高于HashSet。

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

6.5、存储对象所在类的要求

HashSet、LinkedHashSet：

向HashSet、LinkedHashSet中添加的数据，其所在的类一定要重写hashCode()和equals()方法。

要求：重写的hashCode()和equals()尽可能保持一致性，即相等的对象必须具有相等的散列码。

重写两个方法的小技巧：对象中用作equals()方法比较的Field,都应该用来计算hashCode值。

TreeSet:

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

2.两种排序方式：自然排序（实现Comparable接口）和定制排序（Comparator对象）。

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

	//方式一：自然排序
	@Test
    public void test1(){
        TreeSet set = new TreeSet();

        //举例一：(Integer类实现了Comparable接口)
        set.add(23);
        set.add(12);
        set.add(-90);
        set.add(50);

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

	//方式二：定制排序
    @Test
    public void test2(){
        Comparator com=new Comparator() {
            //按照年龄从小到大排列
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof User && o2 instanceof User){
                    User user1=(User)o1;
                    User user2=(User)o2;
                    return Integer.compare(user1.getAge(),user2.getAge());
                }else{
                    throw new RuntimeException("输入的数据类型不匹配");
                }
            }
        };

        TreeSet set = new TreeSet(com);
        set.add(new User("Tom",23));
        set.add(new User("Jerry",13));
        set.add(new User("Jim",56));
        set.add(new User("Mike",45));
        set.add(new User("Jack",35));
        set.add(new User("Jack",25));

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

是小葱哦

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
3
评论
Collection接口总结

1、单列集合框架结构Collection接口：单列集合，用来存储一个一个的对象List接口：存储有序的、可重复的数据。（“动态”数组）ArrayListLinkedListVectorSet接口：存储无序的、不可重复的数据。（数学中的集合）HashSetLinkedHashSetTreeSet对应图示：（实线是继承，虚线是实现）2、Collection接口中的常用方法add(Object obj); 向集合中添加元素addAll(Collection col
复制链接

扫一扫