List接口知识点整理

文章目录

ArrayList

List接口

Vector

LinkedList

ArrayList

概述

List 接口的大小可变数组的实现。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现
List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。（此类大致上等同于 Vector类，除了此类是不同步的。）
数据结构: 数据的存储方式
和集合相关的数据结构: 数组 栈 队列 链表 哈希表 二叉树
主要是观察集合的add方法

特点：

1. 底层数据结构是数组。
2. 增删效率低，改查效率高。
3. 能够存储null值。
4. 线程不安全，效率高可以通过Collection.Collections.synchronizedList();变安全。
5. 有索引，能够方便检索。
6. 元素可重复，我们可以通过选择排序去重复（添加一组不重复的元素）。
7. 不可以排序，但是可以通过Collections.sort();方法排序

Collection.Collections.synchronizedList()方法的使用

List list = Collections.synchronizedList(new ArrayList<>());
list.add(1);
list.add(2);
list.add(3);
synchronized (list){
    Iterator iterator = list.iterator();
    while (iterator.hasNext()) {
        Object next =  iterator.next();
        System.out.println(next);
    }
}

为什么只锁遍历的代码？经过看源码发现add方法已经锁过了，无需再锁。

Java中Collections.sort()的使用!

在日常开发中，很多时候都需要对一些数据进行排序的操作。然而那些数据一般都是放在一个集合中如：Map ，Set ，List 等集合中。他们都提共了一个排序方法 sort()，要对数据排序直接使用这个方法就行，但是要保证集合中的对象是 可比较的。

怎么让一个对象是 可比较的，那就需要该对象实现 Comparable 接口啦。然后重写里面的。

public class Student implements Comparable<Student>{
    private int age;
    private String name;

    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    @Override
    public int compareTo(Student o) {
        //降序
        //return o.age - this.age;
        //升序
        return this.age - o.age;
    }


    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student(1,"25"));
        list.add(new Student(3,"21"));
        list.add(new Student(2,"18"));
        list.add(new Student(4,"32"));
        list.add(new Student(5,"36"));
        list.add(new Student(6,"16"));
        System.out.println("排序前:");
        for (Student student : list) {
            System.out.println(student.toString());
        }
        Collections.sort(list);
        System.out.println("默认排序后:");
        for (Student student : list) {
            System.out.println(student.toString());
        }


    }
    }

这里说一下重写的 public int compareTo(Student o){} 这个方法，它返回三种 int 类型的值： 负整数，零 ，正整数。

返回值	含义
负整数	当前对象的值 < 比较对象的值 ， 位置排在前
零	当前对象的值 = 比较对象的值 ， 位置不变
正整数	当前对象的值 > 比较对象的值 ， 位置排在后

这个时候需求又来了，默认是用 age 排序，但是有的时候需要用 id 来排序怎么办？ 这个时候比较器 ：Comparator 就排上用场了。

Comparator 的使用有两种方式：

Collections.sort(list,Comparator<T>）;
list.sort(Comparator<T>);

其实主要是看 Comparator 接口的实现，重写里面的 compare 方法。代码如下：

Collections.sort(list, new Comparator<Student>() {
    @Override
    public int compare(Student o1, Student o2) {
            return o1.getId-o2.getId;
    }
});

compare(Student o1, Student o2) 方法的返回值跟 Comparable<> 接口中的 compareTo(Student o) 方法 返回值意思相同。另一种写法如下：

//自定义排序2

list.sort(new Comparator<Student>() {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.getId() - o2.getId();
    }
});

去重复

1. 创建一个新集合

List list = new ArrayList();
list.add(2);
list.add(1);
List list2 = new ArrayList();
list2.add(1);
for (Object o : list) { //遍历旧集合，看新集合中是否包含旧集合的内容
    if (!list2.contains(o)){
        list2.add(o);
    }
}
for (Object o : list2) {
    System.out.println(o);//遍历新集合
}

2. 选择排序思想去重复

Vector

类似于ArrayList，底层数据结构是数组，插入和移除性能较差，线程安全，效率低。

特点：

1. 底层数据结构是数组
2. 有索引，能够方便检索
3. 增加和删除的效率低，查询和修改的效率高
4. 线程安全，效率低
5. 能够存储 null 值
6. 元素可重复【我们自己可以通过选择排序思想去除重复元素】
7. 不可以排序，但是可以通过 Collections.sort();方法排序

Vector类特有功能

1.public void addElement(E obj) 添加元素 obj 到集合中
2.public E elementAt(int index) 获取指定索引 index 的元素
3.public Enumeration elements() 使用 Enumeration 迭代器遍历集合中的元素

ArrayList和Vector的区别？

1. Vector的方法都是同步的，线程安全的，但是线程的同步必然会影响到性能，所以ArrayList效率比Vector高
2. 当两者中的元素超过他们的初始大小时，Vector会以2倍扩容，但是ArrayList以1.5倍扩容，这样ArrayList有利于节约内存空间。

LinkedList

特点：

1. 底层数据结构是链表。

2. 链表的特点是有序，查找跟修改的效率低，增加跟删除效率高。

3. 可以存储null值。

4. 线程不安全。

5. 允许重复。

6. 不可排序

特有方法：

• void addFirst(E e)
• void addLast(E e)
• E getFirst()
• E getLast()
• E removeFirst()
• E removeLast()