Cyh的博客

Email:kissyan4916@163.com
posts - 26, comments - 19, trackbacks - 0, articles - 220

ArrayList、Vector和LinkedList

Posted on 2009-05-30 23:55 啥都写点 阅读(673) 评论(0)  编辑  收藏 所属分类: J2SE
关键技术:
  • ArrayList是最常用的List实现类,内不是通过数组实现的,它允许对元素进行快速随机访问。数组的缺点是每个元素之间不能含有“空隙”,当数组大小不满足时需要增加存储能力,就要将已有数组数据复制到新的存储空间中。当从ArrayList的中间位置插入或者删除元素时,需要对数组进行复制、移动,代价比较高。因此,它适合随机查找和遍历,不适合插入和删除。
  • Vector与ArrayList一样,也是通过数组实现的,不同的是它支持线程的同步,即某一时刻只有一个线程能够Vector,避免多线程同时写而引起的不一致性,但实现同步需要很高的花费,因此,访问它比访问AarryList慢
  • LinkedList是用链表结构存储数据的,很适合数据的动态插入和删除,随机访问和遍历速度比较慢。另外,它还提供了List接口中没有定义的方法,专门用于操作表头和表尾元素,可以当做堆栈、队列和双向队列使用。

package book.arrayset;

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;

/**
 * 演示各种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();
        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());
        
        
/**
         * (1)ArrayList是最常用的List实现类,内部是通过数组实现的,它允许对元素进行快速随机访问。数组的缺点是每个元素之间不能含有“空隙”。
         * 当数组大小不满足时会增加存储能力,将已有数组数据复制到新的存储空间中。当从ArrayList的中间位置插入或者删除元素时,需要对数组进行拷贝,移动,代价比较高。因此,它适合随即查找和遍历,不适合插入合删除。
         * (2)Vector与ArrayList一样,也是通过数组实现的。不同的是它支持线程的同步,
         * 即一时刻只有一个线程能够写Vector,避免多线程同时写引起的不一致性。但实现同步需要很高的花费,
         * 因此,访问它比访问ArrayList慢。
         * (3)LinkedList是用链表结构存储数据的,很适合数据的动态插入和删除,随即访问和遍历速度比较慢。另外,它还提供了List没有定义的方法,专门用于操作表头和表尾元素,可以当作堆栈、队列和双向队列使用。
         * (4)因为ArrayList和Vector都是用数组实现的,所以,在添加和插入时,最好从表尾操作,而不要从中间或者表头开始,以避免数组移动引起的开销!
         * (5)可以为每个List生成ListIterator,支持双向遍历List,而且能够在ListIterator位置插入和删除元素。
         * (6)堆栈类继承Vector,它总是对列表的尾部数据进行操作,采用了先进后出的策略,自定义了插入、查看和弹出元素三个方法。
         
*/
    }
}



                                                                                                       --    学海无涯
        


只有注册用户登录后才能发表评论。


网站导航: