Java--Collection集合

喜欢ヅ旅行 2024-04-08 12:44 15阅读 0赞

> 掌握Collection接口下每个集合底层的数据结构，熟悉集合的常用方法，学会创建集合并对其进行操作

#### 文章目录 ####

*  集合概述
 *   *  Collection集合继承结构
     *  Collection接口
     *   *  Collection接口的常用方法
         *  Collection接口的通用迭代
         *  集合迭代过程中的删除
     *  List接口
     *   *  List集合之ArrayList
         *  List集合之LinkedList
         *  List集合之Vector
     *  Set接口
     *   *  Set集合之HashSet
         *  Set集合之TreeSet
     *  泛型
     *   *  如何自定义泛型
     *  Collections工具类

--------------------

## 集合概述 ##

*  集合实际上是一个容器，一个载体，可以容纳其他类型的数据。
 *  集合不能直接存储基本数据类型，也不能直接存储Java对象，集合当中存储的都是Java对象的内存地址(**存储的是引用**)。

list.add(100); //自动装箱 Integer

*  在Java中每一个不同的集合，底层会对应不同的数据结构，往不同的集合中存储元素，等于数据放到了不同的数据结构当中。数据存储的结构就是数据结构。不同的数据结构，数据存储方式不同。
 *  所有的集合类和集合接口在java.until包下

### Collection集合继承结构 ###

**结构继承图：**  
![在这里插入图片描述][d9e7cdaf86084b3592842849fe903601.png]

### Collection接口 ###

#### Collection接口的常用方法 ####

以为Collection接口是公共的，所有集合都有这个接口中的方法，Collection接口的常用方法如下：  
boolean add(Object e); 向集合中添加元素  
int size(); 获取集合元素的个数  
void clear(); 清空集合  
boolean contains(Object o); 判断集合是否包含元素o  
boolean remove(Object o); 删除集合中某个元素  
boolean isEmpty(); 判断集合中元素个数是否为0  
Object\[ \] toArray();把集合转换成数组

import java.util.ArrayList;
    import java.util.Collection;
    public class Test01 {
        
        public static void main(String[] args) {
        
            //创建集合对象
           Collection c = new ArrayList();
    
            //向集合中添加元素
            c.add(1100); //自动装箱  Integer x = new Integer();
            c.add(true);
            c.add(new Object());
    
            //获取集合中元素个数
            System.out.println("集合中元素个数："+c.size()); //3
            //删除集合中某个元素
            c.remove(1100);
            System.out.println("集合中元素个数："+c.size()); //2
    
            //清空集合
            c.clear();
            System.out.println("集合中元素个数："+c.size()); //0
    
    
            //判断集合中是否包含某个元素
            c.add("Hello");
            c.add("word");
            c.add("lic");
            System.out.println(c.contains("lic")); //true
    
            //判断集合是否为空(集合中是否存在元素)
            System.out.println(c.isEmpty()); //false
    
            //集合转化成数组
            Object[] objects = c.toArray();
            for (Object o: objects
                 ) {
        
                System.out.print(o+" ");
            }
        }
    }

运行结果如下：  
![在这里插入图片描述][cab1850bae70455696f41b5c96c74464.png]

常用方法中的contains方法和remove方法在使用时会调用equals方法。  
![在这里插入图片描述][838ab46c49e040ec93353001a1a0e7ce.png]  
以上源码可知，contains方法调用indexOf方法，而indexOf方法调用equals方法。所以集合在判断是否包含某个元素o，集合会拿着自己集合中每一个元素和o比较，如果equals方法返回为true，则表示包含元素o。

示例：自定义Date类,此时没有重写equals方法，看看会出现问题吗。

class Date{
        
        private int year;
        private int month;
        private int day;
    
        public Date(int year, int month, int day) {
        
            this.year = year;
            this.month = month;
            this.day = day;
        }
    
        public int getYear() {
        
            return year;
        }
    
        public void setYear(int year) {
        
            this.year = year;
        }
    
        public int getMonth() {
        
            return month;
        }
    
