【进阶篇-Day9：JAVA中单列集合Collection、List、ArrayList、LinkedList的介绍】

目录

1、集合的介绍

[1.1 概念](#1.1 概念)

[1.2 集合的分类](#1.2 集合的分类)

2、单列集合：Collection

[2.1 Collection的使用](#2.1 Collection的使用)

[2.2 集合的通用遍历方式](#2.2 集合的通用遍历方式)

[`2.2.1 迭代器遍历：`](#2.2.1 迭代器遍历：)

（1）例子：

（2）迭代器遍历的原理：

（3）迭代器源码分析：

（4）总结：

[`2.2.2 增强for循环遍历：`](#2.2.2 增强for循环遍历：)

[`2.2.3 foreach遍历：`](#2.2.3 foreach遍历：)

[2.3 List集合](#2.3 List集合)

（1）和索引相关的方法：

（2）list集合的遍历方法：

[2.4 数据结构](#2.4 数据结构)

[2.4.1 栈和队列](#2.4.1 栈和队列)

[2.4.2 数组](#2.4.2 数组)

[2.4.3 链表](#2.4.3 链表)

[2.4.4 总结](#2.4.4 总结)

[2.5 ArrayList类和LinkedList类](#2.5 ArrayList类和LinkedList类)

[2.5.1 ArrayList类：](#2.5.1 ArrayList类：)

（1）ArrayList长度可变原理：

[2.5.2 LinkedList类：](#2.5.2 LinkedList类：)

1、集合的介绍

1.1 概念

1.2 集合的分类

注：集合分为单列集合 和 双列集合

单列集合：一次添加一个元素，实现了Collection接口。

双列集合：一次添加两个元素，实现了Map接口。

2、单列集合：Collection

注：Collection集合，可以分为List集合 和 Set集合

List集合：存取有序、有索引、可以存储重复的元素。
Set集合：存取无序、没有索引、不可以存储重复的元素。

2.1 Collection的使用

java 复制代码

package com.itheima.collection;

import java.util.ArrayList;
import java.util.Collection;

public class CollectionTest1 {
    /**
     * Collection的常用方法：
     *     public boolean add(E e):把给定的对象添加到当前集合中
     *     public void clear():清空集合中所有的元素
     *     public boolean isEmpty():判断当前集合是否为空
     *     public boolean remove(E e):把给定的对象在当前集合中删除
     *     public boolean contains(Object obj):判断当前集合中是否包含给定的对象
     *     public int size():返回集合中元素的个数（集合的长度）
     *
     */
    public static void main(String[] args) {
        //以多态的形式创建集合对象，调用单列集合中的共有方法
        Collection<String> c = new ArrayList<>();

        //1、add(E e):把给定的对象添加到当前集合中
        boolean b1 = c.add("张三");
        boolean b2 = c.add("李四");
        boolean b3 = c.add("王五");
        System.out.println(b1);//true 返回是否添加成功的状态
        System.out.println(b2);//true
        System.out.println(b3);//true
        System.out.println(c);//[张三, 张三, 张三]

        //2、clear():清空集合中所有的元素
        c.clear();
        System.out.println(c);//[]

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

        //4、remove(E e):把给定的对象在当前集合中删除
        c.add("马四");
        c.add("赵武");
        boolean remove = c.remove("马四");//返回值为是否删除成功的标记：删除存在的对象则返回true，删除不存在的对象则返回false
        System.out.println(c);//[赵武] 可以发现马四已经被删除了

        //5、contains(Object obj):判断当前集合中是否包含给定的对象
        boolean contains1 = c.contains("平平");
        System.out.println(contains1);//false 不包含则返回false
        boolean contains2 = c.contains("赵武");
        System.out.println(contains2);//true 包含则返回true

        //6、size():返回集合中元素的个数（集合的长度）
        System.out.println(c.size());//1
    }
}

2.2 集合的通用遍历方式

`2.2.1 迭代器遍历：`

（1）例子：

java 复制代码

package com.itheima.collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionTest3 {
    /**
     * public Iterator<E> iterator():获取遍历集合的迭代器
     *     1、public E next():从集合中获取一个元素
     *          注：如果next()调用超过了集合的大小，就会出现 NoSuchElementException 异常
     *     2、public boolean hasNext():如果任有元素可以迭代，则返回true
     */
    public static void main(String[] args) {
        Collection<Student> c = new ArrayList<>();
        Student s1 = new Student("张三", 11);//Student是自定义创建的类
        Student s2 = new Student("李四", 21);
        Student s3 = new Student("王五", 31);
        //添加三个对象
        c.add(s1);
        c.add(s2);
        c.add(s3);

        //1、获取迭代器
        Iterator<Student> iterator = c.iterator();

        //2、循环判断集合中是否还有元素
        while (iterator.hasNext()){//
            //3、调用next方法，从集合中获取一个元素
            Student next = iterator.next();
            System.out.println(next);
        }
    }
}

（2）迭代器遍历的原理：

总结：next()方法取出一个元素后，指针会向后移动一位。

（3）迭代器源码分析：

（4）总结：

`2.2.2 增强for循环遍历：`

java 复制代码

package com.itheima.collection;

import java.util.ArrayList;
import java.util.Collection;

public class CollectionTest4 {
    /**
     * 使用增强for循环遍历
     *
     */
    public static void main(String[] args) {
        Collection<Student> c = new ArrayList<>();
        Student s1 = new Student("张三", 11);//Student是自定义创建的类
        Student s2 = new Student("李四", 21);
        Student s3 = new Student("王五", 31);
        //添加三个对象
        c.add(s1);
        c.add(s2);
        c.add(s3);

        //使用增强for循环遍历
        for (Student s : c){
            System.out.println(s);
        }
    }
}

注：增强for循环 的遍历方式，其实就是迭代器遍历，当编译成字节码文件后，发现增强for循环代码就会转换为迭代器遍历方式。

`2.2.3 foreach遍历：`

java 复制代码

package com.itheima.collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Consumer;

public class CollectionTest4 {
    public static void main(String[] args) {
        Collection<Student> c = new ArrayList<>();
        Student s1 = new Student("张三", 11);//Student是自定义创建的类
        Student s2 = new Student("李四", 21);
        Student s3 = new Student("王五", 31);
        //添加三个对象
        c.add(s1);
        c.add(s2);
        c.add(s3);

        //使用foreach方法遍历
        c.forEach(e-> System.out.println(e));
    }
}

注：foreach底层也是迭代器遍历。

2.3 List集合

（1）和索引相关的方法：

java 复制代码

package com.itheima.collection.list;

import java.util.ArrayList;
import java.util.List;

public class ListDemo1 {
    /**
     * List接口的特点：存取有序、有索引、可以存储重复
     * 和索引有关的API:
     *     public void add(int index, E element):在指定的索引位置，添加元素
     *     public E set(int index, E element):根据索引修改集合中的元素
     *     public E remove(int index):根据索引删除集合中的元素
     *     public E get(int index):返回指定索引处的元素
     */
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        //1、add(int index, E element):在指定的索引位置，添加元素
        list.add("lisi");
        list.add("wangwu");
        list.add("maliu");
        list.add(1, "lisi");//在1号位置添加元素，原来1号位置及后面的元素都向后移动一位
        System.out.println(list);//[lisi, lisi, wangwu, maliu]

        //2、set(int index, E element):根据索引修改集合中的元素
        list.set(1, "马四");//修改索引为1的元素为马四
        System.out.println(list);//[lisi, 马四, wangwu, maliu]

        //3、remove(int index):根据索引删除集合中的元素
        list.remove(1);//删除索引为1的元素
        System.out.println(list);//[lisi, wangwu, maliu]

        //4、get(int index):返回指定索引处的元素
        System.out.println(list.get(1));//wangwu 获取索引为1的元素
    }
}

注意：remove()方法，如果list集合中存储的本身就是int类型，那么删除时会被当做索引，因此需要手动装箱，如下例子：

java 复制代码

package com.itheima.collection.list;
import java.util.ArrayList;
import java.util.List;
public class ListDemo {
        List<Integer> ll = new ArrayList<>();
        ll.add(111);
        ll.add(222);
        ll.add(333);
//        ll.remove(222);//222会被当作索引，这里就会报空指针，手动装箱，如下
        ll.remove(Integer.valueOf(222));
        System.out.println(ll);//[111, 333]
    }
}

（2）list集合的遍历方法：

java 复制代码

package com.itheima.collection.list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class ListDemo2 {
    /**
     * List集合的遍历方式：
     *     1、普通for循环
     *     2、迭代器遍历
     *     3、增强for循环
     *     4、foreach方法
     *     5、ListIterator（List集合特有的迭代器）
     *
     */
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("111");
        list.add("222");
        list.add("333");
        list.add("444");

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

        System.out.println("--------------------");

        //2、迭代器遍历
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

        System.out.println("--------------------");

        //3、增强for循环
        for (String s : list){
            System.out.println(s);
        }

        System.out.println("--------------------");

        //4、foreach方法
        list.forEach(item -> System.out.println(item));

        System.out.println("--------------------");

        //5、ListIterator（List集合特有的迭代器）
        ListIterator<String> listIterator = list.listIterator();
        while (listIterator.hasNext()){
            System.out.println(listIterator.next());
        }
        //上述ListIterator遍历和正常的一样，不一样的是可以倒叙遍历，同时增加了add()方法
        while (listIterator.hasPrevious()){
            System.out.println(listIterator.previous());
        }
    }
}

注意：在遍历过程中做删除、增加操作，可能会发生并发修改异常。

java 复制代码

package com.itheima.collection.list;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

/**
 * Title: ListDemo3
 * Describe: 类的功能
 * Name: masizhou
 * Date: 2024/7/13
 * Copyright: @2022 by masizhou
 */

public class ListDemo3 {
    /**
     * 在遍历过程中，如果有添加、删除元素操作时，会出现并发修改异常：ConcurrentModificationException
     * 【场景】：使用[迭代器]遍历集合的过程中，调用了[集合对象]的添加，删除方法，机会出现此异常
     * 【解决方案】：迭代器的遍历过程中，不允许使用集合对象的添加或删除，那就是用迭代器，自己的添加或删除方法
     *              删除方法：普通的迭代器有
     *              添加方法：普通的迭代器没有，需要使用list集合特有的迭代器
     *
     */
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");

        /*
        下面代码使用的是增强for循环，其实底层也是使用迭代器的方法，
        但这个时候增加和删除只能拿到集合的方法，没法使用迭代器的方法
        【解决方法】：手写迭代器进行遍历---这就是为啥手写迭代器遍历虽然麻烦，但是有特定使用的场景
        */
//        for (String s : list){
//            list.remove("bbb");
//        }
        ListIterator<String> listIterator = list.listIterator();
        while (listIterator.hasNext()){
            String s = listIterator.next();
            if ("aaa".equals(s)){
                listIterator.remove();
                listIterator.add("我是增加的元素");
            }
        }

        System.out.println(list);//[我是增加的元素, bbb, ccc, ddd]
    }
}

注意：

（1）我们在写代码，在遍历过程中需要对一个集合做增加或者删除操作时，一般会放在一个新的集合中，避免索引乱了的问题而导致空指针。

（2）但是为了节省内存，就是要操作原集合，那就使用迭代器的遍历方法，然后用迭代器的add和remove方法做增加和删除操作就可以解决这个问题。

2.4 数据结构

2.4.1 栈和队列

2.4.2 数组

2.4.3 链表

2.4.4 总结

2.5 ArrayList类和LinkedList类

2.5.1 ArrayList类：

java 复制代码

package com.itheima.collection.list;
import java.util.ArrayList;
import java.util.List;

public class ListDemo3 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();//多态
        list.add("aaa");
        list.add("bbb");

        System.out.println(list);
    }
}

（1）ArrayList长度可变原理：

注意：

2.5.2 LinkedList类：

java 复制代码

package com.itheima.collection.list;
import java.util.LinkedList;
import java.util.List;

public class ListDemo4 {
    /**
     * LinkedList特有方法：
     *     public void addFirst(E e):头部添加
     *     public void addLast(E e):尾部添加
     *     public E getFirst():获取第一个
     *     public E getLast():获取最后一个
     *     public E removeFirst():删除第一个
     *     public E removeLast():删除最后一个
     *
     */
    public static void main(String[] args) {
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("张三");
        linkedList.add("李四");
        linkedList.add("王五");

        //1、addFirst(E e):头部添加
        linkedList.addFirst("玛尔");
        System.out.println(linkedList);//[玛尔, 张三, 李四, 王五]

        //2、addLast(E e):尾部添加
        linkedList.addLast("马六");
        System.out.println(linkedList);//[玛尔, 张三, 李四, 王五, 马六]

        //3、getFirst():获取第一个
        System.out.println(linkedList.getFirst());//玛尔

        //4、getLast():获取最后一个
        System.out.println(linkedList.getLast());//马六

        //5、removeFirst():删除第一个
        LinkedList<String> l1 = new LinkedList<>();
        l1.add("aaa");
        l1.add("bbb");
        l1.add("ccc");
        l1.add("ddd");
        //l1 = [aaa, bbb, ccc, ddd]
        l1.removeFirst();
        System.out.println(l1);//[bbb, ccc, ddd]

        //6、removeLast():删除最后一个
        LinkedList<String> l2 = new LinkedList<>();
        l2.add("aaa");
        l2.add("bbb");
        l2.add("ccc");
        l2.add("ddd");
        //l2 = [aaa, bbb, ccc, ddd]
        l2.removeLast();
        System.out.println(l2);//[aaa, bbb, ccc]
    }
}

答：实际上就是从头或者从尾部开始遍历查找：

如果索引比集合长度的一半小，则从头找；

如果索引比集合长度的一半大，则从尾找；

注意！！！

双列集合在Day10里。。。