42、集合的第一大类：List

分手后的思念是犯贱 2024-03-31 11:18 40阅读 0赞

一、基本介绍：

1、List接口和常用方法

（1）List接口基本介绍：

***List接口是Collection接口的子接口***

1）List集合类中元素有序（即添加顺序和取出顺序一致），且可重复

2）List集合中每个元素都有其对应的顺序索引，即支持索引（索引从0开始）

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

4）JDK API中List接口的实现类有

![39e012f257dc4570befc3269f83f8bf6.png][]

其中常用的有：**ArrayList, LinkedList和Vector**

![18bed88a6809434abc9174f4f604efa8.png][]

·注意：**subList()**返回的是**\[fromIndex, toIndex）**

5)![fa8bdf128bf34239b6e71358860b88cb.png][]

//我的代码：

package Collection_;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    public class List01 {
        @SuppressWarnings({"all"})
        public static void main(String[] args) {
            List list=new ArrayList<>();
            list.add("hello");
            list.add("hello");
            list.add("hello");
            list.add("hello");
            list.add("hello");
            list.add("hello");
            list.add("hello");
            list.add("hello");
            list.add("hello");
            list.add("hello");
            System.out.println("list="+list);
            list.set(2,"韩顺平教育");
            System.out.println("list="+list);
            System.out.println("list的第5个元素是："+list.get(5));
            list.remove(6);
            list.set(7,"hi");
            System.out.println("=======使用迭代器遍历list=========");
            Iterator iterator=list.iterator();
            while (iterator.hasNext()) {
                Object next =  iterator.next();
                System.out.println(next);
            }
        }
    }
    //list=[hello, hello, hello, hello, hello, hello, hello, hello, hello, hello]
    //list=[hello, hello, 韩顺平教育, hello, hello, hello, hello, hello, hello, hello]
    //list的第5个元素是：hello
    //=======使用迭代器遍历list=========
    //hello
    //hello
    //韩顺平教育
    //hello
    //hello
    //hello
    //hello
    //hi
    //hello

//老师的代码：

package Collection_;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    public class ListExercise01 {
        @SuppressWarnings({"all"})
        public static void main(String[] args) {
            List list=new ArrayList();
            for(int i=0;i<12;i++){
                list.add("hello"+i);
            }
            System.out.println("list="+list);
            list.add(1,"韩顺平教育");
            System.out.println("list="+list);
            System.out.println("第五个元素："+list.get(4));
            list.remove(5);
            System.out.println("list="+list);
            list.set(6,"hi");
            System.out.println("list="+list);
            Iterator iterator=list.iterator();
            while (iterator.hasNext()) {
                Object obj =  iterator.next();
                System.out.println("obj="+obj);
            }
        }
    }
    //list=[hello0, hello1, hello2, hello3, hello4, hello5, hello6, hello7, hello8, hello9, hello10, hello11]
    //list=[hello0, 韩顺平教育, hello1, hello2, hello3, hello4, hello5, hello6, hello7, hello8, hello9, hello10, hello11]
    //第五个元素：hello3
    //list=[hello0, 韩顺平教育, hello1, hello2, hello3, hello5, hello6, hello7, hello8, hello9, hello10, hello11]
    //list=[hello0, 韩顺平教育, hello1, hello2, hello3, hello5, hi, hello7, hello8, hello9, hello10, hello11]
    //obj=hello0
    //obj=韩顺平教育
    //obj=hello1
    //obj=hello2
    //obj=hello3
    //obj=hello5
    //obj=hi
    //obj=hello7
    //obj=hello8
    //obj=hello9
    //obj=hello10
    //obj=hello11

2、List的三种遍历方式：

![9d803aafe8f3420eb1e7bdf7c2695d10.png][]

（1）![9c8a69ef6f044057847d5c822507f477.png][]

