（Java学习笔记）JavaSE 集合：Collection接口（Liist、Set接口）

最新推荐文章于 2022-03-06 01:33:34 发布

小张不会飞

最新推荐文章于 2022-03-06 01:33:34 发布

阅读量435

点赞数 2

分类专栏： JavaSE笔记文章标签： java 接口类

本文链接：https://blog.csdn.net/qq_43110389/article/details/105433158

版权

JavaSE笔记专栏收录该内容

18 篇文章 5 订阅

订阅专栏

Collection接口

Collection 接口是 List、Set 和 Queue 接口的父接口，该接口里定义的方法既可用于操作 Set 集合，也可用于操作 List 和 Queue 集合。

目录：Collection接口

Collection接口
1、Collection接口方法
2、子接口：List接口
2.1、List接口方法
2.11遍历的三种方式
2.12、总结：常用方法

2.2、ArrayList
2.3、LinkedList
2.4、Vector
2.5、比较ArrayList、LinkedList、Vector实现类的异同（面试）

3、子接口：Set接口
3.1、HashSet
3.2、LinkedHashSet
3.3、TreeSet

1、Collection接口方法

1、添加 ①add(Object obj) ②addAll(Collection coll)

2、获取有效元素的个数 int size()

3、清空集合 void clear()

4、是否是空集合 boolean isEmpty()

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

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

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

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

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

        //isEmpty():判断当前集合是否为空
        System.out.println(coll.isEmpty());

5、是否包含某个元素 ①boolean contains(Object obj)：是通过元素的equals方法来判断是否是同一个②boolean containsAll(Collection c)：也是调用元素的equals方法来比较的。拿两个集合的元素挨个比较。

6、删除 ①boolean remove(Object obj) ：通过元素的equals方法判断是否是要删除的那个元素。只会删除找到的第一个元素 ②boolean removeAll(Collection coll)：取当前集合的差集

7、取两个集合的交集 boolean retainAll(Collection c)：把交集的结果存在当前集合中，不影响c

8、集合是否相等 boolean equals(Object obj)

9、转成对象数组 Object[] toArray()

10、获取集合对象的哈希值 hashCode()

@Test
    public void test1(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
//        Person p = new Person("Jerry",20);
//        coll.add(p);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);
        //contains(Object obj):判断当前集合中是否包含obj
        //我们在判断时会调用obj对象所在类的equals()。
        boolean contains = coll.contains(123);
        System.out.println(contains);
        System.out.println(coll.contains(new String("Tom")));
//        System.out.println(coll.contains(p));//true
        System.out.println(coll.contains(new Person("Jerry",20)));//false -->true

        //2.containsAll(Collection coll1):判断形参coll1中的所有元素是否都存在于当前集合中。
        Collection coll1 = Arrays.asList(123,4567);
        System.out.println(coll.containsAll(coll1));
    }

    @Test
    public void test2(){
        //remove(Object obj):从当前集合中移除obj元素。
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);

        coll.remove(123);
        System.out.println(coll);//123被移除

        coll.remove(new Person("Jerry",20));//person类必须重写equals()
        System.out.println(coll);

        // removeAll(Collection coll1):差集：从当前集合中移除coll1中所有的元素。
        Collection coll1 = Arrays.asList(123,456);
        coll.removeAll(coll1);
        System.out.println(coll);
    }

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

        //retainAll(Collection coll1):交集：获取当前集合和coll1集合的交集，并返回给当前集合
//        Collection coll1 = Arrays.asList(123,456,789);
//        coll.retainAll(coll1);
//        System.out.println(coll);

        //equals(Object obj):要想返回true，需要当前集合和形参集合的元素都相同。
        Collection coll1 = new ArrayList();
        coll1.add(456);
        coll1.add(123);
        coll1.add(new Person("Jerry",20));
        coll1.add(new String("Tom"));
        coll1.add(false);

        System.out.println(coll.equals(coll1));//true
    }

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

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

        //集合 --->数组：toArray()
        Object[] arr = coll.toArray();
        for(int i = 0;i < arr.length;i++){
            System.out.println(arr[i]);
        }

        //拓展：数组 --->集合:调用Arrays类的静态方法asList()
        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 :把new int[]{123, 456}当成一个元素

        List arr2 = Arrays.asList(new Integer[]{123, 456});
        System.out.println(arr2.size());//2 ：把new int[]{123, 456}当成二个元素
    }

