一、初始容量(ArrayList)
- ArrayList每次新增一个元素,就会检测ArrayList的当前容量是否已经到达临界点,如果到达临界点则会扩容1.5倍
- ArrayList的扩容是通过申请新的空间,拷贝原来数组生成新的数组,这个过程相当耗费资源
- 若事先已知集合的使用场景和集合的大概范围,最好是指定初始化容量,这样对资源的利用会更加好。尤其是大数据量的前提下,效率的提升和资源的利用会显得更加具有优势
- Collection的初始容量异常重要,所以:对于已知的情景,请为集合指定初始容量
例1(list1未指定初始容量,list2指定初始容量,list2的运行速度是list1的2倍)
public static void main(String[] args) {
StudentVO student = null;
long begin1 = System.currentTimeMillis();
List<StudentVO> list1 = new ArrayList<>();
for(int i = 0 ; i < 1000000; i++){
student = new StudentVO(i,"chenssy_"+i,i);
list1.add(student);
}
long end1 = System.currentTimeMillis();
System.out.println("list1 time:" + (end1 - begin1));
long begin2 = System.currentTimeMillis();
List<StudentVO> list2 = new ArrayList<>(1000000);
for(int i = 0 ; i < 1000000; i++){
student = new StudentVO(i,"chenssy_"+i,i);
list2.add(student);
}
long end2 = System.currentTimeMillis();
System.out.println("list2 time:" + (end2 - begin2));
}
list1 time:1638
list2 time:921
Arraylist的add():
public boolean add(E e) {
ensureCapacity(size + 1);
elementData[size++] = e;
return true;
}
public void ensureCapacity(int minCapacity) {
modCount++; //修改计数器
int oldCapacity = elementData.length;
//当前需要的长度超过了数组长度,进行扩容处理
if (minCapacity > oldCapacity) {
Object oldData[] = elementData;
//新的容量 = 旧容量 * 1.5 + 1
int newCapacity = (oldCapacity * 3)/2 + 1;
if (newCapacity < minCapacity)
newCapacity = minCapacity;
//数组拷贝,生成新的数组
elementData = Arrays.copyOf(elementData, newCapacity);
}
}
二、asList
1.避免使用基本数据类型数组转换为列表
例2(基本类型数组用asList转换为列表):
程序的运行结果并没有像我们预期的那样是5而是1
public static void main(String[] args) {
int[] ints = {1,2,3,4,5};
List list = Arrays.asList(ints);
System.out.println("list'size:" + list.size());
}
//outPut:
//list'size:1
asList源码:
- asList接受的参数是一个泛型的变长参数,基本数据类型是无法泛型化
- 8个基本类型是无法作为asList的参数的, 要想作为泛型参数就必须使用其所对应的包装类型
public static <T> List<T> asList(T... a) {
return new ArrayList<>(a);
}
但是例2并没有出错的原因:
因为该实例是将int类型的数组当做其参数,而在Java中数组是一个对象,它是可以泛型化的。所以该例子是不会产生错误的。既然例子是将整个int类型的数组当做泛型参数,那么经过asList转换就只有一个int 的列表了,如下:
public static void main(String[] args) {
int[] ints = {1,2,3,4,5};
List list = Arrays.asList(ints);
System.out.println("list 的类型:" + list.get(0).getClass());
System.out.println("list.get(0) == ints:" + list.get(0).equals(ints));
}
//outPut: list 的类型:class [I list.get(0) == ints:true
从上述运行结果可以充分证明list里面的元素就是int数组
修改例2(int变为Ineteger):
public static void main(String[] args) {
Integer[] ints = {1,2,3,4,5};
List list = Arrays.asList(ints);
System.out.println("list'size:" + list.size());
System.out.println("list.get(0) 的类型:" + list.get(0).getClass());
System.out.println("list.get(0) == ints[0]:" + list.get(0).equals(ints[0]));
}
----------------------------------------
//outPut:
//list'size:5
//list.get(0) 的类型:class java.lang.Integer
//list.get(0) == ints[0]:true
2.asList产生的列表不可操作
例3(ints通过asList转换为list 类别,然后再通过add方法加一个元素):
运行结果抛出UnsupportedOperationException异常,该异常表示list不支持add方法(java.util.ArrayList中基本的add方法)
public static void main(String[] args) {
Integer[] ints = {1,2,3,4,5};
List list = Arrays.asList(ints);
list.add(6);
}
//output:
Exception in thread "main" java.lang.UnsupportedOperationException
at java.util.AbstractList.add(Unknown Source)
at java.util.AbstractList.add(Unknown Source)
at com.chenssy.test.arrayList.AsListTest.main(AsListTest.java:10)
asList源码:
- asList接受参数后,直接new 一个ArrayList
- 此ArrayList不是java.util.ArrayList,他是Arrays的内部类
//asList接受参数后,直接new 一个ArrayList
public static <T> List<T> asList(T... a) {
return new ArrayList<>(a);
}
//此ArrayList不是java.util.ArrayList,他是Arrays的内部类
private static class ArrayList<E> extends AbstractList<E>
implements RandomAccess, java.io.Serializable{
private static final long serialVersionUID = -2764017481108945198L;
private final E[] a;
ArrayList(E[] array) {
if (array==null)
throw new NullPointerException();
a = array;
}
//.................
}
- Arrays的内部类提供了size、toArray、get、set、indexOf、contains方法,而像add、remove等改变list结果的方法从AbstractList父类继承过来,同时这些方法也比较奇葩,它直接抛出UnsupportedOperationException异常
public boolean add(E e) {
add(size(), e);
return true;
}
public E set(int index, E element) {
throw new UnsupportedOperationException();
}
public void add(int index, E element) {
throw new UnsupportedOperationException();
}
public E remove(int index) {
throw new UnsupportedOperationException();
}
通过上述代码可以看出asList返回的列表只不过是一个披着list的外衣,它并没有list的基本特性(变长)。
该list是一个长度不可变的列表,传入参数的数组有多长,其返回的列表就只能是多长。所以:不要试图改变asList返回的列表
三、SubList的缺陷
除了SubString方法可以用来对String对象进行分割处理外,也可以使用SubList、SubMap、SubSet来对List、Map、Set进行分割处理
1.subList返回仅仅只是一个视图
例4(通过构造函数、subList重新生成一个与list1一样的list,然后list3通过add新增了一个元素,最后比较list1 == list2?、list1 == list3?):
public static void main(String[] args) {
List list1 = new ArrayList(); list1.add(1); list1.add(2);
//通过构造函数新建一个包含list1的列表 list2
List<Integer> list2 = new ArrayList<Integer>(list1);
//通过subList生成一个与list1一样的列表 list3
List<Integer> list3 = list1.subList(0, list1.size());
//修改list3
list3.add(3);
System.out.println("list1 == list2:" + list1.equals(list2));
System.out.println("list1 == list3:" + list1.equals(list3));
}
正常来说,output应该为:
list1 == list2:true
list1 == list3: false实际output:
list1 == list2:false
list1 == list3:true
SubList源码:
- SubList是ArrayList的内部类,它与ArrayList一样,都是继承AbstractList和实现RandomAccess接口。同时也提供了get、set、add、remove等list常用的方法
- subListRangeCheck方式是判断fromIndex、toIndex是否合法,如果合法就直接返回一个subList对象
- 在产生该new该对象的时候传递了一个参数 this ,该参数非常重要,因为他代表着原始list
public List<E> subList(int fromIndex, int toIndex) {
subListRangeCheck(fromIndex, toIndex, size);
return new SubList(this, 0, fromIndex, toIndex);
}
//构造函数
SubList(AbstractList<E> parent,
int offset, int fromIndex, int toIndex) {
this.parent = parent;
this.parentOffset = fromIndex;
this.offset = offset + fromIndex;
this.size = toIndex - fromIndex;
this.modCount = ArrayList.this.modCount;
}
//set方法
public E set(int index, E e) {
rangeCheck(index);
checkForComodification();
E oldValue = ArrayList.this.elementData(offset + index);
ArrayList.this.elementData[offset + index] = e;
return oldValue;
}
//get方法
public E get(int index) {
rangeCheck(index);
checkForComodification();
return ArrayList.this.elementData(offset + index);
}
//add方法
public void add(int index, E e) {
rangeCheckForAdd(index);
checkForComodification();
parent.add(parentOffset + index, e);
this.modCount = parent.modCount;
this.size++;
}
//remove方法
public E remove(int index) {
rangeCheck(index);
checkForComodification();
E result = parent.remove(parentOffset + index);
this.modCount = parent.modCount;
this.size--;
return result;
}
}
SubList构造函数中需要注意的地方:
- this.parent = parent;而parent就是在前面传递过来的list,也就是说this.parent就是原始list的引用
- this.offset = offset + fromIndex;this.parentOffset = fromIndex; 同时在构造函数中它甚至将modCount(fail-fast机制)传递过来了
- SubList的get方法:
- return ArrayList.this.elementData(offset + index):这段代码可以清晰表明get所返回就是原列表offset + index位置的元素
- SubList的add方法:
- parent.add(parentOffset + index, e); this.modCount = parent.modCount;
- SubList的remove方法:
- result = parent.remove(parentOffset + index); this.modCount = parent.modCount;
- SubList的get方法:
从上述get、add和remove方法可知:
SubList同样也是AbstractList的子类,同时它的方法如get、set、add、remove等都是在原列表上面做操作,它并没有像subString一样生成一个新的对象
故:
- subList返回的只是原列表的一个视图,它所有的操作最终都会作用在原列表上!!!
例2输出结果与预想不一样的原因:
- list1中首先包含1和2
- 其次通过 List<Integer> list2 = new ArrayList<Integer>(list1); 创造的list2包含1和2
- List<Integer> list3 = list1.subList(0, list1.size());包含1和2
- list3通过add方法增加元素3时,其首先会对list1(即原列表进行操作)增加元素3,然后再将元素3添加到list3中
- 最后输出:list1 == list2:false; list1 == list3:true
2.subList生成子列表后,不要试图去操作原列表
例5
public static void main(String[] args) {
List list1 = new ArrayList();
list1.add(1);
list1.add(2);
//通过subList生成一个与list1一样的列表 list3
List<Integer> list3 = list1.subList(0, list1.size());
//修改list1
list1.add(3);
System.out.println("list1'size:" + list1.size());
System.out.println("list3'size:" + list3.size());
}
//预想输出:
//list1'size:3
//实际输出:
//list1'size:3
Exception in thread "main" java.util.ConcurrentModificationException
at java.util.ArrayList$SubList.checkForComodification(Unknown Source)
at java.util.ArrayList$SubList.size(Unknown Source)
at com.chenssy.test.arrayList.SubListTest.main(SubListTest.java:17)
list1正常输出,但是list3就抛出ConcurrentModificationException异常(即fail-fast机制)
list.size方法:
- 首先通过checkForComodification验证,然后再返回this.size
- 在checkForComodification验证会验证modCount与this.modCount是否相等,不相等则抛出ConcurrentModificationException
public int size() {
checkForComodification();
return this.size;
}
private void checkForComodification() {
if (ArrayList.this.modCount != this.modCount)
throw new ConcurrentModificationException();
}
modCount 在new的过程中 "继承"了原列表modCount,只有在修改该列表(子列表)时才会修改该值(先表现在原列表后作用于子列表)
而在例5中我们是操作原列表,原列表的modCount当然不会反应在子列表的modCount上啦,所以才会抛出该异常。
对于子列表视图,它是动态生成的,生成之后就不要操作原列表了,否则必然都导致视图的不稳定而抛出异常。最好的办法就是将原列表设置为只读状态,要操作就操作子列表:
//通过subList生成一个与list1一样的列表 list3
List<Integer> list3 = list1.subList(0, list1.size());
3.推荐使用subList处理局部列表
在开发过程中我们一定会遇到这样一个问题:获取一堆数据后,需要删除某段数据。例如,有一个列表存在1000条记录,我们需要删除100-200位置处的数据,可能我们会这样处理:
for(int i = 0 ; i < list1.size() ; i++){
if(i >= 100 && i <= 200){
list1.remove(i);
/*
* 当然这段代码存在问题,list remove之后后面的元素会填充上来,
* 所以需要对i进行简单的处理,当然这个不是这里讨论的问题。
*/
}
}
这个应该是我们大部分人的处理方式吧,其实还有更好的方法,利用subList。subList中子列表的操作都会反映在原列表上。所以下面一行代码全部搞定:
list1.subList(100, 200).clear();
四、保持compareTo和equals同步
在Java中我们常使用Comparable接口来实现排序,其中compareTo是实现该接口方法。我们知道compareTo返回0表示两个对象相等,返回正数表示大于,返回负数表示小于。同时我们也知道equals也可以判断两个对象是否相等
public class Student implements Comparable<Student>{
private String id;
private String name;
private int age;
public Student(String id,String name,int age){
this.id = id;
this.name = name;
this.age = age;
}
public boolean equals(Object obj){
if(obj == null){
return false;
}
if(this == obj){
return true;
}
if(obj.getClass() != this.getClass()){
return false;
}
Student student = (Student)obj;
if(!student.getName().equals(getName())){
return false;
}
return true;
}
public int compareTo(Student student) {
return this.age - student.age;
}
/** 省略getter、setter方法 */
}
Student类实现Comparable接口和实现equals方法,其中compareTo是根据age来比对的,equals是根据name来比对的
public static void main(String[] args){
List<Student> list = new ArrayList<>();
list.add(new Student("1", "chenssy1", 24));
list.add(new Student("2", "chenssy1", 26));
Collections.sort(list); //排序
Student student = new Student("2", "chenssy1", 26);
//检索student在list中的位置
int index1 = list.indexOf(student);
int index2 = Collections.binarySearch(list, student);
System.out.println("index1 = " + index1);
System.out.println("index2 = " + index2);
}
按照常规思路来说应该两者index是一致的,因为他们检索的是同一个对象,但是非常遗憾,其运行结果:
index1 = 0 index2 = 1
为什么会产生这样不同的结果呢?
因为indexOf和binarySearch的实现机制不同:
- indexOf是基于equals来实现的只要equals返回TRUE就认为已经找到了相同的元素
- binarySearch是基于compareTo方法的,当compareTo返回0 时就认为已经找到了该元素
在我们实现的Student类中我们覆写了compareTo和equals方法,但是我们的compareTo、equals的比较依据不同,一个是基于age、一个是基于name
比较依据不同那么得到的结果很有可能会不同。所以知道了原因,我们就好修改了:将两者之间的比较依据保持一致即可
对于compareTo和equals两个方法我们可以总结为:
- 使其相等的方式就是两者应该依附于相同的条件。当compareto相等时equals也应该相等,而compareto不相等时equals不应该相等,并且compareto依据某些属性来决定排序
参考文章:
Java-Tutorial/Java集合详解8:Java集合类细节精讲.md at master · h2pl/Java-Tutorial · GitHub