Java基础-集合框架-Collection-List-ArrayList API及常用方法

ArrayList

ArrayList API

Modifier and Type	Method	Description
boolean	add(E e)	将指定元素添加到此列表的队尾
void	add(int index, E element)	将指定元素添加到此列表的指定位置。
boolean	addAll(Collection<? extends E> c)	以Iterator返回指定集合的元素并一次追加到此列表的末尾。
boolean	addAll(int index, Collection<? extends E> c)	以Iterator返回指定集合的元素并一次追加到此列表，从指定index位置开始。
void	clear()	从列表中删除所有元素。
Object	clone()	返回此ArrayList实例的浅拷贝对象。
boolean	contains(Object o)	如果此列表包含指定的元素，则返回 true 。
void	ensureCapacity(int minCapacity)	如果需要，增加此 ArrayList实例的容量，以确保它可以至少保存最小容量参数指定的元素数。
void	forEach(Consumer<? super E> action)	对 Iterable的每个元素执行给定的操作，直到所有元素都被处理或因动作引发异常。
E	get(int index)	返回此列表中指定位置的元素。
int	indexOf(Object o)	返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
boolean	isEmpty()	如果此列表不包含元素，则返回 true 。
Iterator	iterator()	以正确的顺序返回该列表中的元素的迭代器。
int	lastIndexOf(Object o)	返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
ListIterator	listIterator()	返回列表中的列表迭代器（按适当的顺序）。
ListIterator	listIterator(int index)	从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。
E	remove(int index)	删除该列表中指定位置的元素。
boolean	remove(Object o)	从列表中删除指定元素的第一个出现（如果存在）。
boolean	removeAll(Collection<?> c)	从此列表中删除指定集合中包含的所有元素。
boolean	removeIf(Predicate<? super E> filter)	删除满足给定谓词的此集合的所有元素。
void	replaceAll(UnaryOperator operator)	将该列表的每个元素替换为将该运算符应用于该元素的结果。
boolean	retainAll(Collection<?> c)	仅保留此列表中包含在指定集合中的元素。
E	set(int index, E element)	用指定的元素替换此列表中指定位置的元素。
int	size()	返回此列表中的元素数。
void	sort(Comparator<? super E> c)	使用提供的 Comparator对此列表进行排序以比较元素。
Spliterator	spliterator()	在此列表中的元素上创建late-binding和故障快速 Spliterator 。
List	subList(int fromIndex, int toIndex)	返回此列表中指定的 fromIndex （包括）和 toIndex之间的独占视图。
Object[]	toArray()	以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组。
T[]	toArray(T[] a)	以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）; 返回的数组的运行时类型是指定数组的运行时类型。
void	trimToSize()	修改这个 ArrayList实例的容量是列表的当前大小。

sample code

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Iterator;
import java.util.ListIterator;

public class ArrayListDemo {

	@SuppressWarnings("unchecked")
	public static void main(String[] args) {

		ArrayList<String> list1 = new ArrayList<String>();

		/**
		 * @param E e 元素
		 * 
		 * @return Boolean 是否成功添加元素
		 * 
		 * @description 向列表中添加元素
		 */
		list1.add("A");
		list1.add("B");
		list1.add("C");

		// [A,B,C]
		System.out.println(list1);

		/**
		 * @param E e 元素
		 * 
		 * @param int index 索引位置
		 * 
		 * @return void 
		 * 
		 * @description 向列表中指定位置添加元素
		 */
		list1.add(0, "D");

		// [D, A, B, C]
		System.out.println(list1);

		ArrayList<String> list2 = new ArrayList<String>();
		list2.add("E");
		list2.add("F");
		list2.add("G");

		/**
		 * @param Collection<? extends E> c 列表
		 * 
		 * @return Boolean 是否成功添加元素
		 * 
		 * @description 向列表队尾依次添加另一个列表的所有元素
		 */
		list1.addAll(list2);

		// [D, A, B, C, E, F, G]
		System.out.println(list1);

		ArrayList<String> list3 = new ArrayList<String>();
		list3.add("H");
		list3.add("I");
		list3.add("J");

		/**
		 * @param Collection<? extends E> c 列表
		 * 
		 * @param int index 索引位置
		 * 
		 * @return Boolean 是否成功添加元素
		 * 
		 * @description 向列表指定位置依次添加另一个列表的所有元素
		 */
		list1.addAll(1, list3);

		// [D, H, I, J, A, B, C, E, F, G]
		System.out.println(list1);

		/**
		 * @description 删除列表中所有元素
		 */
		list2.clear();

		/**
		 * @return Object
		 * 
		 * @description 返回该列表的浅拷贝对象
		 */
		ArrayList<String> list4 = (ArrayList<String>)list1.clone();
		System.out.println(list4);

		/**
		 * @return boolean
		 * 
		 * @description 判断该集合是否包含指定元素
		 */
		// true
		System.out.println(list1.contains("A"));

		/**
		 * @since JDK 1.8
		 * 
		 * @description 遍历该列表的所有元素
		 */
		list1.forEach(
				x -> System.out.println(x)
				);

		/**
		 * @description 返回列表指定位置的元素
		 */
		// H
		System.out.println(list1.get(1));

		/**
		 * @description 返回此元素在列表中第一次出现的位置。若不含有此元素，则返回-1
		 */
		list1.indexOf("B");

		/**
		 * @description 返回此元素在列表中最后一次出现的位置。若不含有此元素，则返回-1
		 */
		list1.lastIndexOf("B");

		/**
		 * @description 此列表不包含元素时返回true
		 */
		list1.isEmpty();

		/**
		 * @description 返回该列表的迭代器对象
		 * 
		 * @缺点： 只能单向移动
		 */
		Iterator<String> it = list1.iterator();
		while(it.hasNext()) {
			it.next();
			// 在遍历列表时删除元素唯一安全的方式。
			// 每调用一次next，只能调用一次remove
			it.remove();
		}

		/**
		 * @param int listIterator(int index) 可在创建时直接定义迭代器当前位置
		 * 
		 * @description iterator的升级版
		 * 
		 * 可以双向移动
		 */
		ListIterator<String> listIt = list1.listIterator();
		while(listIt.hasNext()) {
			System.out.println(listIt.next() + ", " + listIt.previousIndex() + ", " + listIt.nextIndex());
		}
		while(listIt.hasPrevious()) {
			System.out.print(listIt.previous() + " ");
		}


		/**
		 * @return boolean
		 * 
		 * @description 移除此列表中指定位置的元素
		 */
		list1.remove(0);

		/**
		 * @return boolean
		 * 
		 * @description 移除此列表中指定元素
		 */
		list1.remove("A");

		/**
		 * @return boolean
		 * 
		 * @description 移除此列表中指定列表包含的所有元素
		 */
		list1.removeAll(list2);

		/**
		 * @since JDK 1.8
		 * 
		 * @description 移除指定符合条件的元素
		 */
		list1.removeIf(
				x -> x.equals("A")
				);		

		/**
		 * @since JDK 1.8
		 * 
		 * @description 替换列表中的指定元素
		 */
		list1.replaceAll(
				str -> {
					if(str.equals("A")) {
						return "a";
					}else {
						return "B";
					}
				}
				);

		/**
		 * @description 仅保留与参数列表中共同存在的元素
		 */
		list1.retainAll(list2);

		/**
		 * @description 替换指定位置的元素
		 */
		list1.set(0, "B");

		/**
		 * @description 返回列表中包含元素的个数
		 */
		System.out.println(list1.size());

		/**
		 *  列表增加元素数量较大时，每次通过列表自动扩容性能较低，直接使用此方法扩容至指定大小
		 * 
		 * @description 将列表扩容至指定容量
		 */
		list1.ensureCapacity(100000);

		/**
		 * @return Object[]
		 * 
		 * @description 按顺序返回一个包含此列表中所有元素的数组。
		 */
		Object[] objAry = list1.toArray();


		/**
		 * @return T[]
		 * 
		 * @description 按顺序返回一个包含此列表中所有元素的数组。
		 */
		String[] StrAry = new String[]{};
		StrAry = list1.toArray(StrAry);

		/**
		 * @description 去除列表中没有使用的容量
		 */
		list1.trimToSize();

		list1.sort(new SortByAge());
		
		/**
		 * @since JDK1.8
		 * 
		 * @description Spliterator就是为了并行遍历元素而设计的一个迭代器，jdk1.8中的集合框架中的数据结构都默认实现了spliterator
		 */
		list1.spliterator();

	}

}


@SuppressWarnings("rawtypes")
class SortByAge implements Comparator {
	public int compare(Object o1, Object o2) {
		Student s1 = (Student) o1;
		Student s2 = (Student) o2;
		if (s1.getAge() > s2.getAge())
			return 1;
		return -1;
	}
}

class Student{

	private String name;

	private Integer age;

	/**  
	 * @return: String name
	 */
	public String getName() {
		return name;
	}

	/**  
	 * @param name set String name
	 */
	public void setName(String name) {
		this.name = name;
	}

	/**  
	 * @return: Integer age
	 */
	public Integer getAge() {
		return age;
	}

	/**  
	 * @param age set Integer age
	 */
	public void setAge(Integer age) {
		this.age = age;
	}

}