11、遍历 iterator()：返回迭代器对象，用于集合遍历

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

        Iterator iterator = coll.iterator();

        //方式一：不推荐
//        for(int i = 0;i < coll.size();i++){
//            System.out.println(iterator.next());
//        }

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

    @Test
    public void test2(){

        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);

        //错误方式一：
//        Iterator iterator = coll.iterator();
//        while((iterator.next()) != null){
//            System.out.println(iterator.next());//输出456，Tom  并报异常
//        }

        //错误方式二：
        //集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。
        while (coll.iterator().hasNext()){
            System.out.println(coll.iterator().next());//死循环，不断输出123（第一个元素）
        }
    }

    //测试Iterator中的remove()
    //如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法，
    // 再调用remove都会报IllegalStateException。
    @Test
    public void test3(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(456);
        coll.add(new Person("Jerry",20));
        coll.add(new String("Tom"));
        coll.add(false);

        //删除集合中"Tom"
        Iterator iterator = coll.iterator();
        while (iterator.hasNext()){
//            iterator.remove();
            Object obj = iterator.next();
            if("Tom".equals(obj)){
                iterator.remove();
//                iterator.remove();
            }
        }
        //遍历集合
        iterator = coll.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

2、子接口：List接口

通常使用List替代数组

List集合类中元素有序、且可重复，集合中的每个元素都有其对应的顺序索引。

List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素。

2.1、List接口方法

void add(int index, Object ele):在index位置插入ele元素
boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
Object get(int index):获取指定index位置的元素
int indexOf(Object obj):返回obj在集合中首次出现的位置
int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
Object remove(int index):移除指定index位置的元素，并返回此元素
Object set(int index, Object ele):设置指定index位置的元素为ele
List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex 位置的子集合

2.11遍历的三种方式

 @Test
    public void test2(){
        ArrayList list = new ArrayList();
        list.add(123);
        list.add(456);
        list.add("AA");
        list.add(456);

        //方式一：Iterator迭代器方式
        Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println("***************");

        //方式二：增强for循环
        for(Object obj : list){
            System.out.println(obj);
        }
        System.out.println("***************");

        //方式三：普通for循环
        for(int i = 0;i < list.size();i++){
            System.out.println(list.get(i));
        }
    }

2.12、总结：常用方法

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

2.2、ArrayList

    @Test
    public void test(){
        //ArrayList源码分析   jdk1.7下
        //底层创建了长度为10的 Object[] elementData
        ArrayList<Object> arrayList = new ArrayList<>();
        //添加数据
        arrayList.add(1);//底层 elementData[0] = new Integer(1);

        //...一直添加数据

        //添加到第11个数据
        arrayList.add(11);//底层  此次添加导致elementData[] 容量不足，触发扩容机制：
        // 默认情况下，扩容为原来的1.5倍，同时将原有数组中的数据复制到新的数组中。

        //结论：开发中，建议使用带参构造器 new ArrayList<>(int initialCapacity)
        // 指定底层数组elementData[]的长度，避免中间使用过程中的扩容，提高效率


        //ArrayList源码分析   jdk1.8下的变化
        //底层elementData[]初始化为{}，并没有创建长度为10的数组
        ArrayList<Object> arrayList1 = new ArrayList<>();
        //添加数据
        arrayList.add(1);//第一次添加数据，底层才创建了长度为10的elementData[]，并将数据1 添加到数组中

        //后续添加和扩容操作，与1.7下相同
        
        //小结：jdk7中的ArrayList的对象的创建类似于单例的饿汉式
        // jdk8中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。
    }

2.3、LinkedList

   @Test
    public void test1(){
        //LinkedList底层源码分析
        //创建对象，内部声明了Node类型的first（头结点）和last（尾结点）两个属性，默认值为null
        LinkedList linkedList = new LinkedList();
        //添加数据
        linkedList.add(1); //将数据1 封装到Node中，创建了一个Node对象

        //Node定义：    双向链表的结点
//        private static class Node<E> {
//            E item;
//            LinkedList.Node<E> next;
//            LinkedList.Node<E> prev;
//
//            Node(LinkedList.Node<E> prev, E element, LinkedList.Node<E> next) {
//                this.item = element;
//                this.next = next;
//                this.prev = prev;
//            }
//        }
    }

2.4、Vector

线程安全，效率较低底层使用Object[] elementData存储

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

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

2.5、比较ArrayList、LinkedList、Vector实现类的异同（面试）

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

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

	Vector作为List接口的古老实现类，（jdk1.0）线程安全，效率较低  底层使用Object[] elementData存储

LinkedList：作为List接口的次要实现类（jdk1.2）线程不安全，对于频繁的插入、删除操作，效率高于ArrayList，底层使用双向链表存储

3、子接口：Set接口

存储的的数据，无序，不可重复，且Set接口中没有额外定义新的方法，使用的都是Collection中声明过的方法。

无序：存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值所决定

不可重复：保证添加的元素按照equals()判断时，不能返回true，即相同的元素只能添加一个。

3.1、HashSet

Set接口的主要实现类，线程不安全，可存储null值底层：数组+链表的结构

添加元素的过程（以HashSet为例，LinkedHashSet同样如此）

我们向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 :元素a放到数组中，指向原来的元素。
  jdk 8 :原来的元素在数组中，指向元素a
  总结：七上八下
```
添加元素要求：向Set(主要指：HashSet、LinkedHashSet)中添加的数据，其所在的类一定要重写hashCode()和equals() 且重写的hashCode()和equals()尽可能保持一致性：相等的对象必须具有相等的散列码

3.2、LinkedHashSet

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

LinkedHashSet在添加数据的同时，每个数据还维护了两个引用（指针），形成一个双向链表，记录此数据前一个数据和后一个数据。遍历其内部数据时，可以按照添加的顺序遍历。

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

3.3、TreeSet

TreeSet 是 SortedSet 接口的实现类，TreeSet 可以确保集合元素处于排序状态。可以按照添加对象的指定属性，进行排序。底层使用红黑树结构存储数据

package com.zck.listtest;

import org.junit.Test;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

/**
 * @author zck
 * @create 2020-04-07 19:16
 */
public class TreeSetTest {
    /*
    1.向TreeSet中添加的数据，要求是相同类的对象。
    2.两种排序方式：自然排序（实现Comparable接口） 和 定制排序（Comparator）
    3.自然排序中，比较两个对象是否相同的标准为：compareTo()返回0.不再是equals().
    4.定制排序中，比较两个对象是否相同的标准为：compare()返回0.不再是equals().
     */
    @Test
    public void test1(){
        TreeSet set = new TreeSet();

        //失败：不能添加不同类的对象
//        set.add(123);
//        set.add(456);
//        set.add("AA");
//        set.add(new User("Tom",12));

        //举例一：添加Integer类型数据，默认 从小到大排序  (String类型同样)
//      set.add(34);
//      set.add(-34);
//      set.add(43);
//      set.add(11);
//      set.add(23);
        
        //举例二：
        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());
        }
    }

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

}

package com.zck.listtest;

/**
 * @author zck
 * @create 2020-04-08 19:17
 */

public class User implements Comparable{
    private String name;
    private int age;

//省略 getter（）、setter（）、构造器、toString（）
    @Override
    public boolean equals(Object o) {
        System.out.println("User equals()....");
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        if (age != user.age) return false;
        return name != null ? name.equals(user.name) : user.name == null;
    }

    @Override
    public int hashCode() { //return name.hashCode() + age;
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }

    //自然排序：按照姓名从大到小排列,年龄从小到大排列
    @Override
    public int compareTo(Object o) {
        if(o instanceof User){
            User user = (User)o;
//            return -this.name.compareTo(user.name);
            int compare = -this.name.compareTo(user.name);
            if(compare != 0){//若姓名相同，返回0
                return compare;
            }else{
                return Integer.compare(this.age,user.age);
            }
        }else{
            throw new RuntimeException("输入的类型不匹配");
        }

    }
}

注：本文章是根据哔哩哔哩公开课 Java -Java 学习- Java 基础到高级-宋红康-零基础自学Java-尚硅谷整理所得
大爱康师傅！！！

小张不会飞

关注

2
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
（Java学习笔记）JavaSE 集合：Collection接口（Liist、Set接口）

Collection接口Collection 接口是 List、Set 和 Queue 接口的父接口，该接口里定义的方法既可用于操作 Set 集合，也可用于操作 List 和 Queue 集合。目录：Collection接口Collection接口1、Collection接口方法2、子接口：List接口2.1、List接口方法2.11遍历的三种方式2.12、总结：常用方法2.2、Array...
复制链接

扫一扫