集合框架的学习总结List，Set

来源：互联网发布：下载软件管家360 编辑：程序博客网时间：2024/05/09 16:20

List的基类接口是Collection,List集合有三个常见子类ArrayList ,LinkedList, Vector；

ArrayList底层的数据结构式数组结构。特点在于查询速度很快，线程不同步。

Vector底层的数据结构式数组结构。线程时安全的，出现在jdk1.2版本，增删改查速度都很慢，已被ArrayList替代。

LinkedList的底层的数据结构式链表结构。增加，修改，删除元素的速度也是很快的。

List集合特点是：元素时有序的，同时元素是可以重复的，因为该集合体系时有索引。

List集合中的特有方法

void add(int index, Ojbect b) 向指定集合的位置中添加添加元素；

void addAll(int index,Collection c) 向集合中添加集合c

void remove(int index) 删除集合指定位置处的元素

E get(int index) 获取指定位置处的元素

int indexOf(Object o) 返回集合中第一次出现该元素的索引下标

int lastIndexOf(Object o) 返回集合中最后一次出现该元素的索引下标，如果集合中没有出现该元素，那么返回-1；

E set(int index ,Object o) 用指定的元素替换集合指定位置的元素。

ListIterator listIterator() 返回集合中的一个迭代器。

通过上面的方法我们可以发现，List集合中都可以操作索引下标。

[java] view plaincopy
/* 
List接口中特有的方法 
增 
add(int index ,Object obj) 
addAll(Collection c) 
删 
remove(int index); 
removeAll(Collection c) 
改 
set(int index,Object obj) 
查 
get(int index); 
subList(int start,int from) 
listIterator(); 
 
*/  
import java.util.*;  
class JavaCollection1_2   
{  
    public static void main(String[] args)   
    {  
        //创建list接口下的一个子类ArrayList对象。  
        ArrayList al=new ArrayList();  
        al.add("java_1");  
        al.add("java_2");  
        al.add("java_3");  
        al.add("java_4");  
        sop("原集合："+al);  
        //1 在指定的位置添加元素  
        al.add(1,"java_5");  
        sop(al);  
        // 2删除指定位置的元素。  
        al.remove(3);  
        sop(al);  
        //3修改指定位置的元素。  
        al.set(0,"java_10");  
        sop(al);  
        //4获取所有的元素  
        //使用List集合的get()方法。使用角标进行遍历。  
        for(int i=0;i<al.size();i++)  
        {  
            sop("al("+i+")="+al.get(i));  
        }  
        //5使用迭代器  
        for(ListIterator lit=al.listIterator();lit.hasNext();)  
        {  
            sop(lit.next());  
        }  
  
    }  
    public static void sop(Object obj)  
    {  
        System.out.println(obj);  
    }  
}  

List集合中Vector的特性用法：

[java] view plaincopy
import java.util.*;  
/* 
ArrayList，LinkedList不支持枚举，统一使用迭代器。 
枚举就是Vector特有的取出方式。 
枚举和迭代的方式是类似的。 
因为枚举的方法名过长，因此被迭代器取代。 
*/  
class JavaCollection1_3   
{  
    public static void main(String[] args)   
    {  
        Vector v=new Vector();  
        v.add("java_1");  
        v.add("java_2");  
        v.add("java_3");  
        v.add("java_4");  
        Enumeration e=v.elements();//使用枚举。  
        while(e.hasMoreElements())  
        {  
            sop(e.nextElement());  
        }  
    }  
    public static void sop(Object obj)  
    {  
        System.out.println(obj);  
    }  
}  

List集合中LinkedList的特性用法：

[java] view plaincopy
/* 
LinkedList特有的方法： 
addFirst();向头部添加元素 
addLast();向尾部添加元素 
getFirst();获取LinkedList集合中头部的元素  
getLast();获取LinkedList集合中尾部的元素 
这里的getFirst()和getLast()方法都是获取元素，但是不删除元素。 
removeFirst(); 
removeLast(); 
这里的removeFirst和removeLast方法也可以获取元素，但是元素也同时被删除了 
 
注意事项； 
使用上面的方法，如果集合中没有元素，那么就会抛出NoSuchElementException异常 
在jdk1.6的版本中出现了替代了方法 
 
offerFirst() 
offerLast() 
 
peekFirst() 
peekLast() 
--获取元素，但是不删除元素，如果集合中没有该元素，那么就会返回null,不会抛出异常 
 
pollFirst() 
pollLast() 
--返回元素，并且也回删除元素，如果集合中没有该元素，那么也就返回Null，不会抛出异常 
*/  
import java.util.*;  
class JavaCollection1_4   
{  
    public static void main(String[] args)   
    {  
        LinkedList ll=new LinkedList();  
        ll.addFirst("java_1");  
        ll.addFirst("java_2");  
        ll.addFirst("java_3");  
        ll.addFirst("java_4");  
        sop(ll);  
        sop(ll.getFirst());  
        sop(ll.getLast());  
        //sop(ll.removeFirst());  
        //sop(ll.removeLast());  
        //sop(ll);  
  
        //不用迭代器使用removeFirst方法也可以取出LinkedList集合中的元素  
        while(!ll.isEmpty())  
        {  
            sop(ll.removeFirst());  
        }  
        sop("**************************");  
        method1();  
    }  
    public static void sop(Object obj)  
    {  
        System.out.println(obj);  
    }  
    public static void method1()  
    {  
        LinkedList ll=new LinkedList();  
        ll.offerFirst("java01");  
        ll.offerFirst("java02");  
        ll.offerLast("java03");  
        ll.offerLast("java04");  
        sop(ll);  
        sop(ll.peekFirst());  
        sop(ll.peekLast());  
        sop(ll.pollFirst());  
        sop(ll.pollLast());  
        sop(ll);  
    }  
}  

