各自的优劣

用Comparable 简单， 只要实现Comparable 接口的对象直接就成为一个可以比较的对象，但是需要修改源代码。

用Comparator 的好处是不需要修改源代码， 而是另外实现一个比较器， 当某个自定义的对象需要作比较的时候，把比较器和对象一起传递过去就可以比大小了， 并且在Comparator 里面用户可以自己实现复杂的可以通用的逻辑，使其可以匹配一些比较简单的对象，那样就可以节省很多重复劳动了。

Comparable和Comparator的 介绍和实例

Comparable

Comparable是排序接口。若一个类实现了Comparable接口，就意味着该类支持排序。实现了Comparable接口的类的对象的列表或数组可以通过Collections.sort或Arrays.sort进行自动排序。此外，实现此接口的对象可以用作有序映射中的键或有序集合中的集合，无需指定比较器。该接口定义如下：

package java.lang;
import java.util.*;
public interface Comparable<T> 
{
    public int compareTo(T o);
}

此接口只有一个方法compareTo，比较此对象与指定对象的顺序，如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。

现在有两个Person类的对象，我们如何来比较二者的大小呢？我们可以通过让Person实现Comparable接口：

public class Person implements Comparable<Person>
{
    String name;
    int age;
    public Person(String name, int age)
    {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
    @Override
    public int compareTo(Person p)
    {
        return this.age-p.getAge();
    }
    public static void main(String[] args)
    {
        Person[] people=new Person[]{new Person("xujian", 20),new Person("xiewei", 10)};
        System.out.println("排序前");
        for (Person person : people)
        {
            System.out.print(person.getName()+":"+person.getAge());
        }
        Arrays.sort(people);
        System.out.println("\n排序后");
        for (Person person : people)
        {
            System.out.print(person.getName()+":"+person.getAge());
        }
    }
}

执行结果

Comparator

Comparator是比较接口，我们如果需要控制某个类的次序，而该类本身不支持排序(即没有实现Comparable接口)，那么我们就可以建立一个“该类的比较器”来进行排序，这个“比较器”只需要实现Comparator接口即可。也就是说，我们可以通过实现Comparator来新建一个比较器，然后通过这个比较器对类进行排序。该接口定义如下：

package java.util;
public interface Comparator<T>
 {
    int compare(T o1, T o2);
    boolean equals(Object obj);
 }

注意

1、若一个类要实现Comparator接口：它一定要实现compare(T o1, T o2) 函数，但可以不实现 equals(Object obj) 函数。

2、int compare(T o1, T o2) 是“比较o1和o2的大小”。返回“负数”，意味着“o1比o2小”；返回“零”，意味着“o1等于o2”；返回“正数”，意味着“o1大于o2”。

现在假如上面的Person类没有实现Comparable接口，该如何比较大小呢？我们可以新建一个类，让其实现Comparator接口，从而构造一个“比较器"。

public class PersonCompartor implements Comparator<Person>
{
    @Override
    public int compare(Person o1, Person o2)
    {
        return o1.getAge()-o2.getAge();
    }
}
public class Person
{
    String name;
    int age;
    public Person(String name, int age)
    {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
    public static void main(String[] args)
    {
        Person[] people=new Person[]{new Person("xujian", 20),new Person("xiewei", 10)};
        System.out.println("排序前");
        for (Person person : people)
        {
            System.out.print(person.getName()+":"+person.getAge());
        }
        Arrays.sort(people,new PersonCompartor());
        System.out.println("\n排序后");
        for (Person person : people)
        {
            System.out.print(person.getName()+":"+person.getAge());
        }
    }
}

执行结果

Collection 和 Collections 有什么区别？

Collection和Collections是Java集合框架中的两个不同的概念。

1. Collection是Java集合框架中的一个接口，它是所有集合类的根接口，提供了一些通用的方法，如添加、删除、遍历等。

2. Collections是Java集合框架中的一个工具类，提供了一系列静态方法，用于对集合进行操作，如排序、查找、替换、复制、反转等。

简而言之，Collection是一个接口，表示集合类的基本特性和行为，而Collections是一个工具类，提供了对集合进行操作的方法。

Collections 常用的方法有哪些

Collections是Java集合框架中的一个工具类，提供了一系列常用的集合操作方法，包括排序、查找、替换、复制、反转等。常用的Collections方法包括：

1. sort(List<T> list)：对List集合进行排序，排序规则为自然顺序（从小到大）。

2. sort(List<T> list, Comparator<? super T> c)：对List集合进行排序，排序规则由Comparator指定。

3. binarySearch(List<? extends Comparable<? super T>> list, T key)：在有序List集合中查找指定元素，返回元素的索引值。

4. binarySearch(List<? extends T> list, T key, Comparator<? super T> c)：在有序List集合中查找指定元素，返回元素的索引值，查找规则由Comparator指定。

5. reverse(List<?> list)：反转List集合中的元素。

6. shuffle(List<?> list)：随机打乱List集合中的元素顺序。

7. swap(List<?> list, int i, int j)：交换List集合中指定位置的两个元素。

8. fill(List<? super T> list, T obj)：将List集合中的所有元素替换为指定元素。

9. copy(List<? super T> dest, List<? extends T> src)：将src集合中的元素复制到dest集合中。

10. max(Collection<? extends T> coll)：返回Collection集合中的最大元素。

11. min(Collection<? extends T> coll)：返回Collection集合中的最小元素。

迭代器Iterator

迭代器 Iterator 是什么？

迭代器（Iterator）是Java集合框架中的一个接口，用于遍历集合中的元素。迭代器提供了一种通用的遍历方式，可以遍历任何类型的集合，包括List、Set、Map等。它可以实现集合的单向遍历，即只能从前往后遍历，不能倒着遍历。在遍历过程中，可以删除集合中的元素，但不能修改集合中的元素。

Iterator 怎么使用？

（1）Iterator（）要求容器返回一个Iterator。Iterator将准备好返回序列的第一个元素。

（2）使用next（）获得序列中的下一个元素

（3）使用hasNext（）检查序列中是否还有元素。

（4）使用remove（）删除上一次Iterator.next()方法返回的对象。

List list = new ArrayList<>();
Iterator iterator = list.iterator();//list集合实现了Iterable接口
while (iterator.hasNext()) {
    String string = iterator.next();
    //do something
}

Iterator有什么优点？

迭代器（Iterator）是Java集合框架中的一个重要接口，具有以下优点：

1. 通用性强：迭代器提供了一种通用的遍历方式，可以遍历任何类型的集合，包括List、Set、Map等。

2. 简单易用：使用迭代器遍历集合非常简单，只需要通过调用Iterator的方法，如hasNext()、next()、remove()等，即可完成遍历。

3. 安全可靠：使用迭代器遍历集合可以保证线程安全，避免了多线程环境下的并发访问问题。

4. 支持删除操作：使用迭代器遍历集合可以方便地删除集合中的元素，而不需要考虑删除元素后的索引变化问题。

5. 性能高效：使用迭代器遍历集合的性能非常高效，尤其是对于大型集合，可以避免一次性加载所有元素的问题。

Iterator有什么特点？

Iterator是Java集合框架中的一个接口，用于遍历集合中的元素。它的特点如下：

1. 可以遍历任何类型的集合，包括List、Set、Map等。

2. 可以实现集合的单向遍历，即只能从前往后遍历，不能倒着遍历。

3. 可以在遍历过程中删除集合中的元素，但不能修改集合中的元素，否则会抛出ConcurrentModificationEception的异常。

4. 可以使用泛型，避免了类型转换的麻烦。

5. Iterator必须依附于一个集合类对象而存在，Iterator本身不具有装载数据对象的功能。

如何边遍历边移除 Collection 中的元素？

边遍历边移除Collection 的唯一正确方式是使用 Iterator.remove() 方法，如下：

List list = new ArrayList<>();
Iterator<Integer> it = list.iterator();
//正确的移除方法
while(it.hasNext()){
//设置移除元素的条件
    it.remove();
} 
//一种最常见的错误代码如下
for(Integer i : list){ 
    list.remove(i)；//报 ConcurrentModificationException 异常
}

骚戴理解：也就是只能通过迭代器实例的remove方法来移除，而不能通过集合本身的remove方法来移除，如果用集合本身的remove方法就会触发fail-fast机制产生ConcurrentModificationException 异常，因为不允许一个线程在遍历 Collection 时另一个线程修改它。

Iterator 和 ListIterator 有什么区别？

Iterator和ListIterator都是Java集合框架中的接口，用于遍历集合中的元素。它们的主要区别如下：

1. 遍历方向不同：Iterator只能向前遍历集合中的元素，而ListIterator可以向前或向后遍历集合中的元素。

2. 支持元素操作不同：Iterator只能遍历集合中的元素，不能进行添加、修改等操作，而ListIterator可以在遍历过程中添加、修改、删除集合中的元素。

3. 支持方法不同：ListIterator相对于Iterator多了一些方法，如previous()、hasPrevious()、add()、set()等，用于在遍历过程中向前遍历、添加元素、修改元素等操作。

4. 支持的集合类型不同：Iterator可以遍历任何类型的集合，包括List、Set、Map等，而ListIterator只能遍历List类型的集合。

骚戴理解：如果需要遍历List集合并支持元素操作，应该使用ListIterator；如果只需要遍历集合中的元素，可以使用Iterator。

遍历一个 List 有哪些不同的方式？每种方法的实现原理是什么？

遍历一个List集合有以下几种不同的方式：

1. for循环遍历

使用for循环遍历List集合，可以使用下标访问集合中的元素。实现原理是通过循环控制变量遍历List集合，通过下标访问集合中的元素。

List<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");
for (int i = 0; i < list.size(); i++) {
    String element = list.get(i);
    System.out.println(element);
}

讲解原理

for循环遍历List集合的实现原理是通过循环控制变量遍历List集合，通过下标访问集合中的元素。

for循环的语法格式如下：

for (初始化表达式; 布尔表达式; 更新表达式) {
    // 循环体
}

其中，初始化表达式用于初始化循环控制变量，布尔表达式用于判断循环是否继续执行，更新表达式用于更新循环控制变量的值。

在for循环遍历List集合时，初始化表达式通常是将循环控制变量初始化为0，布尔表达式通常是判断循环控制变量是否小于List集合的长度，更新表达式通常是将循环控制变量加1。循环体中可以通过下标访问List集合中的元素，实现遍历List集合的功能。

2. foreach循环遍历

使用foreach循环遍历List集合，可以直接访问集合中的元素。foreach循环遍历的实现原理是通过遍历List集合中的每个元素，自动获取元素的值并赋给循环变量，然后执行循环体中的语句。

List<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");
for (String element : list) {
    System.out.println(element);
}

讲解原理

具体来说，foreach循环首先会获取List集合的迭代器，然后使用该迭代器遍历集合中的每个元素。在遍历过程中，循环变量会自动获取元素的值，并将其赋给循环变量。然后，执行循环体中的语句，完成对List集合的遍历操作。

与for循环遍历List集合相比，foreach循环遍历List集合的语法更加简洁，不需要显式地使用下标访问集合中的元素，可以直接访问元素变量。因此，foreach循环更加易于理解和使用，是遍历List集合的常用方式之一。

3. 迭代器遍历

使用迭代器遍历List集合，可以遍历任何类型的集合，包括List、Set、Map等。实现原理是通过获取List集合的迭代器，使用hasNext()、next()方法遍历集合中的元素。

List<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    System.out.println(element);
}

4. ListIterator遍历

使用ListIterator遍历List集合，可以向前或向后遍历集合中的元素，并支持元素操作。实现原理是通过获取List集合的ListIterator，使用hasNext()、next()、hasPrevious()、previous()、add()、set()等方法遍历集合中的元素。

List<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");
ListIterator<String> iterator = list.listIterator();
while (iterator.hasNext()) {
    String element = iterator.next();
    System.out.println(element);
}

集合的各种遍历方式的使用场景有哪些？

集合的各种遍历方式适用于各种场景，具体如下：

1. for循环遍历：适用于需要根据元素的下标来访问集合中的元素的场合（例如List集合），例如需要对集合中的元素进行修改或删除操作时。

2. foreach循环遍历：适用于只需要访问集合中的元素，不需要根据元素的下标来访问的场合，例如只需要对集合中的元素进行读取操作时。

3. 迭代器遍历：适用于需要对集合中的元素进行修改或删除操作的场合，因为在使用迭代器遍历集合时，可以通过迭代器的remove()方法删除集合中的元素。

4. Lambda表达式遍历：适用于需要对集合中的元素进行函数式处理的场合，例如对集合中的元素进行过滤、映射、排序等操作时。

集合的各种遍历方式的性能分析？

在遍历集合时，不同的遍历方式具有不同的性能表现，具体的性能排名取决于集合的类型、大小、元素类型等多种因素。以下是一般情况下各种遍历方式的性能排名：

1. for循环遍历：性能最好，因为使用下标访问集合中的元素速度较快。

2. 迭代器遍历：性能次之，因为迭代器可以直接访问集合中的元素，避免了每次都需要计算下标的开销。

3. foreach循环遍历：性能较差，因为使用foreach循环遍历集合时，需要先获取迭代器，然后使用迭代器遍历集合中的元素，相比于直接使用下标访问集合中的元素，速度较慢。

4. Lambda表达式遍历：性能较差，因为Lambda表达式需要编译成函数对象，而且在遍历集合时需要进行函数式处理，相比于直接访问集合中的元素，速度较慢。

5. Stream API遍历：性能最差，因为Stream API需要进行多次操作，例如过滤、映射、排序等，每次操作都需要创建新的对象，相比于直接访问集合中的元素，速度较慢。

需要注意的是，以上性能排名仅供参考，实际性能可能会受到多种因素的影响，例如集合的大小、元素类型、遍历次数等。因此，在实际开发中，需要根据具体情况选择最优的遍历方式。同时，也可以使用性能分析工具来评估不同遍历方式的性能表现。

ArrayList

说一下 ArrayList 的优缺点

优点：

1. 随机访问速度快：ArrayList 底层使用数组实现，可以通过下标直接访问数组中的元素，因此随机访问速度快。

2. 遍历速度较快：ArrayList 支持快速遍历，因为它的底层是一个数组，可以利用 CPU 缓存来提高遍历速度。

3. 可以存储基本数据类型：ArrayList 可以存储基本数据类型和对象类型，而且可以自动装箱和拆箱。

缺点：

1. 插入和删除操作性能较差：由于 ArrayList 底层使用数组实现，因此在插入和删除元素时，需要移动其他元素，导致性能较差。

2. 不支持多线程并发访问：ArrayList 不是线程安全的，如果多个线程同时对 ArrayList 进行修改操作，可能会导致数据不一致或抛出 ConcurrentModificationException 异常。

3. 内存空间浪费：ArrayList 在创建时需要指定初始容量，如果容量不足时需要进行扩容操作，而且扩容时需要重新分配内存空间，可能会导致内存空间浪费。

骚戴理解：ArrayList 适用于随机访问和修改操作较多的场景，但是在插入和删除操作较多的场景下，LinkedList 可能更加适合。同时，在多线程并发访问的场景下，可以使用 Vector 或 CopyOnWriteArrayList 等线程安全的 List 实现。

如何实现数组和 List 之间的转换？

数组转 List：使用 Arrays. asList(array) 进行转换。

List 转数组：使用 List 自带的 toArray() 方法。

// List 转数组
List list = new ArrayList();
list.add("123");
list.add("456");
list.toArray();
// 数组转 List
listString[] array = new String[]{"123","456"};
Arrays.asList(array);

ArrayList 和 LinkedList 的区别是什么？

ArrayList 和 LinkedList 都是 Java 中常用的 List 实现，它们的区别主要体现在以下几个方面：

1. 底层实现方式不同：ArrayList 底层使用数组实现，而 LinkedList 底层使用双向链表实现。

2. 随机访问和遍历性能不同：由于 ArrayList 底层使用数组实现，因此支持快速随机访问和遍历，而且可以利用 CPU 缓存提高访问速度；而 LinkedList 的遍历速度较慢，因为需要从头节点开始遍历每个节点，而且无法利用 CPU 缓存提高访问速度。

3. 插入和删除操作性能不同：由于 ArrayList 底层使用数组实现，因此在插入和删除元素时，需要移动其他元素，导致性能较差；而 LinkedList 的插入和删除操作性能较好，因为只需要修改相邻节点的指针即可。

4. 内存空间占用不同：LinkedList 比 ArrayList 更占内存，因为 LinkedList 的节点除了存储数据，还存储了两个引用，一个指向前一个元素，一个指向后一个元素。而 ArrayList 则是使用数组实现，每个元素只需要存储数据本身就可以了，因此相对来说占用的内存空间较小。LinkedList 的每个节点都需要额外存储两个指针，因此在存储大量元素时，可能会导致内存占用较大。而 ArrayList 在创建时需要指定初始容量，如果容量不足时需要进行扩容操作，而且扩容时需要重新分配内存空间，可能会导致内存空间浪费。

骚戴理解：ArrayList 适用于随机访问和修改操作较多的场景，但是在插入和删除操作较多的场景下，LinkedList 可能更加适合。

双向链表

双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。

ArrayList 和 Vector 的区别是什么？

这两个类都实现了 List 接口（List 接口继承了 Collection 接口），他们都是有序集合

1、线程安全：Vector 使用了 Synchronized 来实现线程同步，是线程安全的，而 ArrayList 是非线程安全的。

2、性能：ArrayList 在性能方面要优于 Vector。Vector类的所有方法都是同步的。可以由两个线程安全地访问一个Vector对象、但是一个线程访问Vector的话代码要在同步操作上耗费大量的时间。

3、扩容：当 ArrayList 需要扩容时，它会创建一个新的数组，并将原数组中的元素复制到新数组中，新数组的大小是原数组的 1.5 倍。而 Vector 扩容时会创建一个新的数组，并将原数组中的元素复制到新数组中，新数组的大小是原数组的 2 倍。因此，Vector 的扩容比 ArrayList 更加消耗内存，但是相对来说 Vector 的性能更稳定，因为它的扩容次数相对较少。

骚戴理解：Vector 是线程安全的，而 ArrayList 不是线程安全的，如果需要在多线程环境中使用 ArrayList，需要进行同步处理。