ArayList的一些常用法<一> 转

转：http://yy.azj.blog.163.com/blog/static/18508700320122893451389/

import java.util.ArrayList;

 import java.util.Iterator;

 import java.util.LinkedList;

 import java.util.List;

 import java.util.ListIterator;

 import java.util.Stack;

 import java.util.Vector;



 /**

 * 老紫竹JAVA提高教程(6)-认识List列表<br>

 * List可以精确控制在集合里面的先后顺序。<br>

 * 可以直接通过数据的位置访问数据。<br>

 * 一般允许重复数据<br>

 * 一般允许null,且允许多个null

 *　

 * @author 老紫竹 JAVA世纪网(java2000.net)

 *　

 */

 public class Lession6 {



 　 public static void main(String[] args) {

 　　 // 下面是List里面常用的实现类



 　　 // 大小可变列表的实现，允许任何数据加入

 　　 ArrayList arrayList = new ArrayList();



 　　 // 同样是大小可变列表的实现.

 　　 // 与ArrayList的最大区别就是这个类的方法是同步(synchronized)的

 　　 // 详细的区别，请参考

 　　 // 看源代码理解ArrayList和Vector 的真正区别

 　　 // http://www.java2000.net/p9750

 　　 Vector vector = new Vector();



 　　 // 实现了双向队列的控制，包括头尾的操作

 　　 // 可用于堆栈和FIFO操作等

 　　 LinkedList linkedList = new LinkedList();



 　　 // 集成自 Vector

 　　 // 提供了LIFO的堆栈操作方式

 　　 Stack stack = new Stack();



 　　 // -----------------

 　　 // 下面以ArrayList作为例子，看看列表的各个方法

 　　 List list = new ArrayList();

 　　 // 构建第二个列表

 　　 List list2 = new ArrayList();



 　　 // 向列表的尾部添加指定的数据

 　　 list.add(123);



 　　 // 在列表的指定位置插入指定数据

 　　 // 我们在最前面插入数据

 　　 // 列表的位置索引从0开始

 　　 list.add(0, 456);



 　　 // 将list2里面的数据，全部放到list1的尾部去

 　　 // 注意此处可以是任何集合类，不限于列表

 　　 list.addAll(list2);



 　　 // 将list2里面的数据，全部放到list1指定位置的后面

 　　 // 等于插入一段数据

 　　 list.addAll(2, list2);



 　　 // 清空列表，删除里面所有的数据

 　　 list.clear();



 　　 // 判断列表里是否包含某个数据

 　　 boolean found = list.contains(123);



 　　 // 判断列表是否包含了另一个集合的所有数据

 　　 // 注意此处可以是任何集合类，不限于列表

 　　 boolean ok = list.containsAll(list2);



 　　 // 获得指定位置的数据

 　　 // 如果位置超过了列表的范围 0 到 list.size()-1

 　　 // 则抛出异常：IndexOutOfBoundsException

 　　 Object obj = list.get(3);



 　　 // 得到数据在列表中的位置

 　　 // 如果没找到，返回-1

 　　 // 位置索引从0开始

 　　 int index = list.indexOf(456);



 　　 // 判断列表是不是空的

 　　 boolean empty = list.isEmpty();



 　　 // 列表的迭代器操作

 　　 // 顺序严格按照列表的保存的顺序

 　　 Iterator it = list.iterator();



 　　 // 得到数据在列表最后一次出现的位置

 　　 // 适合于有重复数据的列表

 　　 index = list.lastIndexOf(456);



 　　 // 列表的另一个迭代器

 　　 ListIterator listIT = list.listIterator();



 　　 // 列表的另一个迭代器，可以指定起始位置

 　　 ListIterator listIT2 = list.listIterator(3);



 　　 // 删除某个位置的数据

 　　 list.remove(3);



 　　 // 删除指定对象的第一个出现的位置

 　　 // 注意，如果是整数，要区分其与remove(int)的区别

 　　 // 建议用 remove(new Integer(123)); 来删除数据对象

 　　 list.remove(new Integer(123));



 　　 // 删除列表里在另一个集合里存在的数据

 　　 list.removeAll(list2);



 　　 // 只保留在另一个集合里存在的数据，等于交集

 　　 list.retainAll(list2);



 　　 // 替换指定位置的数据

 　　 list.set(3, 999);



 　　 // 列表数据的数量

 　　 int size = list.size();



 　　 // 得到一个子数组

 　　 List subList = list.subList(2, 10);



 　　 // 将集合转化为数组

 　　 Object[] objs = list.toArray();



 　　 // 将集合转化为指定格式的数组

 　　 // 比如集合里保存的都是String

 　　 String[] objs2 = (String[]) list.toArray(new String[0]);

 　 }

 }

总结：

实际上我们最常用的还是 ArrayList, Vector因为是同步方法，只有在多线程，以及 全局的数据时，我才考虑用。

---

List remove中要注意的问题 :

 import java.util.*;

　　public class object {

　　public static void main(String[] args) {

　　String str1 = new String("abcde");

　　String str2 = new String("abcde");

　　String str3 = new String("abcde");

　　String str4 = new String("abcde");

　　String str5 = new String("abcde");

　　List list = new ArrayList();

　　list.add(str1);

　　list.add(str2);

　　list.add(str3);

　　list.add(str4);

　　list.add(str5);

　　System.out.println("list.size()=" + list.size());

　　for (int i = 0; i < list.size(); i++) {

　　if (((String) list.get(i)).startsWith("abcde")) {

　　list.remove(i);

　　}



　　}

　　System.out.println("after remove:list.size()=" + list.size());

　　}

　　}

运行结果不是：

　　list.size()=5

　　after remove:list.size()=0

居然是：

　　list.size()=5

　　after remove:list.size()=2

 

　　原因：List每remove掉一个元素以后，后面的元素都会向前移动，此时如果执行i=i+1，则刚刚移过来的元素没有被读取。

 

解决方法：

　　1.倒过来遍历list

for (int i = list.size()-1; i > =0; i--) {

　　if (((String) list.get(i)).startsWith("abcde")) {

　　list.remove(i);

　　}

　　}

 

　　2.每移除一个元素以后再把i移回来

for (int i = 0; i < list.size(); i++) {

　　if (((String) list.get(i)).startsWith("abcde")) {

　　list.remove(i);

　　i=i-1;

　　}

　　}

　　3.使用iterator.remove()方法删除

for (Iterator it = list.iterator(); it.hasNext();) {

　　String str = (String)it.next();

　　if (str.equals("chengang")){

　　it.remove();

　　}

　　}

 注意：在遍历list或者说在遍历集合过程中，执行了删除动作就会报错

　　工作中碰到个ConcurrentModificationException。代码如下：

 

 

　List list = ...;

　　for(Iterator iter = list.iterator(); iter.hasNext();) {

　　Object obj = iter.next();

　　...

　　if(***) {

　　list.remove(obj);

　　}

　　}

在执行了remove方法之后，再去执行循环，iter.next()的时候，报java.util.ConcurrentModificationException(当然，如果remove的是最后一条，就不会再去执行next()操作了)

　　下面来看一下源码

 

　public interface Iterator<E> {

　　boolean hasNext();

　　E next();

　　void remove();

　　}



　　public interface Collection<E> extends Iterable<E> {

　　...

　　Iterator<E> iterator();

　　boolean add(E o);

　　boolean remove(Object o);

　　..

　　}