11.Java集合框架概述---Collection（List和Set）总结

关注

原创最新推荐文章于 2026-04-03 09:00:44 发布 442 阅读 AI 写同款· GEO 优化 ›

java集合Collection、List、Set详解 java高级之集合文章目录java高级之集合概述集合 VS 数组数组集合整体概述Collection接口常用方法迭代器迭代器中的方法源码简单分析循环List接口概述常用方法实现类：ArrayList实现类：LinkedList实现类：VectorList接口总结Set接口概述实现类：HashSet实现类：LinkedHashSet实现类：TreeSetSet接口总结概述万事万物皆对象，我们可以使用数组来存储对象但存在一些弊端。集合就像是一种java容器,可以动态的存储多个对象，可以把它理解为是动态阅读详情

1 Java 集合框架概述
一方面，面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象的操作，就要对对象进行存储。另一方面，使用Array存储对象方面具有一些弊端，而Java 集合就像一种容器，可以动态地把多个对象的引用放入容器中。
数组在内存存储方面的特点：
数组初始化以后，长度就确定了。
数组声明的类型，就决定了进行元素初始化时的类型
数组在存储数据方面的弊端：
数组初始化以后，长度就不可变了，不便于扩展
数组中提供的属性和方法少，不便于进行添加、删除、插入等操作，且效率不高。同时无法直接获取存储元素的个数
数组存储的数据是有序的、可以重复的。---->存储数据的特点单一
Java 集合类可以用于存储数量不等的多个对象，还可用于保存具有映射关系的关联数组。
在这里插入图片描述

Collection接口继承树：

Map接口继承树：

2 Collection接口方法
Collection 接口是 List、Set 和 Queue 接口的父接口，该接口里定义的方法既可用于操作 Set 集合，也可用于操作 List 和 Queue 集合。 JDK不提供此接口的任何直接实现，而是提供更具体的子接口(如：Set和List)实现。
在 Java5 之前，Java 集合会丢失容器中所有对象的数据类型，把所有对象都当成 Object 类型处理；从 JDK 5.0 增加了泛型以后，Java 集合可以记住容器中对象的数据类型。
在这里插入图片描述

public class CollectionTest1 {
    @Test
    public void test1(){
        Collection collection = new ArrayList();
        //add方法:将元素添加到集合collection
        collection.add("AA");
        collection.add("123");
        collection.add(123);
        collection.add(new Date());
        collection.add("CC");
        //size获取添加元素的个数
        System.out.println(collection.size());
        //addall(Collection coll) 将coll集合中的元素添加到当前的集合中
        Collection collection1 = new ArrayList();
        collection1.addAll(collection);
        //clear:清空元素
        collection.clear();
        //isempty判断当前集合是否为空
        System.out.println(collection.isEmpty());//false
        //Contains()
        System.out.println(collection1.contains("CC"));//true
    }
}