        public void setMonth(int month) {
        
            this.month = month;
        }
    
        public int getDay() {
        
            return day;
        }
    
        public void setDay(int day) {
        
            this.day = day;
        }
    
    }

测试类：

import java.util.ArrayList;
    import java.util.Collection;
    public class Test02 {
        
        public static void main(String[] args) {
        
            //创建集合
           Collection c = new ArrayList();
           //创建Date对象 d1
            Date d1 = new Date(2022, 8, 27);
            //将d1添加到集合c
            c.add(d1);
            //判断集合中是否包含
            Date d2 = new Date(2022, 8, 27);
            System.out.println(c.contains(d2));
        }
    }

运行结果：  
![在这里插入图片描述][f9d357e2321b41bfb26bd9f55b158757.png]  
但是通过看代码，实际上集合中包含“2022年8月27日”这个数据，但结果说明不包含，这是出现了什么问题？  
问题在于没有重写Date的equals方法，不重写equals方法，调用的是Object类的equals。比较对象的内存地址，这里应该比较内容，就需要重写Date类的equals方法。

@Override
        public boolean equals(Object o) {
        
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Date date = (Date) o;
            return year == date.year && month == date.month && day == date.day;
        }

运行结果：![在这里插入图片描述][2fd6e467afec42f78b682be3607576ae.png]  
*说明放在集合中的元素是需要重写equals方法的！！*

测试remove方法有没有调用equals方法。