LinkedList练习：

[java] view plaincopy
/* 
使用一个LinkedList来简单的模拟堆栈数据结构。 
堆栈：先进后出 
队列：先进先出 
*/  
import java.util.*;  
class JavaCollection1_5   
{  
    public static void main(String[] args)   
    {  
        QueueDemo q=new QueueDemo();  
        q.add("java_1");  
        q.add("java_2");  
        q.add("java_3");  
        q.add("java_4");  
        //sop(q.get());  
        while(!q.Null())  
        {  
            sop(q.get());  
        }  
  
        StackDemo s=new StackDemo();  
        s.add("java_1");  
        s.add("java_2");  
        s.add("java_3");  
        s.add("java_4");  
        while(!s.Null())  
        {  
            sop(s.get());  
        }  
    }  
    public static void sop(Object obj)  
    {  
        System.out.println(obj);  
    }  
}  
/*模拟队列*/  
class QueueDemo  
{  
    private LinkedList link;  
    QueueDemo()  
    {  
        link=new LinkedList();  
    }  
    public void add(Object obj)  
    {  
        link.offerFirst(obj);  
    }  
    public Object get()  
    {  
         return link.pollLast();  
    }  
    public boolean Null()  
    {  
        return link.isEmpty();  
    }  
}  
/*模拟堆栈*/  
class StackDemo  
{  
    private LinkedList link;  
    StackDemo()  
    {  
        link=new LinkedList();  
    }  
    public void add(Object obj)  
    {  
        link.offerFirst(obj);  
    }  
    public Object get()  
    {  
         return link.pollFirst();  
    }  
    public boolean Null()  
    {  
        return link.isEmpty();  
    }   
}  

ArrayList集合练习：

[java] view plaincopy
/* 
去除ArrayList中重复的元素。 
思路： 
创建一个新的ArrayList，然后在遍历需要除重的老集合，然后在判断新集合中是否存在当前遍历的元素，如果不存在，就添加到新的集合中，如果存在，那么当前元素就不用添加到新集合中。 
遍历结束后，那么新集合就是去重后的集合 
*/  
import java.util.*;  
class JavaCollection1_6   
{  
    public static void main(String[] args)   
    {  
        ArrayList al=new ArrayList();  
        al.add(1);  
        al.add(2);  
        al.add(3);  
        al.add(4);  
        al.add(4);  
        al.add(3);  
        al.add(2);  
        List list=getSingleArrayList(al);  
        sop(list);  
    }  
    public static List getSingleArrayList(ArrayList al)  
    {  
         ArrayList temp_al=new ArrayList();  
        for(ListIterator it=al.listIterator();it.hasNext();)  
        {  
            Object obj=it.next();//注意在循环中it.next()只能使用一次，马上it.hasNext()判断一次，不然就有可能报异常。  
            if(!temp_al.contains(obj))//如果新集合中不存在该元素，那么便添加该元素。  
            {  
                temp_al.add(obj);  
            }  
        }  
        return temp_al;  
    }  
    public static void sop(Object obj)  
    {  
        System.out.println(obj);  
    }  
} 
 Set集合特点：
set集合中数据的存储和取出是无序的。而且元素时不可以重复；
set集合Collection功能是一样的。list有操作角标的特有方法。但是set集合没有特殊的特性方法。
set集合中常见的子类：
HashSet -----底层的数据结构式哈希表。
TreeSet------底层的数据结构式二叉树。
注：Hash表的特点，先比较对象的hash值，如果hash值不同，然后就根据hash值存储在hash表中，如果hash值相同，那么就会比较对象的equal()方法。如果equal()返回的也是true，那么向hash表中存储元素就会失败。
HashSet集合是如何在保证数据的唯一性的呢？
1主要是通过比较元素本身的hashcode值，
2如果hashcode值相同，那么就在比较元素的equal方法，主要元素的hash值不同，就不会比较equal方法，
如果两个条件中只要有一个不相同，那么元素就会存储成功。

0 0