ArrayList、Vector、LinkedList学习例子

转载 2015年11月20日 16:29:31
    package c4;  
      
    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;  
      
    /**  
     * (1)ArrayList是最常用的List实现类,内部是通过数组实现的,它允许对元素进行快速随机访问。数组的缺点是每个元素之间不能含有“空隙”。  
     * 当数组大小不满足时会增加存储能力,将已有数组数据复制到新的存储空间中。当从ArrayList的中间位置插入或者删除元素时,需要对数组进行拷贝,移动,代价比较高。因此,它适合随即查找和遍历,不适合插入合删除。  
     * (2)Vector与ArrayList一样,也是通过数组实现的。不同的是它支持线程的同步,  
     * 即一时刻只有一个线程能够写Vector,避免多线程同时写引起的不一致性。但实现同步需要很高的花费,  
     * 因此,访问它比访问ArrayList慢。  
     * (3)LinkedList是用链表结构存储数据的,很适合数据的动态插入和删除,随即访问和遍历速度比较慢。另外,它还提供了List没有定义的方法,专门用于操作表头和表尾元素,可以当作堆栈、队列和双向队列使用。  
     * (4)因为ArrayList和Vector都是用数组实现的,所以,在添加和插入时,最好从表尾操作,而不要从中间或者表头开始,以避免数组移动引起的开销!  
     * (5)可以为每个List生成ListIterator,支持双向遍历List,而且能够在ListIterator位置插入和删除元素。  
     * (6)堆栈类继承Vector,它总是对列表的尾部数据进行操作,采用了先进后出的策略,自定义了插入、查看和弹出元素三个方法。  
     */  
      
    /**  
     * 演示各种List的使用  
     * List是能维护元素的次序,它允许元素重复  
     */  
    public class TestList {  
          
        /**  
         * 初始化一个List  
         * @param list  
         */  
        public static void init(List list){  
            if(list != null){  
                list.add("aaa");  
                list.add("ccc");  
                list.add("bbb");  
                list.add("eee");  
                list.add("ddd");  
            }  
        }  
        /**  
         * 输出List的内容  
         * @param list  
         */  
        public static void output(List list){  
            if (list != null){  
                //根据列表下标遍历,使用list.size()获取列表中元素的个数  
                for (int i=0; i<list.size(); i++){  
                    System.out.print(list.get(i) + "  ");  
                }  
                //或者用迭代器遍历  
                Iterator it  = list.iterator();  
                Object value = null;  
                while (it.hasNext()){  
                    value = it.next();  
                    //System.out.println(value);  
                }  
            }  
            System.out.println();  
        }  
        /**  
         * 使用ArrayList  
         */  
        public static void testArrayList(){  
            List list = new ArrayList();  
            init(list);  
            System.out.println("使用ArrayList: ");  
            output(list);  
        }  
        /**  
         * 使用Vector  
         */  
        public static void testVector(){  
            List list = new Vector();  
            init(list);  
            System.out.println("使用Vector: ");  
            output(list);  
        }  
        /**  
         * 使用LinkedList  
         */  
        public static void testLinkedList(){  
            List list = new LinkedList();  
            init(list);  
            System.out.println("使用LinkedList: ");  
            output(list);  
        }  
          
        public static void main(String[] args) {  
            TestList.testArrayList();  
            TestList.testVector();  
            TestList.testLinkedList();  
              
            List list = new ArrayList();  
            System.out.println(list == null);  
            init(list);  
            //List支持元素重复  
            list.add("aaa");  
            list.add("bbb");  
            System.out.println("插入元素aaa, bbb后:");  
            output(list);  
            //指定元素插入的位置  
            list.add(1, "fff");  
            System.out.println("在下标为1处插入fff后:");  
            output(list);  
            List list2 = new ArrayList();  
            list2.add("ggg");  
            list2.add("hhh");  
            //将另一列表中的元素插入到列表中  
            list.addAll(list2);  
            System.out.println("添加list2的元素后:");  
            output(list);  
      
            //判断列表是否包含某一元素  
            //通过元素的equals方法,判断元素是否相等  
            System.out.println("list包含aaa? " + list.contains("aaa"));  
            //判断列表中是否包含了另外一个列表中的所有元素。  
            System.out.println("list包含list2中的所有元素? " + list.containsAll(list2));  
            //定位一个元素在列表中最先出现的位置  
            System.out.println("aaa在list中第一次出现的位置: " + list.indexOf("aaa"));  
            //定位一个元素在列表中最后出现的位置  
            System.out.println("aaa在list中最后一次出现的位置: " + list.lastIndexOf("aaa"));  
              
            //更新列表中某个位置的元素值  
            list.set(2, "xxx");  
            System.out.println("更新位置为2的元素为xxx后:");  
            output(list);  
            //删除列表中的某个元素,只删除第一次出现的那个  
            list.remove("aaa");  
            System.out.println("删除元素aaa后:");  
            output(list);  
            //删除列表中指定位置的元素  
            list.remove(1);  
            System.out.println("删除下标为1的元素后:");  
            output(list);  
            //删除列表中的其他元素,只保留另一个列表中包含的元素  
            list.retainAll(list2);  
            System.out.println("删除除list2包含的以外的元素后:");  
            output(list);  
            //删除列表中在另一列表中也包含了的元素  
            list.removeAll(list2);  
            System.out.println("删除list2包含的元素后:");  
            output(list);  
              
            //清空列表  
            list.clear();  
            //判断列表中是否有数据  
            System.out.println("清空List后,list为空么?  " + list.isEmpty());  
            init(list);  
            //用列表中的某些元素构造一个新的列表  
            list2 = list.subList(1,3);  
            System.out.println("用list的第1个到第3个元素构造一个新的List:");  
            output(list2);  
              
            //用List特有的遍历器ListIterator遍历列表  
            //与普通的Iterator不用,它允许两个方向遍历列表  
            ListIterator listIt = list.listIterator();  
            System.out.println("正向遍历列表");  
            while (listIt.hasNext()){  
                System.out.print(listIt.next());  
            }   
            System.out.println();  
            System.out.println("反向遍历列表");  
            while (listIt.hasPrevious()){  
                System.out.print(listIt.previous());  
            }   
            System.out.println();  
            //也可以使用ListIterator从List中间插入和删除元素,  
            //只能在遍历器当前位置添加和删除。  
            listIt.add("newadd");  
            System.out.println("用ListIterator往列表中添加元素newadd后: ");  
            output(list);  
            listIt.next();  
            listIt.remove();  
            System.out.println("用ListIterator删除列表中元素后: ");  
            output(list);  
      
            //LinkedList自定义的方法  
            LinkedList linklist = new LinkedList();  
            init(linklist);  
            //添加元素到列表头  
            linklist.addFirst("fff");  
            System.out.println("把fff放到列表头后:");  
            output(linklist);  
            //添加元素到列表尾  
            linklist.addLast("eee");  
            System.out.println("把eee放到列表尾后:");  
            output(linklist);  
            //获取表头元素  
            System.out.println("列表头元素:" + linklist.getFirst());  
            //获取表尾元素  
            System.out.println("列表尾元素:" + linklist.getLast());  
            //删除列表头的元素  
            linklist.removeFirst();  
            System.out.println("删除列表头元素后:");  
            output(linklist);  
            //删除列表尾的元素  
            linklist.removeLast();  
            System.out.println("删除列表尾元素后:");  
            output(linklist);  
              
            //堆栈Stack类,它继承自Stack类  
            Stack myStack =  new Stack();  
            //插入元素,是插入到尾部  
            myStack.push("aaa");  
            myStack.push("bbb");  
            myStack.push("ccc");  
            myStack.push("ddd");  
            myStack.push("aaa");  
            myStack.push("ddd");  
            System.out.println("堆栈中的元素是: ");  
            output(myStack);  
            System.out.println("堆栈尾部元素: " + myStack.peek());  
            System.out.println("弹出堆栈尾部元素: " + myStack.pop());  
            output(myStack);  
            myStack.push("kkk");  
            output(myStack);  
        }  
    }  