import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Objects;
    
    public class Test02 {
        
        public static void main(String[] args) {
        
            //创建集合
           Collection c = new ArrayList();
            //添加a元素
            Integer a = new Integer(100);
            c.add(a);
            //删除b元素
            Integer b = new Integer(100);
            c.remove(b);
            //元素个数
            System.out.println(c.size());
        }

运行结果：  
![在这里插入图片描述][937650995be5483d874fef0fc0dcf210.png]  
以上程序中删除集合的b元素，a也被删除了。说明remove方法调用equals方法。更加说明了存储在集合中的元素需要重写equals方法。

#### Collection接口的通用迭代 ####

集合的遍历又叫集合的迭代，Java的集合框架中，Collection接口继承了Iterable接口，表示Collection集合元素都是可迭代的，集合Collection通过调用iterator方法获取迭代器对象，通过Iterator迭代器接口的hasNext和next方法完成集合元素的迭代。  
示例：

import java.util.ArrayList;
    import java.util.Collection;
    import java.util.HashSet;
    import java.util.Iterator;
    /*
    集合遍历、迭代专题
     */
    public class Text03 {
        
        public static void main(String[] args) {
        
            Collection c = new ArrayList();
            c.add(100);
            c.add("hello");
            c.add(new Object());
            c.add(100);
    
            //获取集合的迭代器对象
            Iterator it = c.iterator();
            /*
            迭代器对象的两个方法
            boolean hasNext  返回true表示还有元素可以迭代
            Object next 让迭代器前进一位，并将指向的元素返回
             */
            while (it.hasNext()){
        
                //存进去什么类型，取出来还是什么类型
                Object obj = it.next();
                //输出转换成字符串，println调用toString类型
                System.out.println(obj);
                }
            }
        }

运行结果如下：  
![在这里插入图片描述][086f5bcc291b43e5b4c9ed2df92b6091.png]

#### 集合迭代过程中的删除 ####

使用迭代器遍历集合过程中删除集合的元素，调用迭代器的remove方法删除元素

import java.util.ArrayList;
    import java.util.Collection;
    import java.util.HashSet;
    import java.util.Iterator;
    
    /*
    集合遍历、迭代专题
     */
    public class Text03 {
        
        public static void main(String[] args) {
        
                 //创建集合
                 Collection c2 = new HashSet();
                 //加入元素
                 c2.add(100);
                 c2.add(100);
                 c2.add("lic");
                 c2.add(200);
                 c2.add(400);
                 c2.add("li");
                 //生成迭代器
                Iterator it2 = c2.iterator();
                while(it2.hasNext()){
        
                    Object obj2 = it2.next();
                    //使用迭代器的remove方法删除元素
                    it2.remove();
                    System.out.println(obj2);
                }
            System.out.println(c2.size());
            }
        }

### List接口 ###

*  1.List集合特点：有序可重复。 元素有下标；从0开始，以1递增。存储一个1可以再存储一个1
 *  2.List集合是Collection接口的子接口，有特有的方法。
 *  在Java中，List接口是一个有序的集合，它允许我们按顺序存储和访问元素。
 *  来看一下List集合的特有的方法。

import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    /*
    1.List集合特点：有序可重复。 元素有下标；从0开始，以1递增。存储一个1可以再存储一个1
    2.List集合是Collection接口的子接口，有特有的方法
    
     */
    public class Test01 {
        
        public static void main(String[] args) {
        
            //创建List接口的集合
            List list = new ArrayList();
            //添加元素
            list.add("A");
            list.add("A");
            list.add("B");
            list.add("C");
            list.add("D");
            list.add(1,"lic");
            //生成迭代器
            Iterator it = list.iterator();
            //遍历
            while ((it.hasNext())){
        
                System.out.println(it.next());
            }
            
            //根据下标获取元素
            System.out.println(list.get(0));
           
            //有下标，通过下标遍历集合的元素
            for (int i = 0; i < list.size(); i++) {
        
    
                System.out.println(list.get(i));
            }
    
            //获取指定对象第一次出现的索引
            System.out.println(list.indexOf("A"));
    
            //获取指定对象最后一次出现的索引
            System.out.println(list.lastIndexOf("A"));
    
            //删除指定下标位置的元素
            list.remove(1);
            System.out.println(list.size());
    
            //修改指定位置的元素
            System.out.println(list.set(1, "lng"));
    
            for (int i = 0; i < list.size(); i++) {
        
    
                System.out.println(list.get(i));
            }
        }
    }

#### List集合之ArrayList ####

*  默认初始化容量是10
 *  集合底层是一个Object\[ \] 数组
 *  底层是数组的优点：检索效率比较高；缺点：随意增删元素效率低
 *  构造方法： new ArrayList(); (无参构造)。 new ArrayList(int a);(有参构造）ArrayList(Collection c); （构造一个包含指定collection的元素的列表，元素按照该collection的迭代器返回排列顺序）
 *  ArrayList集合的扩容：原容量的1.5倍

import java.util.ArrayList;
    import java.util.Collection;
    import java.util.HashSet;
    import java.util.List;
    
    public class Test02 {
        
        public static void main(String[] args) {
        
            //默认初始化为0
            List list1 = new ArrayList();
            //指定初始化容量100
            List list2 = new ArrayList(100);
            //创建HashSet集合
            Collection c = new HashSet();
            //添加元素
            c.add(1);
            c.add(2);
            c.add(3);
            //HashSet集合转化为List集合
            List list3 = new ArrayList(c);
            for (int i = 0; i < list3.size(); i++) {
        
                System.out.println(list3.get(i));
            }
        }
    }

#### List集合之LinkedList ####

*LinkedList底层数据结构的链表：单向链表、双向链表、循环链表。*

链表最基本的单元是结点，在单向链表中，每一个结点由两部分组成：存储的数据data、指向下一结点的内存地址next。并且每个结点在空间存储上内存地址不连续，和数组完全不同。

在双向链表中，有三部分组成：存储的数据data、指向上一结点的内存地址、指向下一结点的内存地址。

每个结点在空间存储上内存地址不连续，无法通过数学表达式计算要查找的元素的内存地址，所以只能从头节点开始，一个一个挨着查找，所以检索效率低。但是新增或删减元素时，就不需要涉及大量元素位移问题，所以增删效率高。  
**综上**：  
**链表的优点：随机增删元素效率高。  
链表的缺点：检索效率较低。**

#### List集合之Vector ####

Vector底层也是数组，初始化容量是10，扩容后是原容量的2倍，Vector中所有的方法都是线程同步的，带有synchronized关键字，是线程安全的。效率低，使用少。

将线程不安全的ArrayList集合转换成线程安全:

Collections.synchronizedList(ArrayList);

### Set接口 ###

Set集合存储元素的特点：无序不可重复。无序指元素没有下标，不可重复就是存一个元素后，就不能存相同的元素了。

#### Set集合之HashSet ####

*  HashSet底层就是HashMap  
    ![在这里插入图片描述][12a1d5f185784875a2b222df8b1516e3.png]
 *  向HashSet中添加元素，实际就是把该元素作为键添加到底层的HashMap
 *  HashSet就是HashMap键的集合  
    ![在这里插入图片描述][5b5e5649bf6d4aeab0f6abb6694db7a4.png]

HashSet hashSet = new HashSet();
            hashSet.add("a");
            hashSet.add("a");
            hashSet.add("b");
            hashSet.add("ff");
            hashSet.add("ee");
            for (Object s:hashSet
                 ) {
        
                System.out.println(s);
            }

运行结果：

![在这里插入图片描述][21ec1766e06348caadfe18e0f4ea6ead.png]

#### Set集合之TreeSet ####

TreeSet集合实现了SortSet接口。特点是：没有下标，不可重复，但是存进去的元素会自动按照大小顺序排序，称为可排序集合（**无法对自定义类型排序，因为没有说明自定义类型的比较规则**）。

*  TreeSet底层是TreeMap  
    ![7e19fce3a11b48b9b37e793572569a26.png][]
 *  在创建TreeSet时，可以指定Comparator比较器，对集合中的元素进行比较

import java.util.Comparator;
    import java.util.TreeSet;
    
    public class Test06 {
        
        public static void main(String[] args) {
        
            TreeSet<String> treeSet = new TreeSet<>(Comparator.reverseOrder());
            treeSet.add("ad");
            treeSet.add("ac");
            treeSet.add("bc");
    //调用比较器  降序排序
            System.out.println(treeSet);
        }
    }

*  没有指定Comparator比较器，就要求元素的类实现Comparable接口

import java.util.Iterator;
    import java.util.TreeSet;
    //TreeSet里编写Comparable接口
    //如果年龄相同，比较名字
    public class Test08 {
        
        public static void main(String[] args) {
        
    
            TreeSet<user> users = new TreeSet<>();
    
            users.add(new user(12,"ued"));
            users.add(new user(12,"lic"));
            users.add(new user(15,"drc"));
            users.add(new user(13,"wsc"));
    
            Iterator<user> iterator = users.iterator();
            while (iterator.hasNext()){
        
                user next = iterator.next();
                System.out.println(next);
            }
    
        }
    }
    class user implements  Comparable<user>{
        
        int age;
        String name;
    
        public user(int age, String name) {
        
            this.age = age;
            this.name = name;
        }
    
        @Override
        public String toString() {
        
            return "user{" +
                    "age=" + age +
                    ", name='" + name + '\'' +
                    '}';
        }
    
        @Override
        public int compareTo(user o) {
        
            if(this.age==o.age){
        
                return this.name.compareTo(o.name);
            }else{
        
                return this.age-o.age;
            }
        }
    }

结果如下：  
![在这里插入图片描述][ad589544c9564b62b59668fd55207b40.png]

*  如果不调用，默认是升序

//不调用  默认升序
            TreeSet<String> treeSet1 = new TreeSet<>();
            treeSet1.addAll(treeSet);
            System.out.println(treeSet1);

结果如下：  
![在这里插入图片描述][3025a9b1763e49a2abf85b1113c32425.png]

### 泛型 ###

泛型就是把数据类型作为参数传递，在集合框架使用频繁，泛型的好处是在编译时可以进行数据类型的检查。

*  没有使用泛型，不明确集合存储元素是什么类型，可能会进行强制转型

import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    public class Test07 {
        
        public static void main(String[] args) {
        
            Collection list = new ArrayList();
            //添加元素
            list.add("aaa");
            list.add("bbb");
            list.add("ccc");
            //遍历
            Iterator iterator = list.iterator();
                    
            while (iterator.hasNext()){
        
                //没有使用泛型，返回Object类型
                Object s = iterator.next();
                //使用String类的方法需要 向下转型
                String str = (String) s;
                System.out.println(str.substring(1));
            }
    
        }
    }

*  使用泛型后，在编译阶段起作用，明确元素类型，不用强转类型了

import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    public class Test07 {
        
        public static void main(String[] args) {
        
            //定义集合使用泛型，list只能存储String类型的元素
            Collection<String> list = new ArrayList<>();
            //添加元素
            list.add("aaa");
            list.add("bbb");
            list.add("ccc");
            //遍历
            Iterator<String> iterator = list.iterator();
            //使用泛型后，iterator返回String类型，而不是Object类型
            while (iterator.hasNext()){
        
                String s = iterator.next();
                System.out.println(s.substring(1));
            }
        }
    }

#### 如何自定义泛型 ####

自定义泛型时，<>里面的内容是标识符，任意定义合法的标识符。比如下面Test05使用的泛型类型是，那么Method方法的参数类型也必须是T

import java.util.*;
    //自定义泛型
    public class Test05 <T> {
        
    
        public void Method(T o){
        
            System.out.println(o);
        }
    
        public static void main(String[] args) {
        
            Test05<Integer> a = new Test05<>();
            a.Method(12);
            Test05<String> b = new Test05<>();
            b.Method("aa");
        }
    }

### Collections工具类 ###

Collection是一个集合接口，Collections是一个集合工具类，升序排序、降序排序、二分法查找、非线程安全集合转换成线程安全集合，但是Collections传进去的参数只能是List。

import java.util.*;
    
    //Collection是一个集合接口 Collections是一个集合工具类
    public class collections {
        
        public static void main(String[] args) {
        
    
            Set<Integer> set = new HashSet<>();
            //Set集合之后就是线程安全的
            Collections.synchronizedSet(set);
            //添加元素
            set.add(21);
            set.add(5);
            set.add(15);
            set.add(8);
    
            //通过构造方法 Set集合转化为List集合
            List<Integer> list = new ArrayList<>(set);
            //升序排序
            Collections.sort(list);
            //输出
            for (Integer s:list
                 ) {
        
                System.out.println(s);
            }
    
            //二分法查找
            System.out.println("5所在的下标:"+Collections.binarySearch(list, 8));
    
            //降序排序 反转
            Collections.reverse(list);
            for (Integer in:list
                 ) {
        
                System.out.println(in);
            }
        }
    }

[d9e7cdaf86084b3592842849fe903601.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/109ecd3403924fdcac23075e02b2ea97.png
[cab1850bae70455696f41b5c96c74464.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/36d8027dea9e41f09c3842d716a9c53c.png
[838ab46c49e040ec93353001a1a0e7ce.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/8208ee5064db45f6823939e4555cdbc2.png
[f9d357e2321b41bfb26bd9f55b158757.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/5a1780948d2644909d75da2bef4f10f1.png
[2fd6e467afec42f78b682be3607576ae.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/41c7a8bee05a4032baac769b3d920946.png
[937650995be5483d874fef0fc0dcf210.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/5d75e706ef544dd4b2782700b21ef092.png
[086f5bcc291b43e5b4c9ed2df92b6091.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/4187bf0d2bfe4205824d56735e751713.png
[12a1d5f185784875a2b222df8b1516e3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/28d9f8f90f40410abf04001df671a02e.png
[5b5e5649bf6d4aeab0f6abb6694db7a4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/ebe3b8b7a8dc4816aae4209ebbb45ddc.png
[21ec1766e06348caadfe18e0f4ea6ead.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/a5ef7332302b474cb2ac72dc3328115c.png
[7e19fce3a11b48b9b37e793572569a26.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/9f69b0b153dd4fe58e667b7ef9ae27e7.png
[ad589544c9564b62b59668fd55207b40.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/d00fafd1ab7843b4abf672dbca7ec55d.png
[3025a9b1763e49a2abf85b1113c32425.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/5180e7976be84bb68846fcde80f63c4d.png