ArrayList

ArrayList

概念：ArrayList就是动态数组，用MSDN中的说法，就是Array的复杂版本，它提供了动态的增加和减少元素，实现了ICollection和IList接口，灵活的设置数组的大小等好处

add(E e) 方法

将指定的元素追加到此列表的末尾

package a;
//使用add()方法向集合里面添值
public class tianzhi {
		public static void main(String[] args) {
		List l=new ArrayList();
		l.add("a");
		l.add(1);
		l.add('b');
		l.add(2.0f);//Float
		l.add(2.00);
		Object e = 3,s=6;
		l.add(e);	
		l.add(s);	
		//“E”为不确定的类型，所以可以输入任意值,如果想向里面添加对象名，则要输入数据类型
   }
}

add(int index, E element)方法

在此列表中的指定位置插入指定的元素。

public class tianzhi {
		public static void main(String[] args) {
		List l=new ArrayList();
		int e=6;
		l.add(3,e);//前面写下标，后面写要插入集合的内容
		//注意：下标从零开始
		}
	}

addAll(Collection<? extends E> c) 方法

按指定集合的Iterator(Java的迭代器)返回的顺序将指定集合中的所有元素追加到此列表的末尾。

如果对该集合进行了泛化，则要求指定集合中的所有对象都符合泛化类型，否则在编译程序时将抛出异常，入口参数中的“<? extends > E>”说明了这个问题，其中的E为用来泛化的类型。 addAll(Collection<? extends E> col)方法的使用方法如下：

public static void main(String[] args) {
		
			String a = "A";
			String b = "B";
			String c = "C";
			Collection<String> list = new ArrayList<String>();
			list.add(a);// 通过add(E obj)方法添加指定对象到集合中
			list.add(b);
			Collection<String> list2 = new ArrayList<String>();
			// 通过addAll(Collection<? extends E> col)方法添加指定集合中的所有对象到该集合中
			list2.addAll(list);
			list2.add(c);
			Iterator<String> it = list2.iterator();// 通过iterator()方法序列化集合中的所有对象
			while (it.hasNext()) {
			String str = it.next();// 因为对实例it进行了泛化，所以不需要进行强制类型转换
			System.out.println(str);
			}
			}

addAll(int index, Collection<? extends E> c) 方法

将指定集合中的所有元素插入到此列表中，从指定的位置开始。 就是在上个方法中加入集合的下标

clear()

从列表中删除所有元素。

public static void main(String[] args) {
		List l=new ArrayList();
		l.add(66);
		l.add(5);
		for(int i=0;i<l.size();i++) {
			System.out.println(l.get(i));			
		}			
		l.clear();	
		for(int i=0;i<l.size();i++) {
			System.out.println(l.get(i));			
		}
	}

由结果可知在l.clear(); 后是没有输出结果的，也就是集合里面已经没有了元素

contains(Object o)方法

验证集合里面是否有此元素，如果有则返回true

public static void main(String[] args) {
		List l=new ArrayList();
		l.add(66);
		l.add(5);
		for(int i=0;i<l.size();i++) {
			System.out.println(l.get(i));		
		}
		System.out.println(l.contains(66));
	}//返回true

