ArrayList集合API方法简单整合

ArrayListL类的API方法简单汇总

JDK版本：11.0.6
这里只是对每种方法的使用做了简单介绍，并非对其深入分析，只求在第一次使用某个方法不会对着API一脸懵逼

1. 内部结构

ArrayList内部结构是对象数组，增加删除慢，查找快

2. 构造方法

ArrayList<E> arrayList = new ArrayList<>();
//E:必须为引用类型，也就是是说如果要传入char，int等类型时必须使用其包装类
//默认创建容量为10的空队列，容量不够的时候会自动扩容，每次扩容后的容量为原来的1.5倍
ArrayList<E> arrayList  = new ArrayList<>(int initialCapacity);
//创建指定容量的ArrayList对象
ArrayList<E> arrayList = new ArrayList<>(Collection<? extends E> c); (<? extends E>规定传入的Collection对象的子类的类型必须为E的子类)
//将传入的Collection对象变为ArrayList对象

3. ArrayList方法汇总

1. add(int index, E element)

 将指定元素插入此列表中的指定位置
 return : void
 
  public static void main(String[] args[]){
  		ArrayList<Integer> arrayListTemp = new ArrayList<>();
		arrayListTemp.add(0,100);
		System.out.print("1.\t");
		System.out.println(arrayListTemp.get(0));
}

2. add(E e)

将指定元素插入到列表末尾
return : boolean (注意，无论插入是否成功都返回的是true)

 public static void main(String[] args){
 		ArrayList<Integer> arrayListTemp = new ArrayList<>();
		arrayListTemp.add(200);
		System.out.print("2.\t");
		System.out.println(arrayListTemp.get(0));
 }

3. addAll(int index, Collection<? extends E> c)

从指定位置开始，将指定集合中的所有元素插入此列表。
return : boolean

public static void main(String[] args){
		ArrayList<Integer> list = new ArrayList<>();
		TreeSet<Integer> set = new TreeSet<>();
		set.add(2);
		set.add(3);
		list.add(1);
		list.addAll(1,set);
		System.out.print("3.\t");
		System.out.print("添加元素：");
		for (Integer i : list){
			System.out.print(i + " ");
		}
		System.out.println();
}

4. addAll(Collection<? extends E> c)

将指定集合中的所有元素按指定集合的Iterator返回的顺序附加到此列表的末尾。
return : boolean

 public static void main(String[] args){
 		ArrayList<Integer> list = new ArrayList<>();
        TreeSet<Integer> set = new TreeSet<>();
        set.add(2);
        set.add(3);
        list.add(1);
        list.addAll(set);
        System.out.print("4.\t");
        System.out.print("添加元素：");
        for (Integer i : list){
        	System.out.print(i + " ");
        }
        System.out.println();
}

5. clear()

public static void main(String[] args){
		ArrayList<Integer> arrayListTemp = new ArrayList<>();
		arrayListTemp.add(100);
		System.out.print("5.\t");
		System.out.print("清理前列表的元素数：" + arrayListTemp.size() + "\t");
		arrayListTemp.clear();
		System.out.println("清理后列表的元素数：" + arrayListTemp.size());
}

6. clone()

//返回此 ArrayList实例的浅表副本。
//return : Object

7. contains(Object o)

如果列表里面有元素o，返回true
return : boolean

public static void main(String[] args){
		ArrayList<Integer> arrayListTemp = new ArrayList<>();
		arrayListTemp.add(100);
		System.out.print("7.\t");
		System.out.println(arrayListTemp.contains(100));
}

8. ensureCapacity(int minCapacity)

将列表元素容量增加到minCapacity，而不是增加minCapacity

public static void main(String[] args){
		ArrayList<Integer> arrayListTemp = new ArrayList<>();
		System.out.print("8.\t");
		//将列表元素容量从10增加到20
		arrayListTemp.ensureCapacity(20);
		System.out.println();
}

9. forEach(Consumer<? super E> action)

对列表中的所有元素都执行action操作