Person类中重写了equals方法，这样只要判断年龄（基本类型）值相等以及字符串因为重写了equals所以也是比较值是否相等.
@Override
    public boolean equals(Object o) {
        System.out.println("重写的equals");
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

  @Test
    public void test1(){
        Collection coll = new ArrayList();
        coll.add(new String("Tom"));
        coll.add(new Person());
        coll.add(123);
        coll.add(true);
        coll.add("AA");
//        Person p = new Person("suo",18);
//        coll.add(p);
        coll.add(new Person("suo",18));
        //1.Contains()
        //我们在判断时会调用object所在类的equals方法
        boolean contains = coll.contains(true);//true
        System.out.println(contains);
        System.out.println(coll.contains(new String("Tom")));//true,因为string重写了equal
        System.out.println(new String("Tom"));
        //System.out.println(coll.contains(p));//true
        System.out.println(coll.contains(new Person("suo",18)));//false;当从写了equal以后,变为true
        //2.ContainsAll(Collection col(另一个接口)):自己要有不在的就是false
        boolean b = coll.containsAll(coll);
        Collection coll1 = Arrays.asList(123,456);
        System.out.println(b);
        //3.remove():删除对应元素
        coll.remove(1234);//找到并移除
        System.out.println(coll);
        System.out.println(coll.remove(new Person("suo", 18)));//true   调用equals查找
        //4.removell(Collection col):差集:移除COl中的所有元素:移除交集
        coll.removeAll(coll1);
        System.out.println(coll);//移除交集
    }

@Test
    public void test2(){
        Collection coll = new ArrayList();
        coll.add(new String("Tom"));
        coll.add(new Person());
        coll.add(123);
        coll.add(true);
        coll.add("AA");
//        Person p = new Person("suo",18);
//        coll.add(p);
        coll.add(new Person("suo",18));
        Collection coll1 = Arrays.asList(123,456,789);

        //5.retainAll(Collection col):保留交集,并返回给当前集合
        coll.retainAll(coll1);
        System.out.println(coll);//[123]

        //6.equals():当前集合和形参的元素都相同,返回true;有序的,顺序不一样不算一样
        Collection coll2 = new ArrayList();
        coll2.add(new String("Tom"));
        coll2.add(new Person());
        coll2.add(123);
        coll2.add(true);
        coll2.add("AA");
        coll2.add(new Person("suo",18));
        System.out.println(coll2.equals(coll));//false 上面删除了一些coll
    }

@Test
    public void test3(){
        Collection coll = new ArrayList();
        coll.add(new String("Tom"));
        coll.add(new Person());
        coll.add(123);
        coll.add(true);
        coll.add("AA");
//        Person p = new Person("suo",18);
//        coll.add(p);
        coll.add(new Person("suo",18));
        //7.hashCode():返回当前对象的哈希值
        System.out.println(coll.hashCode());
        //8.集合转换为数组:toarray
        Object[] objects = coll.toArray();
        System.out.println(objects);
        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);
        }
        //数组转换为集合:?调用Arrays.asList
        List<Object> objects1 = Arrays.asList(objects);
        System.out.println(objects1);//[Tom, CollectionTest.Person@22927a81, 123, true, AA, CollectionTest.Person@78e03bb5]
        //iterator():返回Iterator接口的实例,用于遍历集合元素,
    }
}

3 Iterator迭代器接口
 Iterator对象称为迭代器(设计模式的一种)，主要用于遍历 Collection 集合中的元素。
 GOF给迭代器模式的定义为：提供一种方法访问一个容器(container)对象中各个元素，而又不需暴露该对象的内部细节。迭代器模式，就是为容器而生。类似于“公交车上的售票员”、“火车上的乘务员”、“空姐”。  Collection接口继承了java.lang.Iterable接口，该接口有一个iterator()方法，那么所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象。
 Iterator 仅用于遍历集合，Iterator 本身并不提供承装对象的能力。如果需要创建Iterator 对象，则必须有一个被迭代的集合。
 集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。
在这里插入图片描述

//Iterator
    @Test
    public void test(){
        Collection coll = new ArrayList();
        coll.add(new String("Tom"));
        coll.add(new Person());
        coll.add(123);
        coll.add(true);
        coll.add("AA");
//        Person p = new Person("suo",18);
//        coll.add(p);
        coll.add(new Person("suo",18));

        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(iterator.next());//NoSuchElementException报异常

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

        //推荐三:
        Iterator iteratorss = coll.iterator();
        while (iteratorss.hasNext()){//hasNext判断是否还有下一个元素
            //next()1.指针下移2.下移以后的集合位置上的元素返回

            System.out.println(iteratorss.next());
        }
    }

@Test
    public void test2(){
        Collection coll = new ArrayList();
        coll.add(new String("Tom"));
        coll.add(new Person());
        coll.add(123);
        coll.add(true);
        coll.add("AA");
//        Person p = new Person("suo",18);
//        coll.add(p);
        coll.add(new Person("suo",18));

        Iterator iterator = coll.iterator();

        //错误方式一.
        while (iterator.next() != null){//next是向下走，不会判断有没有
            System.out.println(iterator.next());//NoSuchElementException
        }

        //错误方式二.
        while (coll.iterator().hasNext()){//这个会一直有
            System.out.println(iterator.next());
        }
    }

    //测试remove方法
    @Test
    public void test3(){
        Collection coll = new ArrayList();
        coll.add(new String("Tom"));
        coll.add(new Person());
        coll.add(123);
        coll.add(true);
        coll.add("AA");
//        Person p = new Person("suo",18);
//        coll.add(p);
        coll.add(new Person("suo",18));
        //删除集合中"AA"
        Iterator iterator = coll.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            if ("AA".equals(next)){
                iterator.remove();
            }
        }
        //重新遍历
        iterator = coll.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

