Java_List_ArrayList,Vector,LinkedList(含Enumeration枚举应用)

本博客为子墨原创，转载请注明出处！
http://blog.csdn.net/zimo2013/article/details/8862177

 

1.List的子类

        (1).ArrayList

              底层的数据结构是数组,线程不同步，ArrayList替代了Vector，查询元素的速度非常快，允许null的元素。它的实现不是synchronized的，如果多个线程访问一个ArrayList实例，并且至少有一个会对它进行修改的话，就必须对它使用外部synchronized

       (2).LinkedList

              底层的数据结构是链表，线程不同步，增删元素的速度非常快，查询慢。不允许出现null，否则会报NoSuchElementException异常。

       (3).Vector

              底层的数据结构就是数组，线程同步的，Vector无论查询和增删都慢，在不考虑线程同步时，被ArrayList替代。

2.ListIterator迭代器

       ListIterator合适于双向遍历List集合，该迭代器包含较多操作集合的方法。

//去除重复元素
import java.util.*;
class Person
{
private String name;
private int age;
Person(String name, int age)
{
this.name = name;
this.age = age;
}
public int getAge()
{
return this.age;
}
public String getName()
{
return this.name;
}
public boolean equals(Object obj)
{
if (!(obj instanceof Person))
return false;
Person p = (Person)obj;
return this.name.equals(p.getName()) && this.age==p.getAge();
}
}
class Demo
{
public static void main(String[] args)
{
ArrayList al = new ArrayList();

al.add(new Person("java01", 11));
al.add(new Person("java02", 22));
al.add(new Person("java03", 33));
al.add(new Person("java03", 33));
al.add(new Person("java04", 44));

al = noRepeat(al);
Iterator it = al.iterator();
while(it.hasNext())
{
Person p = (Person)it.next();
sop("Name:" + p.getName() +"  Age:"+ p.getAge());
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
public static ArrayList noRepeat(ArrayList a1)
{
ArrayList a = new ArrayList();
Iterator it = a1.iterator();
while(it.hasNext())
{
Object p = it.next();
if(!a.contains(p))	//判断ArrayList是否存在一个元素contains()，必须做的一个动作即使用元素的equals()方法
a.add(p);	//ArrayList的contains动作隐含了元素的equals
}

return a;
}
}

 

/*
Vector 枚举应用
Strawberry2013-5-4
*/
import java.util.*;

class PrintStreamDemo
{
public static void main(String[] args)
{
Vector<String> v = new Vector<String>();
v.add("aaaaaa");
v.add("BBBBBBB");
v.add("aaa");

Enumeration e = v.elements();
while(e.hasMoreElements())
{
System.out.println(e.nextElement());
}
}
}

3.在Iterator中操作List抛出ConcurrentModificationException

      对ArrayList的操作我们可以通过索引象来访问，也可以通过Iterator来访问，只要不对ArrayList结构上进行修改都不会造成ConcurrentModificationException，单独用索引对ArrayList进行修改也不会造成该问题，造成该问题主要是在索引和Iterator混用。可以通过JDK的源码来说明该问题。

/**
*在Iterator的内部有个expectedModCount 变量，
*该变量每次初始化*Iterator的时候等于ArrayList的modCount，modCount记录了对ArrayList的结构修改次数，
*在通过Iterator对ArrayList进行结构的修改的时候都会将expectedModCount 与modCount同步，
*但是如果在通过Iterator访问的时候同时又通过索引的方式去修改ArrayList的结构的话，
*由于通过索引的方式只会修改modCount不会同步修改expectedModCount 就会导致
*modCount和expectedModCount 不相等就会抛ConcurrentModificationException，
*这也就是Iterator的fail-fast，快速失效的。所以只要采取一种方式操作ArrayList就不会出问题，
*当然ArrayList不是线程安全的，此处不讨论对线程问题。
*
*/
int expectedModCount = modCount;
public E next() {
checkForComodification();//判断modeCount与expectedModCount 是否相等，如果不相等就抛异常
try {
E next = get(cursor);
lastRet = cursor++;
return next;
} catch (IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException();
}
}

public void remove() {
if (lastRet == -1)
throw new IllegalStateException();
checkForComodification();//同样去判断modeCount与expectedModCount 是否相等

try {
AbstractList.this.remove(lastRet);
if (lastRet < cursor)
cursor--;
lastRet = -1;
expectedModCount = modCount;//此处修改ArrayList的结构，所以要将expectedModCount 于modCount同步，主要是AbstractList.this.remove(lastRet);的remove方法中将modCount++了，导致了modCount与expectedModCount 不相等了。
} catch (IndexOutOfBoundsException e) {
throw new ConcurrentModificationException();
}
}

//判断modCount 与expectedModCount是否相等，如果不相等就抛ConcurrentModificationException异常
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}