public static void main(String[] args){
	ArrayList<Integer> arrayListTemp = new ArrayList<>();
       for (int i=1;i<=3;i++){
            arrayListTemp.add(i*100);
       }
	System.out.print("9.\t");
    //不使用forEach()操作打印list内容:
    for (Integer i:arrayListTemp){
		System.out.print(i+ " ");
	System.out.print("\t");	
}

10. get(int index)

返回列表指定位置的内容
return : E

public static void main(String[] args){
	ArrayList<Integer> arrayListTemp = new ArrayList<>();
	for (int i=1;i<=3;i++){
		arrayListTemp.add(i*100);
	}
	System.out.print("10.\t");
	System.out.println(arrayListTemp.get(0));
}

11. indexOf(Object o)

返回列表中第一次出现元素o的位置的索引，如果没有，返回-1
return :  int

public static void main(String[] args){
	ArrayList<Integer> arrayListTemp = new ArrayList<>();
	for (int i=1;i<=3;i++){
		arrayListTemp.add(i*100);
	}
	System.out.print("11.\t");
	System.out.println("200在列表中出现的第一个位置的索引：" + arrayListTemp.indexOf(200));
}

12. isEmpty()

如果列表为空，返回true，反之false
return :  boolean

public static void main(String[] args){
	ArrayList<Integer> arrayListTemp = new ArrayList<>();
	for (int i=1;i<=3;i++){
		arrayListTemp.add(i*100);
	}
	System.out.print("12.\t");
	System.out.println("列表是否为空：" + arrayListTemp.isEmpty());
}

13. iterator()

依适当的顺序返回此列表的元素迭代器
return :  Iterator

public static void main(String[] args){
 	ArrayList<String> list = new ArrayList<>();
    for (int i=0;i<5;i++){
		list.add(i+"");
	}
	Iterator<String> iterator = list.iterator();
	System.out.print("16.\t");
	System.out.print("使用迭代器打印队列元素：");
	while(iterator.hasNext()){
		String s = iterator.next();
		System.out.print(s + " ");
	}
	System.out.println();
}

14. lastIndexOf(Object o)

返回列表中最后一次出现元素o的位置的索引，如果没有，返回-1
return :  int

public static void main(String[] args){
	ArrayList<Integer> arrayListTemp = new ArrayList<>();
	for (int i=1;i<=3;i++){
		arrayListTemp.add(i*100);
	}
	System.out.print("14.\t");
	System.out.println("200在列表中出现的第一个位置的索引：" + 	arrayListTemp.lastIndexOf(200));
}

15. listIterator()

依适当的顺序返回此列表的列表迭代器
return :  ListIterator<E>

public static void main(String[] args){
	ArrayList<String> list = new ArrayList<>();
	for (int i=0;i<5;i++){
		list.add(i+"");
	}
	ListIterator<String> iterator = list.listIterator();
	System.out.print("15.\t");
	System.out.print("使用迭代器打印队列元素：");
	while(iterator.hasNext()){
		String s = iterator.next();
		System.out.print(s + " ");
	}
	System.out.println();
}

16. listIterator(int index)

从列表中的指定位置开始，返回列表中元素的列表迭代器（按正确顺序）。
return :  Iterator<E>

public static void main(String[] args){
	ArrayList<String> list = new ArrayList<>();
	for (int i=0;i<5;i++){
		list.add(i+"");
	}
	ListIterator<String> iterator = list.listIterator(1);
	System.out.print("16.\t");
	System.out.print("使用迭代器打印队列元素：");
	while(iterator.hasNext()){
		String s = iterator.next();
		System.out.print(s + " ");
	}
	System.out.println();
}

17. remove(int index)

删除列表指定位置的元素
return : E 返回被删除的元素

public static void main(String[] args){
	ArrayList<Integer> arrayListTemp = new ArrayList<>();
	for (int i=1;i<=3;i++){
		arrayListTemp.add(i*100);
	}
	System.out.print("17.\t");
	System.out.println(arrayListTemp.remove(0));
}

18. remove(Object o)

从列表中删除指定元素的第一个匹配项
return :  boolean

public static void main(String[] args){
	ArrayList<String> arrayListTemp = new ArrayList<>();
	for (int i=1;i<=3;i++){
		arrayListTemp.add(""+i);
}
	System.out.print("18.\t");
	System.out.println(arrayListTemp.remove("1"));
}

19. removeAll(Collection<?> c)

从此列表中删除指定集合中包含的所有元素
return :  boolean

public static void main(String[] args){
	ArrayList<String> arrayListTemp = new ArrayList<>();
	for (int i=1;i<=3;i++){
		arrayListTemp.add(""+i);
	}
	ArrayList<String> arrayListTemp2 = new ArrayList<>();
	for (int i=1;i<=2;i++){
		arrayListTemp2.add(""+i);
	}
	System.out.print("19.\t");
	System.out.print("删除前：");
	printArratList(arrayListTemp);
	System.out.print("删除后：");
	arrayListTemp.removeAll(arrayListTemp2);
	printArratList(arrayListTemp);
	System.out.println();
}

20. removeIf(Predicate<? super E> filter)

删除此集合中满足给定谓词的所有元素。
return :    boolean

public static void main(String[] args){
	ArrayList<Integer> arrayListTemp = new ArrayList<>();
	for (int i=1;i<=3;i++){
		arrayListTemp.add(i);
	}
	//定义一个过滤器：过滤掉所有小于2的元素
	//格式：Predicate <E> 过滤器名 = 变量 -> 过滤条件
	Predicate<Integer> predicate = (i) -> i<2;
	System.out.print("20.\t");
	System.out.print("删除前：");
	printArratList(arrayListTemp);
	arrayListTemp.removeIf(predicate);
	System.out.print("删除后：");
	printArratList(arrayListTemp);
	System.out.println();
}

21. removeRange(int fromIndex, int toIndex)

删除[fromIndex,toIndex)区间中的元素
//protected
/**
* removeRange()方法是一个protected方法，需要其子类的对象才能调用，所以此处应该定义一个ArrayList类的子类
 * 在里面重写removeRange方法
*/
class MyArrayList extends ArrayList{
	MyArrayList list;
	public void removeRange(int fromIndex,int toIndex){
		super.removeRange(fromIndex,toIndex);
	}
}
public static void main(String[] args){
	MyArrayList list = new MyArrayList();
	for (int i=1;i<=3;i++){
		list.add(i);
	}
	System.out.print("21.");
	System.out.print("删除前：");
	printArratList(list);
	list.removeRange(0,2);
	System.out.print("删除后：");
	printArratList(list);
	System.out.println();
	/**
	* 但还可以使用另外一种方法替代
	*/
	{
		System.out.println("21的另外一种方式");
		ArrayList<Integer> arrayListTemp = new ArrayList<>();
		for (int i=1;i<=3;i++){
			arrayListTemp.add(i);
		}
		System.out.print("删除前：");
		printArratList(arrayListTemp);
		arrayListTemp.subList(0,2).clear();//removeRange()方法的底层逻辑就是这玩意儿
		System.out.print("删除后：");
        printArratList(arrayListTemp);
        System.out.println();
	}
}

22. retainAll(Collection<?> c)

只保留指定集合中含有的元素
return : boolean

public static void main(String[] args){
	ArrayList<String> arrayListTemp = new ArrayList<>();
    for (int i=1;i<=3;i++){
		arrayListTemp.add(""+i);
	}
	ArrayList<String> arrayListTemp2 = new ArrayList<>();
	for (int i=1;i<=2;i++){
		arrayListTemp2.add(""+i);
	}
	System.out.print("22.\t");
	System.out.print("删除前：");
	printArratList(arrayListTemp);
 	System.out.print("删除后：");
	arrayListTemp.retainAll(arrayListTemp2);
	printArratList(arrayListTemp);
	System.out.println();
}

23. set(int index, E element)

用指定元素替换指定位置的元素
return : E 返回被替换的元素

public static void main(String[] args){
	ArrayList<Integer> arrayListTemp = new ArrayList<>();
	for (int i=1;i<=3;i++){
		arrayListTemp.add(i);
	}
	System.out.print("23.\t");
	System.out.print("替换前：");
	printArratList(arrayListTemp);
	System.out.print("替换后：");
	arrayListTemp.set(0,300);
	printArratList(arrayListTemp);
	System.out.println();
}

24. size()

返回此列表中元素个数
return : int

public static void main(String[] args){
	ArrayList<Integer> arrayListTemp = new ArrayList<>();
	for (int i=1;i<=3;i++){
		arrayListTemp.add(i);
	}
	System.out.print("24.\t");
	System.out.println("列表中元素个数：" + arrayListTemp.size());
}

25. spliterator()

在此列表中的元素上创建late-binding和故障快速 Spliterator。
return :  Spliterator<E>

public static vodi main(String[] args){

}

26. subList(int fromIndex, int toIndex)

返回[fromIndex,toIndex)区间的List<E>元素
return : List<E>

public static void main(String[] args){
	ArrayList<Integer> arrayListTemp = new ArrayList<>();
	for (int i=1;i<=3;i++){
		arrayListTemp.add(i);
	}
 	System.out.print("26.");
	List list = arrayListTemp.subList(0,2);
	System.out.print("[0,2)区间中的列表元素：");
	printArratList(list);
	System.out.println();
}

27. toArray()

将列表中的元素都储存在数组中返回
return : Object[]

public static void main(String[] args){
	ArrayList<Integer> arrayListTemp = new ArrayList<>();
	for (int i=1;i<=3;i++){
		arrayListTemp.add(i);
	}
	Object[] arr = arrayListTemp.toArray();
	System.out.print("27.\t");
	for (int i=0;i<arr.length;i++){
		System.out.print(arr[i] + " ");
	}
	System.out.println();
}

28. toArray(T[] a)

将列表中的所有元素存储在T类型的数组中返回
return :T[]

public static void main(){
	ArrayList<String> arrayListTemp = new ArrayList<>();
	for (int i=1;i<=3;i++){
		arrayListTemp.add(i+"");
	}
	String[] arr = new String[arrayListTemp.size()];
	arrayListTemp.toArray(arr);
	System.out.print("28.\t");
	for (String s:arr){
		System.out.print(s+ " ");
	}
	System.out.println();
}

29. trimToSize()

将列表的容量调整为实际大小

public static void main(String[] args){
	ArrayList<String> arrayListTemp = new ArrayList<>();
	for (int i=1;i<=3;i++){
		arrayListTemp.add(i+"");
	}
 	//将列表容量调整为3
    arrayListTemp.trimToSize();
}

自定义的打印列表所有元素的方法

public static void printArratList(ArrayList list){
	for (int i=0;i<list.size();i++){
		System.out.print(list.get(i) + " ");
	}
}

4.结语

这些对ArrayList接口中API方法的简单总结，还是开头的话，这些并不是对API方法的深入探索，只是为了在初次使用的时候能够有个大概的了解，中间还有几个方法的用法没总结，待以后知识体系逐渐完备之后会补充的。