java集合之List

1.  List的四个基本增删改查方法的使用如下：

public class Demo1_List {

    /*
     * void add(int index, E element)
     * E remove(int index)     返回值为删除的元素
     * boolean remove(E element)
     * E get(int index)
     * E set(int index, E element)
     */
    public static void main(String[] args) {

        //demo1();
        //demo2();
        //demo3();
        List l = new ArrayList();
        l.add("a");
        l.add("b");
        l.add("c");
        l.set(1, "dd");         //将指定位置的元素修改
        System.out.println(l);  //[a, dd, c]
    }

    public static void demo3() {
        List l = new ArrayList();
        l.add("a");
        l.add("b");
        l.add("c");
        //Object o = l.get(0);
        //System.out.println(o);
        //通过索引遍历list集合
        for (int i = 0; i < l.size(); i++) {
            System.out.println(l.get(i));
        }
    }

    public static void demo2() {
        List l = new ArrayList();
        l.add("a");
        l.add("b");
        l.add("c");
        l.add(555);
        Object obj = l.remove(1);
        System.out.println(obj);  //b    
        System.out.println(l);    //[a, c]
        System.out.println(l.remove("a"));   //true
        //Object o = l.remove(555);    //java.lang.IndexOutOfBoundsException: Index: 555, Size: 2   这里删除时不会自动装箱
    }

    public static void demo1() {
        List l = new ArrayList();
        l.add("a");
        l.add("b");
        l.add("c");
        System.out.println(l);    //[a, b, c]
        l.add(3, "d");          //0 <= index <= size  时不会报异常
        //l.add(4, "d");        java.lang.IndexOutOfBoundsException: Index: 4, Size: 3
    }

}

2.  使用get()  和  size()方法结合遍历存有自定义对象的集合

public class Demo2_List {

    /*
     * 向List集合中存储学生对象，使用size()和get()结合的方法遍历集合
     */
    public static void main(String[] args) {
        List l = new ArrayList();
        l.add(new Student("张三",18));
        l.add(new Student("李四",19));
        l.add(new Student("王五",10));
        for (int i = 0; i < l.size(); i++) {
//            System.out.println(l.get(i));
            Student s = (Student) l.get(i);
            System.out.println(s.getName() + " " + s.getAge());
        }
    }

}

3.  需要注意：遍历的同时修改集合会报java.util.ConcurrentModificationException并发修改异常，要想避免这个异常，则可以使用迭代器特有的添加方法

public class Demo3_ConcurrentModificationException {

    public static void main(String[] args) {

        List l = new ArrayList();
        l.add("a");
        l.add("world");
        l.add("b");
        l.add("c");
        
        /*Iterator it = l.iterator();
        while (it.hasNext()) {
            String s = (String) it.next();
            if (s.equals("world")) {
                l.add("javaee");      //遍历的同时修改集合会报java.util.ConcurrentModificationException并发修改异常
            }                         //要想避免这个异常，则可以使用迭代器特有的添加方法
        }
        */
        
        ListIterator lit = l.listIterator();    //获取list集合特有的迭代器
        while (lit.hasNext()) {
            String s = (String)lit.next();
            if (s.equals("world")) {
                lit.add("javaee");              //使用list特有的迭代器添加方法在遍历的同时添加元素不会出现并发修改异常
            }
        }
        System.out.println(l);    //[a, world, javaee, b, c]
        
    }

}

4.  Vector

public class demo4_Vector {

    /*
     * 现在Vector已经基本上废弃，由list代替
     * 
     * 数组：查询修改快，增删慢
     * 
     * 链表：查询修改慢，增删改快
     * 
     * list的三个子类比较：
     *    ArrayList：
     *        底层数据结构是数组，查询快，增删慢
     *        线程不安全，效率高
     *        
     *    Vector：
     *        底层数据结构是数组，查询快，增删慢
     *        线程安全，，效率低
     *    
     *    Vector相对ArrayList查询慢（线程安全），相对LinkList增删慢（数据结构）
     *    
     *    LinkList：
     *        底层数据结构是链表，查询慢，增删快
     *        线程不安全，效率高
     *        
     *    Vector和ArrayList的区别：
     *        Vector是线程安全的，效率低
     *        ArrayList是线程不安全的，效率高
     *        
     *    ArrayList和LinkList的区别：
     *        ArrayList底层是数组结构，查询和修改快
     *        LinkList底层是链表结构，增删快，查询修改慢
     *        
     *    NB:
     *        查询多时用ArrayList
     *        增删多时用LinkList
     *        如果都多的话，用ArrayList
     *  
     */
    public static void main(String[] args) {

        Vector v = new Vector();
        v.addElement("a");
        v.addElement("b");
        v.addElement("c");
        
        Enumeration en = v.elements();
        while(en.hasMoreElements()) {
            System.out.println(en.nextElement());
        }
    }

}

5.  对List集合中的元素去重

/**
 * @author Administrator
 * 对存储有重复字符串的集合去重
 */
@SuppressWarnings({ "rawtypes", "unchecked" })
public class Demo5_ArrayList_quchong {

    /**
     * @param args
     */
    public static void main(String[] args) {

        ArrayList list = new ArrayList();
        list.add("a");
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("c");
        ArrayList li = getSingle(list);
        System.out.println(li);
    }
    
    
    /**
     * @param list
     * @return ArrayList
     * 思路：通过创建一个新的集合对老集合遍历，将需要留下的元素插入新集合中
     * 
     * 1. 创建一个新空集合
     * 2.对老集合进行遍历，判断新集合中是否存在该元素，如果不存在则插入，如果存在则继续遍历
     * 3.将新集合返回
     */
    public static ArrayList getSingle(ArrayList list) {
        ArrayList newList = new ArrayList();
        Iterator it = list.iterator();
        while(it.hasNext()) {
            Object o = it.next();
            if (!newList.contains(o)) {
                newList.add(o);
            }
        }
        return newList;
    }

}

***************************************************************

/**
 * @author Administrator
 * 对自定义类集合去重处理
 *
 */
@SuppressWarnings({ "rawtypes", "unchecked" })
public class Demo6_ArrayList_zdyquchong {

    /**
     * @param args
     */
    public static void main(String[] args) {

        ArrayList list = new ArrayList();
        list.add(new Person("张三", 23));
        list.add(new Person("张三", 23));
        list.add(new Person("李四", 24));
        list.add(new Person("李四", 24));
        list.add(new Person("李四", 24));
        
        ArrayList li = getSingle(list);
        System.out.println(li);
    }

    /**
     * @param list
     * @return ArrayList
     * 思路：通过创建一个新的集合对老集合遍历，将需要留下的元素插入新集合中
     * 
     * 1. 创建一个新空集合
     * 2.对老集合进行遍历，判断新集合中是否存在该元素，如果不存在则插入，如果存在则继续遍历
     * 3.将新集合返回
     */
    public static ArrayList getSingle(ArrayList list) {
        ArrayList newList = new ArrayList();
        Iterator it = list.iterator();
        while(it.hasNext()) {
            Object o = it.next();
            if (!newList.contains(o)) {
                newList.add(o);
            }
        }
        return newList;
    }
}

 6.LinkList

/*
     * public void addFirst(E e)    
     * public void addLast(E e)
     * public E removeFirst()   返回被删除的元素
     * public E removeLast()    返回被删除的元素
     * public E getFirst()      返回查找的元素
     * public E getLast()       返回查找的元素
     * public E get(int index)  返回查找的元素
     */
    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.addFirst("a");
        list.addFirst("b");
        list.addFirst("c");
        list.addFirst("d");
        list.addLast("e");
        System.out.println(list);
        System.out.println(list.removeFirst());
        System.out.println(list.removeLast());
        System.out.println(list.getFirst());
        System.out.println(list.getLast());
        System.out.println(list.get(1));
        
    }

7. 使用LinkList模拟栈的进出

/**
 * @author Administrator
 *  使用LinkedList模拟栈的进、出以及是否为空
 */
public class Demo8_LinkList {

    public static void main(String[] args) {
        Stack s = new Stack();
        s.in("a");
        s.in("b");
        s.in("c");
        s.in("d");
        
        System.out.println(s);
        while(!s.isEmpty()) {
            System.out.println(s.out());
        }
    }