ensureCapacity(int minCapacity

如果需要，增加此 ArrayList实例的容量，以确保它可以至少保存最小容量参数指定的元素数。

我们在使用Arraylist时，经常要对它进行初始化工作，在使用add()方法增加新的元素时，如果要增加的数据量很大，应该使用ensureCapacity()方法，该方法的作用是预先设置Arraylist的大小，这样可以大大提高初始化速度。

import java.util.ArrayList; 
public class EnsureCapacityTest {
        public static void main(String[] args){
                final int N = 1000000;
                Object obj = new Object();                
                //没用调用ensureCapacity()方法初始化ArrayList对象
                ArrayList list = new ArrayList();
                long startTime = System.currentTimeMillis();
                for(int i=0;i<=N;i++){
                        list.add(obj);
                }
                long endTime = System.currentTimeMillis();
                System.out.println("没有调用ensureCapacity()方法所用时间：" + (endTime - startTime) + "ms");                
                //调用ensureCapacity()方法初始化ArrayList对象
                list = new ArrayList();
                startTime = System.currentTimeMillis();
                list.ensureCapacity(N);//预先设置list的大小
                for(int i=0;i<=N;i++){
                        list.add(obj);
                }
                endTime = System.currentTimeMillis();
                System.out.println("调用ensureCapacity()方法所用时间：" + (endTime - startTime) + "ms");
        }
}

输出结果：

结果：在N的值很大的时候，使用ensureCapacity()方法可大大提高效率；而当N的值较小时，则所用时间差距不明显。

forEach(Consumer<? super E> action)方法

对 Iterable的每个元素执行给定的操作，直到所有元素都被处理或动作引发异常。

 public static void main(String[] args) {
        int i = 0;
        List<Integer> list = new ArrayList<>();
        list.add(++i);
        list.add(++i);
        list.add(++i);
        list.add(++i);
        list.forEach(cc -> System.out.println(cc));
        list.forEach(System.err :: println);
        list.add(++i); 
        Integer[] ints = new Integer[]{};
        ints = list.toArray(ints);
        System.out.println(Arrays.asList(ints));
    }

get(int index) 方法

获得括号里下标所代表的元素
运用代码

public static void main(String[] args) {
		List arrl=new ArrayList();
		arrl.add("张三");
		arrl.add(10);
		arrl.add(3.14);
		//返回集合的长度
		int le=arrl.size();
		//输出值get(index)获取指定下标的值
		System.out.println("第一种方法");
		for(int i=0;i<le;i++) {
			System.out.print(arrl.get(i)+" ");
		}

indexOf(Object o)方法

返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。

public static void main(String[] args) {
		int a=5;
		List l=new ArrayList();
		((ArrayList) l).ensureCapacity(s);
		l.add(66);
		l.add(5);
		l.add(5);
		System.out.println(l.indexOf(5));
		for(int i=0;i<l.size();i++) {
			System.out.println(l.get(i));
		}
	}

第一个输出的是1，是因为第一个5的下标是1，输出的是下标数。该方法主要作用就是用来获取第一个该元素出现的下标。

isEmpty()方法

如果此列表不包含元素，则返回 true 。

验证集合内是否有元素，使用方法是“.isEmpty() ”。

public static void main(String[] args) { 
	int a=5; 
	List l=new ArrayList(); 
	((ArrayList) l).ensureCapacity(s); 
	l.add(66); 
	l.add(5); 
	l.add(5);
	System.out.println(l.isEmpty()); 
 	for(int i=0;i<l.size();i++) {
  		System.out.println(l.get(i)); 
  	} 
  }

iterator()方法

以正确的顺序返回该列表中的元素的迭代器。

// 引入 ArrayList 和 Iterator 类
import java.util.ArrayList;
import java.util.Iterator;

public class RunoobTest {
    public static void main(String[] args) {

        // 创建集合
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("a");
        sites.add("b");
        sites.add("c");
        sites.add("d");

        // 获取迭代器
        Iterator<String> it = sites.iterator();

        // 输出集合中的第一个元素
        System.out.println(it.next());
    }
}

lastIndexOf(Object o) 方法

返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
和indexOf(Object o)不同的是，这个方法是获取该元素在此列表最后出现的下标位置

listIterator() 方法

返回列表中的列表迭代器（按适当的顺序）。

import typeinfo.pets.*;
import java.util.*;

public class ListIteration {
  public static void main(String[] args) {
    List<Pet> pets = Pets.arrayList(8);
    ListIterator<Pet> it = pets.listIterator();
    while(it.hasNext())
      System.out.print(it.next() + ", " + it.nextIndex() +
        ", " + it.previousIndex() + "; ");
    System.out.println();
    // Backwards:
    while(it.hasPrevious())
      System.out.print(it.previous().id() + " ");
    System.out.println();
    System.out.println(pets);    
    it = pets.listIterator(3);
    while(it.hasNext()) {
      it.next();
      it.set(Pets.randomPet());
    }
    System.out.println(pets);
  }
}

listIterator(int index) 方法

在上一个方法中加入了下标的用法，可以设置列表开始位置

remove(int index)方法

删除指定位置的元素

public static void main(String[] args) {
		int s=5;
		List l=new ArrayList();
		((ArrayList) l).ensureCapacity(s);
		l.add(66);
		l.add(5);
		l.add(5);
		l.remove(0);
		for(int i=0;i<l.size();i++) {
			System.out.println(l.get(i));
		}
	}

removeAll(Collection<?> c) 方法

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

removeIf(Predicate<? super E> filter)

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

public static void main(String[] args){
    List<String>list = new ArrayList<String>();
    list.add("a");  //向列表中添加数据
    list.add("b");  //向列表中添加数据
    list.add("c");  //向列表中添加数据
    List<String>list1 = new ArrayList<String>();
    list1.add("a");  //向列表中添加数据
    list1.add("b");  //向列表中添加数据
    boolean ret = list.removeAll(list1);  //从list中移除与list1相同的元素
    Iterator<String>it = list.iterator();  //创建迭代器
    while(it.hasNext()){  //循环遍历迭代器
    System.out.println(it.next());  //输出集合中元素
  }
}

removeRange(int fromIndex, int toIndex) 方法

从这个列表中删除所有索引在 fromIndex （含）和 toIndex之间的元素。

import java.util.*;
public class a extends ArrayList{		
		      public static void main(String[] args) {
		      a arrlist = new a();
		      arrlist.add(10);
		      arrlist.add(12);
		      arrlist.add(31);
		      System.out.println("原list:" + arrlist);
		      arrlist.removeRange(0,2);
		      System.out.println("新list:" + arrlist);
		   }
	}