相关文章推荐

ArrayList、Vector、LinkedList学习例子

package c4; import java.util.ArrayList; import java.util.Iterator; import java.util.LinkedList; imp...

(黑马程序员)学习笔记,Collection集合(ArrayList、LinkedList、Vector、HashSet、TreeSet)

这类集合都实现了Collection接口,因此也j

ArrayList、LinkedList、 Vector、Map 用法比较

ArrayList和Vector是采用数组方式存储数据,此数组元素总数大于实际存储的数据个数以便增加和插入元素,二者都允许直接序号索引元素,但是插入数据要移动数组元素等内存操作,所以它们索引数据快、插...

ArrayList & LinkedList & Vector比较

List主要的实现类有三个,分别是ArrayList, LinkedList和Vector。我们最常用的是前两个,即ArrayList和LinkedList,对Vector多少有些生疏。简单来说,Ve...

ArrayList,Vector和LinkedList区别详解

一、ArrayList ArrayList是一个可以处理变长数组的类型,这里不局限于“数”组,ArrayList是一个泛型类,可以存放任意类型的对象。顾名思义,ArrayList是一个数组列表,因此...

java的List接口的实现类 ArrayList,LinkedList,Vector 的区别

Java的List接口有3个实现类,分别是ArrayList、LinkedList、Vector,他们用于存放多个元素,维护元素的次序,而且允许元素重复。 3个具体实现类的区别如下:       ...

ArrayList Vector LinkedList 区别与用法

ArrayList 和Vector是采用数组方式存储数据,此数组元素数大于实际存储的数据以便增加和插入元素,都允许直接序号索引元素,但是插入数据要设计到数组元素移动等内存操作,所以索引数据快插入数据慢...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)