ArrayList的具体方法

ArrayList的具体方法

1.add(E e) 方法
将指定的元素追加到此列表的末尾

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

2.add(int index, E element)方法
在此列表中的指定位置插入指定的元素。

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

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

4.addAll(int index, Collection<? extends E> c) 方法
将指定集合中的所有元素插入到此列表中，从指定的位置开始。 就是在上个方法中加入集合的下标

这里不再做代码展示，只要熟练使用下标就行

5.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(); 后是没有输出结果的，也就是集合里面已经没有了元素

6.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

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

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

<span style="font-size:18px;">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");
        }
}
 
 
输出结果： 
没有调用ensureCapacity()方法所用时间：110ms 
调用ensureCapacity()方法所用时间：31ms 
   结果显而易见，在N的值很大的时候，使用ensureCapacity()方法可大大提高效率；而当N的值较小时，则所用时间差距不明显，这里就不在赘诉，如果感兴趣，各位网友可以自己试试。</span>

8.forEach(Consumer<? super E> action)
对 Iterable的每个元素执行给定的操作，直到所有元素都被处理或动作引发异常。
下面是Iterable翻译后的的部分源码：

 /**
     * 对每个{@code Iterable}元素执行特定的操作直到所有的元素被处理或者抛出一个异常。
     * 除非实现类另有定义，否则操作将被按照顺序迭代器的顺序执行（如果迭代器被指定）。
     * 操作抛出的异常将传递给其调用者。
     *
     * @implSpec
     * <p>默认实现类似下边这样::
     * {@code
     *     for (T t : this)
     *         action.accept(t);
     * }</pre>
     * @param action 每个元素将要被执行的操作
     * @throws NullPointerException 如果指定的操作action是空的
     * @since 1.8
     */
    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }

练习代码

    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));
    }
    -------------以下是结果-----------------------
1
2
3
4
1
2
[1, 2, 3, 4, 5]
3
4

9.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)+" ");
		}
 -------------以下是结果-----------------------
 张三 10 3.14 

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

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);
		System.out.println(l.indexOf(5));
		for(int i=0;i<l.size();i++) {
			System.out.println(l.get(i));
		}
	}
------------------以下是结果--------------
1
66
5
5

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

11.isEmpty()
如果此列表不包含元素，则返回 true 。

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

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);
		System.out.println(l.isEmpty());
		for(int i=0;i<l.size();i++) {
			System.out.println(l.get(i));
		}
	}
	------------------以下是结果--------------
false
66
5
5

12.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("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");

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

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

13.lastIndexOf(Object o) 方法
返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。

和indexOf(Object o)不同的是，这个方法是获取该元素在此列表最后出现的下标位置

14.listIterator() 方法
返回列表中的列表迭代器（按适当的顺序）。

详解

LIstIterator是一个更加强大的Iterator的子类型,它只能用于各种List类的访问,尽管Iterator只能向前移动,但是ListIterator可以双向移动,它还可以产生相对于迭代器在列表指向的当前位置的前一个和后一个元素的索引,并且可以使用set()方法替换它访问过的最后一个元素.
你可以通过ListIterator()方法产生一个指向List开始处的ListIteraor,并且还可以通过调用ListIterator(n)方法创建一个一开始就指向索引列表n的元素处的ListIterator

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

15.listIterator(int index) 方法
在上一个方法中加入了下标的用法，可以设置列表开始位置

16.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));
		}
	}
	---------------结果-----------------------
5
5

可见下标为0的元素66消失了

17.removeAll(Collection<?> c) 方法
从此列表中删除指定集合中包含的所有元素。

18.removeIf(Predicate<? super E> filter)
删除满足给定谓词的此集合的所有元素。

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

19.removeRange(int fromIndex, int toIndex) 方法
从这个列表中删除所有索引在 fromIndex （含）和 toIndex之间的元素。

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

20.replaceAll(UnaryOperator operator) 方法
将该列表的每个元素替换为将该运算符应用于该元素的结果。

源码解释：方法用于将此列表的每个元素替换为将运算符应用于该元素的结果。操作员抛出的错误或运行时异常被转发给调用者
* 简单解释：用函数接口的返回结果替代原list中的值.
* 如果list的迭代器不支持set操作,当替换第一个元素时,会抛出异常.