package Collection_;
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    public class ListExercise02 {
        @SuppressWarnings({"all"})
        public static void main(String[] args) {
            List list=new ArrayList();
            //List list=new LinkedList();
            //List list=new Vector();
            list.add(new Book("红楼梦","曹雪芹",100));
            list.add(new Book("西游记","吴承恩",10));
            list.add(new Book("水浒传","施耐庵",9));
            list.add(new Book("三国演义","罗贯中",80));
            for (Object o :list) {
                System.out.println(o);
            }
            sort(list);
            System.out.println("==================排序后===================");
            for (Object o :list) {
                System.out.println(o);
            }
        }
        public static void sort(List list){
            int listSize=list.size();
            for(int i=0;i<listSize-1;i++){
                for(int j=0;j<listSize-1-i;j++){
                    Book book1=(Book) list.get(j);//卡在了如何取出对象Book是关键，使用向下转型
                    Book book2=(Book) list.get(j+1);
                    if(book1.getPrice()>book2.getPrice()){
                        list.set(j,book2);
                        list.set(j+1,book1);
                    }
                }
            }
        }
    }
    class Book{
        private String bookName;
        private String author;
        private double price;
    
        public Book(String bookName, String author, double price) {
            this.bookName = bookName;
            this.author = author;
            this.price = price;
        }
    
        public String getBookName() {
            return bookName;
        }
    
        public void setBookName(String bookName) {
            this.bookName = bookName;
        }
    
        public String getAuthor() {
            return author;
        }
    
        public void setAuthor(String author) {
            this.author = author;
        }
    
        public double getPrice() {
            return price;
        }
    
        public void setPrice(double price) {
            this.price = price;
        }
        public void bubbleSort(List list){
        }
        @Override
        public String toString() {
            return "名称：" + bookName + '\t' + "价格：" + price + '\t' + "作者：" + author;
        }
    }
    //名称：红楼梦	价格：100.0	作者：曹雪芹
    //名称：西游记	价格：10.0	作者：吴承恩
    //名称：水浒传	价格：9.0	作者：施耐庵
    //名称：三国演义	价格：80.0	作者：罗贯中
    //==================排序后===================
    //名称：水浒传	价格：9.0	作者：施耐庵
    //名称：西游记	价格：10.0	作者：吴承恩
    //名称：三国演义	价格：80.0	作者：罗贯中
    //名称：红楼梦	价格：100.0	作者：曹雪芹

**3、ArrayList**

（1）注意事项：

1） permits all elements， including null，ArrayList 可以加入null，并且多个

2）ArrayList是由数组来实现数据存储的

3）ArrayList 基本等同于Vector，除了ArrayList是线程不安全（执行效率高）看源码，

在多线程情况下，不建议使用ArrayList

**（2）ArrayList的底层操作机制源码分析（重点，难点.）（B站第510集，还没有吃透）**

1）ArrayList中维护了一个Object类型的数组elementData．

*transient Object\[\] elementData; //transient表示瞬间、短暂的，表示该属性不会被序列化*

2） 当创建对象时，如果使用的是无参构造器，则初始elementData容量为0（jdk7是10）

3） 当添加元素时：先判断是否需要扩容，如果需要扩容，则调用grow方法，否则直接添加元素到合适位置

4） 如果使用的是无参构造器，如果第一次添加，需要扩容的话，则扩容elementData为10，如果需要再次扩容的话，则扩容elementData为1.5倍。

5）如果使用的是指定容量capacity的构造器，则初始elementData容量为capacity

6）如果使用的是指定容量capacity的构造器，如果需要扩容，则直接扩容elementData为1.5倍。

**4、Vector：**

1） Vector类的定义说明

public class vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, Serializable

2） Vector底层也是一个对象数组， *protected Object\[\] elementData；*

3） Vector 是线程同步的，即线程安全， Vector类的操作方法带有synchronized

