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);
        }
    }