JavaApi学习---ArrayList类
ArrayList类常用方法
继承体系结构图
构造方法
public ArrayList() //默认Capacity=10 public ArrayList(int initialCapacity) //提供初始容量 提供的范围在0~Integer.MAX_VALUE = 2147483647 之间 public ArrayList(Collection<? extends E> c) //提供一个集合 ArrayList<Integer> arr1 = new ArrayList<>(); ArrayList<Integer> arr2 = new ArrayList<>(20); List<Integer> list = new ArrayList<>(); ArrayList<Integer> arr3 = new ArrayList<>(list); 扩容：每次扩容为原容量的1.5倍
add()添加一个元素
//在最后添加一个元素 public boolean add(E e) { ensureCapacityInternal(size + 1); //每次添加前会判断是否需要扩容 elementData[size++] = e; return true; } //在指定位置添加元素 public void add(int index, E element) { //检查index是否超过数组的长度 rangeCheckForAdd(index); ensureCapacityInternal(size + 1); //将数组从index位置往后移动 System.arraycopy(elementData, index, elementData, index + 1, size - index); elementData[index] = element; size++; } addAll()添加集合中的全部元素
public boolean addAll(Collection<? extends E> c) //在方法里面调用循环调用add(e)方法 public boolean addAll(int index, Collection<? extends E> c) //在方法里面调用循环调用add(index，e)方法 get(int index)返回index位置的元素
//index需要在list.size()之间否则就会报：IndexOutOfBoundsException System.out.println(arr1.get(2)); //3 System.out.println(arr1.get(5)); //IndexOutOfBoundsException clear()清除所有元素
ArrayList<Integer> arr1 = new ArrayList<>(); arr1.add(1); System.out.println(arr1.toString()); // [1] arr1.clear(); System.out.println(arr1.toString()); //[] clone()返回数组的克隆对象（浅克隆）
ArrayList<Integer> arr1 = new ArrayList<>(); arr1.addAll(Arrays.asList(1, 2, 3, 4)); ArrayList<Integer> arrayList = (ArrayList<Integer>) arr1.clone(); System.out.println(arr1); //[1, 2, 3, 4] System.out.println(arrayList); //[1, 2, 3, 4] contains(e) 集合是否包含此元素，包含返回true，否则返回False
ArrayList<Integer> arr1 = new ArrayList<>(); arr1.addAll(Arrays.asList(1, 2, 3, 4)); System.out.println(arr1.contains(1)); //true ensureCapacity(int minCapacity)改变该集合的容量大小
forEach(Consumer<? super E> action) 对集合中的元素进行遍历，可以对每个元素进行操作
//对集合中每个元素扩大10倍后输出 arr1.forEach(i ->{ System.out.printf(%d、, i * 10); //10、20、30、40、 }); indexOf(object o)
//返回元素第一出现的下标，如果该元素不在集合中就会返回-1 public int indexOf(Object o) { if (o == null) { for (int i = 0; i < size; i++) //从前往后找 if (elementData[i]==null) return i; } else { for (int i = 0; i < size; i++) if (o.equals(elementData[i])) //对象需要重写equals方法 return i; } return -1; } //Person类没有重写equals方法时， ArrayList<Person> peoples = new ArrayList<>(); peoples.add(new Person(张三,18)); peoples.add(new Person(李四,19)); peoples.add(new Person(王五,20)); System.out.println(peoples.indexOf(new Person(张三, 18))); // -1 //Person类重写equals方法后。 System.out.println(peoples.indexOf(new Person(张三, 18))); // 0 //Person类 public class Person { private String name; private Integer age; public Person(){} public Person(String name, Integer age){ this.name=name; this.age = age; } public void say(){ System.out.println(I can talk); } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Person person = (Person) o; return Objects.equals(name, person.name) && Objects.equals(age, person.age); } @Override public int hashCode() { return Objects.hash(name, age); } } lastIndexOf(Object o)
//返回元素最后一次出现的下标，如果该元素不在集合中就会返回-1 //与indexOf相反， public int lastIndexOf(Object o) { if (o == null) { for (int i = size-1; i >= 0; i--) //从后往前找 if (elementData[i]==null) return i; } else { for (int i = size-1; i >= 0; i--) if (o.equals(elementData[i])) return i; } return -1; } isEmpty()判断集合是否为空
//集合中没有元素就返回true否则返回false public boolean isEmpty() { return size == 0; } iterator()获取集合的迭代器
Iterator<Person> iterator = peoples.iterator(); while (iterator.hasNext()){ Person person = iterator.next(); System.out.println(person.toString()); } // Person{name='张三', age=18} // Person{name='李四', age=19} // Person{name='王五', age=20} listIterator()
//listIterator() 默认是从下标0开始的 public ListIterator<E> listIterator() { return new ListItr(0); } //listIterator(int index) 可以指定下标 public ListIterator<E> listIterator(int index) { if (index < 0 || index > size) //指定的范围必须在0~~size之间 throw new IndexOutOfBoundsException(Index: +index); return new ListItr(index); } ListIterator<Person> iterator = peoples.listIterator(3); while (iterator.hasPrevious()){ //从后往前迭代 Person person = iterator.previous(); System.out.println(person.toString()); } iterator()和listIterator()的区别
iterator: 不仅可以对list进行迭代，还可以对set进行迭代 只能单向的迭代，从前往后 listIterator： 只能对list进行迭代。 可以双向迭代，既可从前往后，也可从后往前进行迭代 remove(int index)移除集合指定位置的元素,并返回index位置的元素
//如果移除的不是最后一个元素，将会造成集合的拷贝，（所以删除性能也是挺慢的） //remove(int index) public E remove(int index) { rangeCheck(index); modCount++; E oldValue = elementData(index); int numMoved = size - index - 1; if (numMoved > 0) //如果不是最后一个元素，将会带来数据的拷贝 System.arraycopy(elementData, index+1, elementData, index, numMoved); elementData[--size] = null; return oldValue; } // remove(Object o)移除第一次出现的元素 public boolean remove(Object o) { if (o == null) { //即使传进来一个null值，只要集合中存在null值，也会被删除 for (int index = 0; index < size; index++) //因为从前往后遍历，将会删除第一出现的元素 if (elementData[index] == null) { fastRemove(index); return true; } } else { for (int index = 0; index < size; index++) if (o.equals(elementData[index])) { fastRemove(index); return true; } } return false; } removeAll(Collection<?> c)
//移除和集合c中相同的元素 public boolean removeAll(Collection<?> c) { Objects.requireNonNull(c); // 判断集合c 是否为null return batchRemove(c, false); } //主要是下面的移除方法 private boolean batchRemove(Collection<?> c, boolean complement) { final Object[] elementData = this.elementData; int r = 0, w = 0; boolean modified = false; try { for (; r < size; r++) if (c.contains(elementData[r]) == complement) // 如果集合c中不存源集合的元素， elementData[w++] = elementData[r]; //就将这个元素放到源集合中,从前往后放 } finally { // Preserve behavioral compatibility with AbstractCollection, 兼容AbstractCollection // even if c.contains() throws. // 就算 c.contains()抛出异常，导致没有遍历完 if (r != size) { // 如果没有遍历完，就将r后面的元素全部复制到源集合中，从w的位置 System.arraycopy(elementData, r, elementData, w, size - r); w += size - r; } if (w != size) { // 如果w不等于size 说明有源集合中有c集合相同的元素，就把w后面的元素全部删除，也就实现了功能 // clear to let GC do its work for (int i = w; i < size; i++) elementData[i] = null; modCount += size - w; size = w; modified = true; } } return modified; } removeIf(Predicate<? super E> filter)
//从集合中移除符合条件的元素 //传个断言型的参数 public boolean removeIf(Predicate<? super E> filter) { .... for (int i=0; modCount == expectedModCount && i < size; i++) { @SuppressWarnings(unchecked) final E element = (E) elementData[i]; if (filter.test(element)) { //处理符合条件的元素 removeSet.set(i); //将符合条件的元素放到处理的set中 removeCount++; } } ... //将要移除的元素在这里移除 if (anyToRemove) { final int newSize = size - removeCount; for (int i=0, j=0; (i < size) && (j < newSize); i++, j++) { i = removeSet.nextClearBit(i); elementData[j] = elementData[i]; } for (int k=newSize; k < size; k++) { elementData[k] = null; // Let gc do its work } this.size = newSize; if (modCount != expectedModCount) { throw new ConcurrentModificationException(); } modCount++; } return anyToRemove; } //移除年龄小于20岁的 peoples.removeIf(p -> p.getAge() < 20); System.out.println(peoples.toString()); //[Person{name='王五', age=20}] removeRange(int fromIndex, int toIndex)
//移除指定范围之间的元素 protected void removeRange(int fromIndex, int toIndex) { modCount++; int numMoved = size - toIndex; System.arraycopy(elementData, toIndex, elementData, fromIndex, numMoved); // clear to let GC do its work int newSize = size - (toIndex-fromIndex); for (int i = newSize; i < size; i++) { elementData[i] = null; } size = newSize; } replaceAll(UnaryOperator operator)
//将集合中的元素，通过operator的操作后，将经过加工的元素替换原来的元素 peoples.replaceAll(p->张三.equals(p.getName()) ? new Person() : p); System.out.println(peoples); //[Person{name='null', age=null}, Person{name='李四', age=19}, Person{name='王五', age=20}] retainAll(Collection<?> c)
//和removeAll是相对的，保存集合c中相同的元素 public boolean retainAll(Collection<?> c) { Objects.requireNonNull(c); return batchRemove(c, true); } set(int index, E element)
//将index位置的元素用传进来的替换，并返回原元素 public E set(int index, E element) { rangeCheck(index); E oldValue = elementData(index); elementData[index] = element; return oldValue; } size()返回集合中的个数
sort(Comparator<? super E> c)
//用一定的规则将集合中的元素进行排序 peoples.sort(new Comparator<Person>() { @Override public int compare(Person o1, Person o2) { return o1.getAge()- o2.getAge(); } }); System.out.println(peoples); //[Person{name='张三', age=18}, Person{name='李四', age=19}, Person{name='王五', age=20}] subList(int fromIndex, int toIndex)
//返回源集合中fromIndex--toIndex之间的所有元素 toArray()
//源集合转为数组形式 public Object[] toArray() { return Arrays.copyOf(elementData, size); } Person[] persons = (Person[]) peoples.toArray(); //重构方法，将源集合，转化为 a类型的数组 public <T> T[] toArray(T[] a) { if (a.length < size) // Make a new array of a's runtime type, but my contents: return (T[]) Arrays.copyOf(elementData, size, a.getClass()); System.arraycopy(elementData, 0, a, 0, size); if (a.length > size) a[size] = null; return a; } trimToSize()
//将集合容量缩小为当前集合的实际容量，如果size为0，那还是默认的容量。 public void trimToSize() { modCount++; if (size < elementData.length) { elementData = (size == 0) ? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size); } }