在这里插入图片描述

foreach不会改变原先数组中的值
String[] str = new String[5];
        for (String myStr : str) {
            myStr = "atguigu";
            System.out.println(myStr);
        }
        for (int i = 0; i < str.length; i++) {
            System.out.println(str[i]);
        }

结果：
在这里插入图片描述
4 Collection子接口之一：List接口

describe:
1.—Collection接口:单列集合
|—list接口:有序的,可重复的数据---->"动态"数组,替换原有的数组
|—ArrayList:作为List接口的主要实现类,线程不安全的,执行效率高;底层使用Object[] elementData存储
|—LinkedList:对于频繁的插入,删除操作,使用此类效率比ArrayList高;底层使用的双向列表存储
|—Vector:作为List接口的古老实现类,线程安全,执行效率低;底层使用Object[] elementData存储
面试题:比较ArrayList,LinkedList,Vector三者的异同:
相同点:三个累都实现了List接口,存储数据的特点相同:存储有序的,可重复的数据
不同点:ArrayList
2.ArrayList源码分析: JDK7 的情况下:
ArrayList list = new ArrayList();//创建了底层长度时10的Object[]数组 Object[] elementData
list.add(123);//elementData[0] = new Integer(123);
…
list.add(456)//当此次添加的个数大于10,则扩容,默认扩容为原来容量的1.5倍数,将原有数组中的数据复制到新的数组中
结论:建议开发中使用带参的构造器
JDK8的变化:ArrayList
ArrayList list = new ArrayList();//底层Object[] elementData初始化为{},并没有创建长度为10的数组
list.add(123);//第一次调用add时,底层才创建了长度为10的数组,并将数据123添加到elementData
…
后续的添加和扩容操作与JDK7无异内存节省
小结:JDK8相当于懒汉式单例模式(节省内存);JDK7相当于饿汉式
3.Linkedlist:
LinkedList link = new linkedList();内部声明了Node类型的first和last属性;默认值为null
list.add(123)//将123封装到Node中;创建了Node对象.
其中,Node定义为,体现了LinkedList的双向链表说法
4.Vector的源码分析:在JDK和8中,通过Vector构造器创建对象时,底层都创建了长度为10的数组;
扩容方面,默认扩容为原来的2倍
5.List接口中的常用方法:
总结常用方法:
增:add(obj),addall
删除:remove()位置或者数字
改:set
查:get
长度:size
插:add(index,obj)
遍历:遍历: 迭代Iterator
增强for
普通循环
@author suoliang
@create 2021-04-15:21
在这里插入图片描述

private static void updateList(List list) {
        list.remove(2);
    }
List list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        updateList(list);
        System.out.println(list);//

结果：
在这里插入图片描述

效率高的原因：链表

双向链表：数据结构知识：只要知道了首尾链表一个链表就可以都查到了

5 Collection子接口之二：Set接口

describe:
1.|—set接口:有序的,不可重复的数据—>高中讲的"集合"
|—HashSet:作为set的主要实现类,线程不安全,可以存储null值
|—LinkedHashSet:作为HashSet的子类,遍历其内部数据时,可以按照添加的顺序遍历;
|—TreeSet:可以按照添加的元素的指定属性进行排序
2.Set:存储无序的,不可重复的数据
以HashSet为例
1.无序性:不等于随机性.存储的数据在底层数组中并非按照数组索引的顺序添加,而是根据数据的哈希值添加
2.不可重复性:保证添加的元素按照equals判断时,不能返回true,即,相同的元素只能有一个
(1)set没有额外定义的方法,使用的都是Collection中声明的方法
1. 添加元素的过程:以HashSet()为例:
我们向HashSet中添加元素a,首先调用元素a所在类的hashCode()方法,计算元素a的哈希值
此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置(索引位置),判断数组此位置上是否已经有元素:
如果此位置没有元素,则a元素添加成功—>情况一
如果此位置上有其他的元素b(或以链表形式存在的多个元素),则比较元素a和元素b的Hash值:
如果Hash值不相同,则添加成功—>情况二
如果Hash值相同,进而需要调用u元素a所在类的equals方法
equals返回true,元素添加失败
equals返回false,元素添加成功—>情况三
JDK7:元素a放到数组中,指向原来的元素
JDK:原来的元素在数组中,指向元素a
总结:七上八下
HashSet底层:数组+数据结构
2.要求:向Set中添加的数据,其所在的类一定要重写Hash Code()和equals();
要求L重写的HashCode和equals要保持一致性;相同的对象必须有相同的散列码
重写的小技巧:直接调用

