疯狂JAVA讲义---第七章（中）：集合List，Queue

最新推荐文章于 2018-10-02 22:40:32 发布

原创最新推荐文章于 2018-10-02 22:40:32 发布 · 1.7k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#list #java #struts #敏捷开发 #books #企业应用

J2SE 专栏收录该内容

64 篇文章

订阅专栏

本文深入探讨了Java中List接口的应用，包括ArrayList、LinkedList等实现类的特点与使用场景，并通过实例展示了如何进行元素的增删改查操作。

List是我们所有集合中最多的，也可以说太好用了。相比set他提供了索引，我们可以通过索引得到元素，元素可以重复。使用时要记住set方法不能改变List长度，而romove时会将后面的元素提上来，eg

public class TestList
{
    public static void main(String[] args) 
    {
        List books = new ArrayList();
        //向books集合中添加三个元素 
        books.add(new String("轻量级J2EE企业应用实战"));
        books.add(new String("Struts2权威指南"));
        books.add(new String("基于J2EE的Ajax宝典"));
        System.out.println(books);
        //将新字符串对象插入在第二个位置 
        books.add(1 , new String("ROR敏捷开发最佳实践"));
        for (int i = 0 ; i < books.size() ; i++ )
        {
            System.out.println(books.get(i));
        }
        //删除第三个元素 
        books.remove(2);
        System.out.println(books);
        //判断指定元素在List集合中位置：输出1，表明位于第二位 
        System.out.println(books.indexOf(new String("ROR敏捷开发最佳实践")));
        //将第二个元素替换成新的字符串对象 
        books.set(1, new String("Struts2权威指南"));
        System.out.println(books);
        //将books集合的第二个元素（包括）到第三个元素（不包括）截取称子集合 
        System.out.println(books.subList(1 , 2));
    }
}

ListIterator是其专用迭代器，不但有next还有previous方法，就是说可以向前迭代，非常方便。eg

public class TestListIterator
{
    public static void main(String[] args) 
    {
        String[] books = {
            "Struts2权威指南",
            "轻量级J2EE企业应用实战"
        };
        List bookList = new ArrayList();
        for (int i = 0; i < books.length ; i++ )
        {
            bookList.add(books[i]);
        }
        ListIterator lit = bookList.listIterator();
        while (lit.hasNext())
        {
            System.out.println(lit.next());
            lit.add("-------分隔符-------");
        }
        System.out.println("==========下面开始反向迭代===========");
        while(lit.hasPrevious())
        {
            System.out.println(lit.previous());
        }
    }
}

list的实现类分为ArrayList 和Vector,但vector已经过时，尽量少用。只是vector的子类stack还有用武之地。eg

public class TestVector
{
    public static void main(String[] args) 
    {
        Stack v = new Stack();
        //依次将三个元素push入"栈" 
        v.push("Struts2权威指南");
        v.push("轻量级J2EE企业应用实战");
        v.push("ROR敏捷开发最佳实践");
        //输出：[Struts2权威指南, 轻量级J2EE企业应用实战, ROR敏捷开发最佳实践] 
        System.out.println(v);
        //访问第一个元素，但并不将其pop出"栈"，输出：ROR敏捷开发最佳实践 
        System.out.println(v.peek());
        //依然输出：[Struts2权威指南, 轻量级J2EE企业应用实战, ROR敏捷开发最佳实践] 
        System.out.println(v);
        //pop出第一个元素，输出：ROR敏捷开发最佳实践 
        System.out.println(v.pop());
        //依然输出：[Struts2权威指南, 轻量级J2EE企业应用实战] 
        System.out.println(v);
    }
}

LinkedList这是一个特殊集合，他既可以当list用也可以当queue用。eg（请使用jdk1.6）

public class TestLinkedList
{
    public static void main(String[] args) 
    {
        LinkedList books = new LinkedList();
        //将字符串元素加入队列的尾部 
        books.offer("Struts2权威指南");
        //将一个字符串元素入栈 
        books.push("轻量级J2EE企业应用实战");
        //将字符串元素添加到队列的头部 
        books.offerFirst("ROR敏捷开发最佳实践");
        for (int i = 0; i < books.size() ; i++ )
        {
            System.out.println(books.get(i));
        }
        //访问、并不删除队列的第一个元素 
        System.out.println(books.peekFirst());
        //访问、并不删除队列的最后一个元素 
        System.out.println(books.peekLast());
        //采用出栈的方式将第一个元素pop出队列 
        System.out.println(books.pop());
        //下面输出将看到队列中第一个元素被删除 
        System.out.println(books);
        //访问、并删除队列的最后一个元素 
        System.out.println(books.pollLast());
        //下面输出将看到队列中只剩下中间一个元素：轻量级J2EE企业应用实战 
        System.out.println(books);
    }
}

虽然LinkedList功能强大，但是效率低，通过下面的例子大家能看出差距。eg

public class TestPerformance
{
    public static void main(String[] args) 
    {
        //创建一个字符串数组 
        String[] tst1 = new String[900000];
        //动态初始化数组元素 
        for (int i = 0; i < 900000; i++)
        {
            tst1[i] = String.valueOf(i);
        }
        ArrayList al = new ArrayList();
        //将所有数组元素加入ArrayList集合中 
        for (int i = 0; i < 900000 ; i++)
        {
            al.add(tst1[i]);
        }
        LinkedList ll = new LinkedList();
        //将所有数组元素加入LinkedList集合中 
        for (int i = 0; i < 900000 ; i++)
        {
            ll.add(tst1[i]);
        }
        //迭代访问ArrayList集合的所有元素，并输出迭代时间 
        long start = System.currentTimeMillis();
        for (Iterator it = al.iterator();it.hasNext() ; )
        {
            it.next();
        }
        System.out.println("迭代ArrayList集合元素的时间:" + (System.currentTimeMillis() - start));
        //迭代访问LinkedList集合的所有元素，并输出迭代时间 
        start = System.currentTimeMillis();
        for (Iterator it = ll.iterator();it.hasNext() ; )
        {
            it.next();
        }
        System.out.println("迭代LinkedList集合元素的时间:" + (System.currentTimeMillis() - start));
    }
}