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

最新推荐文章于 2025-04-19 20:58:00 发布

原创最新推荐文章于 2025-04-19 20:58:00 发布 · 366 阅读

0 ·

CC 4.0 BY-SA版权

本文深入探讨Java集合框架中的List、Vector、LinkedList等集合类型的特点、用法及特有方法，包括添加、删除、修改、查找等操作，并通过代码实例展示了如何在实际场景中灵活运用这些集合类型。

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方法，
 如果两个条件中只要有一个不相同，那么元素就会存储成功。