@Test
    public void test(){
        Set set = new HashSet();
        set.add(456);
        set.add(478);
        set.add(478);
        set.add("aa");
        set.add(new Person("name",15));
        set.add(new Person("name",15));//如**果不重写HashCode他俩的H**ash值是不同的,重写以后,Hash值相同,而且equals,所以只显示一个添加成功
        set.add(187);


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

在这里插入图片描述

describe:
1.treeSet中添加的数据,要求是相同类的对象;
2.两种排序方式:自然排序(实现Comparable接口),定制排序
3.自然排序中比较两个对象是否相同的标准为:CompareTo返回0,不再使用equals方法
4.定制排序中,比较两个元素是否相同利用compare

@Test
    public void test(){
        TreeSet treeSet = new TreeSet();

//        treeSet.add(135);
//        treeSet.add(456);
//        treeSet.add("AA");//异常java.lang.Integer cannot be cast to java.lang.String
//        treeSet.add(true);
//        treeSet.add(new Person("suo",12));
//        treeSet.add(12.3);
        treeSet.add(456);
        treeSet.add(789);
        treeSet.add(844);
        treeSet.add(542);
        treeSet.add(4562);

        //举例1
        Iterator iterator = treeSet.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());//从小到大添加
        }
@Override
    public int compareTo(Object o) {
        if (o instanceof Person){
            Person person = (Person)o;
            //return this.name.compareTo(person.name);//从小到大排列
            //return -this.name.compareTo(person.name);//从大到小排列
            if(this.name.compareTo(person.name) != 0){
                return this.name.compareTo(person.name);
            }else{
                if (this.age > person.age){
                    return 1;
                }else{
                    return -1;
                }
            }
        }else{
            throw new RuntimeException("数据类型不一致");
        }
    }

@Test
    public void test2(){
        TreeSet treeSet = new TreeSet(){};
        treeSet.add(new Person("suo",78));
        treeSet.add(new Person("suo1",788));
        treeSet.add(new Person("suo2",781));
        treeSet.add(new Person("suo3",78));
        treeSet.add(new Person("suo4",78));
        treeSet.add(new Person("suo5",78));
        treeSet.add(new Person("suo6",78));
        treeSet.add(new Person("suo6",799));//相当于和上面的一样,compareto比较一样,需要二级排序
        System.out.println(treeSet);
    }

@Test
    public void test3(){
        Comparator comparator = new Comparator() {
            @Override
            //按照年龄大小排序
            public int compare(Object o1, Object o2) {
                if(o1 instanceof Person && o2 instanceof Person){
                    Person person = (Person)o1;
                    Person person1 = (Person)o2;
                    if (person.getAge() > person1.getAge()){
                        return 1;
                        //return Integer.compare(p1.getage, p2.getage)
                    }else
                    {
                        return -1;
                    }
                }
                else{
                    throw new RuntimeException("数据类型不一致");
                }
            }
        };
        TreeSet treeSet = new TreeSet(comparator);//按照上面方法排序
        treeSet.add(new Person("suo",78));
        treeSet.add(new Person("suo1",788));
        treeSet.add(new Person("suo2",781));
        treeSet.add(new Person("suo3",78));
        treeSet.add(new Person("suo4",78));
        treeSet.add(new Person("suo5",78));
        treeSet.add(new Person("suo6",78));
        treeSet.add(new Person("suo6",799));//相当于和上面的一样,compareto比较一样,需要二级排序
    }

在这里插入图片描述
因为虽然改了name，但是他还在name=AA，age=1001的地方放着

练习：在List内去除重复数字值，要求尽量简单：把list转化为hashset就可以实现去重

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