java集合list

一、List与Set的区别

List与Set同为继承Collection的子接口，他们之间的区别就是：

List：有序，可重复

Set：无序，不可重复

这里的无序和有序, 是说的添加顺序和元素顺序的一致性；

比如添加元素的顺数是 a,b,c

List 的存储顺序就是 a,b,c

Set 的存储顺序就不一定了,可能是 c,a,b 什么的了

二、List的实现方法，和他们之间的区别

List有三个实现类，分别是ArrayList、LinkList、Vector

ArrayList：底层数据结构是数组，特点是查询快，增删慢；线程不安全，效率高

Vector：数据结构和ArrayList一样，但是线程安全，效率较低

LinkList：底层数据结构是链表，特点是查询慢，增删快；线程不安全，效率高

三、什么是synchronizedList? 他和Vector有什么区别？

synchronizedList就是java.util.Collections中的一个静态内部类，可以用Collections.synchronizedList(List list)方法来返回一个线程安全的List。

synchronizedList与Vector的区别：

1. SynchronizedList有很好的扩展和兼容功能。他可以将所有的List的子类转成线程安全的类。 
2. 使用SynchronizedList的时候，进行遍历时要手动进行同步处理。
3. SynchronizedList可以指定锁定的对象。

在这里推荐一位大佬写的博客：http://www.hollischuang.com/archives/498

四、通过Array.asList获取List的特点，以及使用时的注意事项

1、示例：

​public class Demo{

    public void method(){
        
        int[] a = new int[]{1,2,3,4,5};
        List lista = Arrays.asList(a);
        
        Integer[] b = new Integer[]{1,2,3,4,5};
        List listb = Arrays.asList(b);
        
        // 运行结果
        System.out.println(lista.size()); // 1
        System.out.println(listb.size()); // 5
    }

}

运行结果lista的大小为1，listb的大小为5；为什么会不同呢？

先让我们来看一下asList的源码：

public static <T> List<T> asList(T... a) {
    return new ArrayList<>(a);
}

从代码中可以发现asList接受的是一个泛型类型的参数，再构造了一个ArrayList。然而基本类型是不支持泛型化的，但是数组支持，所以采用基本类型的数组转化后是将数组放入了构造的ArrayList中，长度是1。

2、asList获取的集合无法使用add()、remove()这一系列方法；

示例：

private static class ArrayList<E> extends AbstractList<E>
        implements RandomAccess, java.io.Serializable

通过查看asList返回的ArrayList这个类可以发现这个类并不是我们熟悉的java.util.ArrayList，而是另一个类；

抽象类AbstractList 定义了一系列比如add()、remove()修改list的方法，然而在这个ArrayList中并没有实现它们，所以返回的ArrayList是不支持修改操作的。

那么如果想要对其进行add或者remove应该怎么做呢？

​​public class Demo{

    public void method(){
        
        Integer[] a = new Integer[]{1,2,3,4,5};
        ArrayList<Integer> arrayList = new ArrayList<>(Arrays.asList(a));

    }

}

将其转化为java.util.ArrayList即可。

五、fail-fast是什么？ fail-safe又是什么？ 他们之间有什么区别？

fail-fast:

fail-fast也就是“快速失败”，它是Java集合的一种错误检测机制。当多个线程对集合进行结构上的改变的操作时，有可能会产生fail-fast机制。记住是有可能，而不是一定。例如：假设存在两个线程（线程1、线程2），线程1通过Iterator在遍历集合A中的元素，在某个时候线程2修改了集合A的结构（是结构上面的修改，而不是简单的修改集合元素的内容），那么这个时候程序就会抛出 ConcurrentModificationException 异常，从而产生fail-fast机制。

这里推荐一个博客https://blog.csdn.net/chenssy/article/details/38151189 想详细了解fail-fast的同学可以看看

fail-safe:

fail-safe也叫安全失败，相对于fail-fast来说fail-safe采用了安全失败机制的集合容器，在遍历时不是直接在集合内容上访问的，而是先复制原有集合内容，在拷贝的集合上进行遍历。

fail-fast与fail-safe的区别：

通过上面对fail-fast与fail-safe的了解，他们的区别也是显而易见的，也就是fail-safe允许在遍历的过程中对容器中的数据进行修改，而fail-fast则不允许。

六、如何在遍历的同时删除ArrayList中的元素

一般而言，遍历List元素有以下三种方式：

• 使用普通for循环遍历
• 使用增强型for循环遍历
• 使用iterator遍历

使用普通for循环遍历

代码如下：

public class Main {
	public static void main(String[] args) throws Exception {
		List<Integer> list = new ArrayList<>();
		for (int i = 0; i < 5; i++)
			list.add(i);
		// list {0, 1, 2, 3, 4}
		for (int i = 0; i < list.size(); i++) {
			// index and number
			System.out.print(i + " " + list.get(i));
			if (list.get(i) % 2 == 0) {
				list.remove(list.get(i));
				System.out.print(" delete");
				i--; // 索引改变!
			}
			System.out.println();
		}
	}
}

结果如下：

 

可以看到遍历删除偶数的结果是成功的，但是这种方法由于删除的时候会改变list的index索引和size大小，可能会在遍历时导致一些访问越界的问题，因此不是特别推荐。

使用增强型for循环遍历

public class Main {
	public static void main(String[] args) throws Exception {
		List<Integer> list = new ArrayList<>();
		for (int i = 0; i < 5; i++)
			list.add(i);
		// list {0, 1, 2, 3, 4}
		for (Integer num : list) {
			// index and number
			System.out.print(num);
			if (num % 2 == 0) {
				list.remove(num);
				System.out.print(" delete");
			}
			System.out.println();
		}
	}
}

结果如下：

 

可以看到删除第一个元素时是没有问题的，但删除后继续执行遍历过程的话就会抛出ConcurrentModificationException的异常。

使用iterator遍历

public class Main {
	public static void main(String[] args) throws Exception {
		List<Integer> list = new ArrayList<>();
		for (int i = 0; i < 5; i++)
			list.add(i);
		// list {0, 1, 2, 3, 4}
		Iterator<Integer> it = list.iterator();
		while (it.hasNext()) {
			// index and number
			int num = it.next();
			System.out.print(num);
			if (num % 2 == 0) {
				it.remove();
				System.out.print(" delete");
			}
			System.out.println();
		}
	}
}

结果如下：

 

可以看到顺利的执行了遍历并删除的操作，因此最推荐的做法是使用iterator执行遍历删除操作。

这里借鉴了一位大佬的博客：https://blog.csdn.net/superxlcr/article/details/51534428