public synchronized E get(int index) (
    if (index >= elementCount) 1
    throw new ArraylndexOutOfBoundsException(index); return elementData(index);

4）在开发中，需要线程同步安全时，考虑使用Vector

![99ca12b2d7064062b91f89f5683b3084.png][]

**5、LinkedList：**

（1）基本介绍：

1）LinkedList底层实现了双向链表和双端队列特点

2）可以添加任意元素（元素可以重复），包括null

3）线程不安全，没有实现同步

**（2）LinkedList的底层操作机制**

1）LinkedList底层维护了一个双向链表．

2）LinkedList中维护了两个属性first和last分别指向 首节点和尾节点

3） 每个节点（Node对象），里面又维护了prev、next、item三个属性，其中通过prev指向前一个，通过next指向后一个节点，item用于存放数据。最终实现双向链表.

![66706a16d5b3453c84a6084566d46c73.png][]

4）所以LinkedList的元素的添加和删除，不是通过数组完成的，相对来说效率较高。

5） 模拟一个简单的双向链表：

package Collection_;
    
    public class LinkedList_ {
        public static void main(String[] args) {
            //模拟一个简单的双向链表
            Node jack=new Node("jack");
            Node tom=new Node("tom");
            Node hsp=new Node("老韩");
    
            //连接三个结点，形成双向链表
            jack.next=tom;
            tom.next=hsp;
            //hsp-->tom-->jack
            hsp.pre=tom;
            tom.pre=jack;
            Node first=jack;//让first引用指向jack，就是双向链表的头结点
            Node last=hsp;//让last引用指向hsp，就是双向链表的尾结点
    
            System.out.println("=====从头到尾进行遍历======");
            while(true){
                if(first==null){
                    break;
                }
                System.out.println(first);
                first=first.next;
            }
    
            System.out.println("=====从尾到头进行遍历======");
            while(true){
                if(last==null){
                    break;
                }
                System.out.println(last);
                last=last.pre;
            }
    
            //添加一个对象，在tom和老韩之间直接插入一个对象smith
            Node smith=new Node("smith");
            smith.next=hsp;
            smith.pre=tom;
            hsp.pre=smith;
            tom.next=smith;
    
            //让first再次指向jack，就是双向链表的头结点
            first=jack;
            System.out.println("=====从头到尾进行遍历======");
            while(true){
                if(first==null){
                    break;
                }
                System.out.println(first);
                first=first.next;
            }
    
            last=hsp;//让last再次指向hsp，就是双向链表的尾结点
            System.out.println("=====从尾到头进行遍历======");
            while(true){
                if(last==null){
                    break;
                }
                System.out.println(last);
                last=last.pre;
            }
        }
    }
    class Node{
        public Object item;//真正存放数据
        public Node next;//指向后一个结点
        public Node pre;//指向前一个结点
        public Node(Object name){
            this.item=name;
        }
    
        @Override
        public String toString() {
            return "Node name="+item;
        }
    }
    //=====从头到尾进行遍历======
    //Node name=jack
    //Node name=tom
    //Node name=老韩
    //=====从尾到头进行遍历======
    //Node name=老韩
    //Node name=tom
    //Node name=jack
    //=====从头到尾进行遍历======
    //Node name=jack
    //Node name=tom
    //Node name=smith
    //Node name=老韩
    //=====从尾到头进行遍历======
    //Node name=老韩
    //Node name=smith
    //Node name=tom
    //Node name=jack

补：CRUD：表示增删改查（create, read, update, delete）

6、ArrayList和LinkedList的比较

![77bde31a057644f19acb3a42e2bef7a4.png][]

*（2）如何选择ArrayList和LinkedList：*

*1）如果我们改查的操作多，选择ArrayList*

*2） 如果我们增删的操作多，选择LinkedList*

*3） 一般来说，在程序中，80％—90％都是查询，因此大部分情况下会选择ArrayList*

*4） 在一个项目中，根据业务灵活选择，也可能这样，一个模块使用的是ArrayList，另外一个模块是LinkedList.*

[39e012f257dc4570befc3269f83f8bf6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/5a26a759ea37404a934d693057966e45.png
[18bed88a6809434abc9174f4f604efa8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/00951acb0d654f70b18ed5e15eb6a383.png
[fa8bdf128bf34239b6e71358860b88cb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/135c3a1fbf794aec8bba023ed4520f3f.png
[9d803aafe8f3420eb1e7bdf7c2695d10.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/3f4da40d4a6440b6adb433370ccdd19d.png
[9c8a69ef6f044057847d5c822507f477.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/3afdcc9a80634c75bcef671bdfa938b2.png
[99ca12b2d7064062b91f89f5683b3084.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/b50936cf12bd48d2aabca3546f811d49.png
[66706a16d5b3453c84a6084566d46c73.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/c74ea88addde47b0adb4ff2ddf8aff83.png
[77bde31a057644f19acb3a42e2bef7a4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/0e4508bd1bb04ffdba7935bcecd3c86e.png