JAVA中几种常见集合的使用实例

Java.util.ArrayList（类）：

import  java.awt. * ;
import  java.util. * ;
public   class  CollectionTest
{//List是一个能包含重复元素的已排序的Collection,有时list也称为序列，List第一个元素的下标为0 
     public String colors[]={"red","white","blue"};//定义一个字符数组

     //构造函数
     public CollectionTest()
     {
          ArrayList list=new ArrayList();//实例化一个ArrayList
          list.add(Color.magenta);//向里面添加一个元素，这里是颜色
          
          for(int count=;count<colors.length;count++)
              list.add(colors[count]);//加入开始声明的数组中的元素
          
          list.add(Color.cyan);     //颜色 导入awt包
          System.out.println("\nArrayList");
          for(int count=;count<list.size();count++)
             System.out.println(list.get(count)+" ");//从arrayList中读取 元素
          
          removeString(list);
          System.out.println("\n\nArrayList after calling"+"removeString:");
          for(int count=;count<list.size();count++)
                 System.out.println(list.get(count)+" ");
     }
     
     
        public void removeString(Collection collection)
        {
             Iterator itrator=collection.iterator();    //声明一个迭代
             //调用itrator的hasNext方法判断Collection是否还包含元素
             while(itrator.hasNext())
             {
                  //调用itrator的next方法得到下一个元素的引用
                  if( itrator.next() instanceof String ) // instanceof 判断是不是String 的实例
                        itrator.remove();    //若是是的 则删除
             }
        }
     
     public  static void main(String[] args)
     {
          new CollectionTest();
     }
     
}

该例示范了ArrayList的使用 先声明了一String类型的数组，里面存储了“颜色”，是用字符串写出的颜色，将这个字符串数组存入 ArrayList实例，同时还存入了awt包内的颜色实例，所有存入后利用迭代，删除不符要求的假数据，也就是咱们用字符串写的颜色，也用到了 instanceof 它是一个二元操做符，相似于equals用于判断instanceof左边 的对象 是不是 右边对象的实例，如果 返回真，这里 就能够判断 ArrayList里面的真假颜色，假颜色是 字符串的 实例，因此咱们经过迭代 一个个对比。只要是String的实例就将其从数组中删 除，因此最后 ArrayList里面仅仅剩下二个元素，运行效果以下：

 java.util.HashSet（类）;

// Set是包含独一无二元素的Collection，HashSet把它的元素存储在哈希表中，而TreeSet把它的元素存储在树中
import  java.util. * ;

public   class  SetTest
{
     private String colors[]={"orange","tan","orange","white",  "gray"};
     public SetTest()
     {
              ArrayList list;
              list=new ArrayList(Arrays.asList(colors));
              System.out.println("ArrayList:"+list);
              printNonDuplicates(list);  
     }
 
 
     public void printNonDuplicates(Collection collection)
     {
          //构造HashSet删除Collection中多余的元素
          HashSet set=new HashSet(collection);
          // 将coolection放入HashSet后即会消除重复元素          
          System.out.println("set："+set);

          Iterator itrator=set.iterator();
          System.out.println("\nNonDuplicates are:");
          while(itrator.hasNext())
          System.out.println(itrator.next()+" ");
          System.out.println();
     }
         
     public static void main(String[] args)
     {  
            new SetTest(); 
     }

}

能够看到重复元素 orange除去了

java.util.Set（接口）

import  java.util.HashSet;
import  java.util.Iterator;
import  java.util.Set;

class  TestSet 
{    
     public static void main(String args[])
     {
         Set set = new HashSet();
         set.add("aaa");
         set.add("bbb");
         set.add("aaa");//后面加入的重复性元素均无效
         set.add("bbb");
         set.add("aaa");
         set.add("bbb");
         set.add("aaa");
         set.add("bbb");
         set.add("aaa");
         set.add("bbb");
         Iterator ite=set.iterator();
         System.out.println(set.size());//the result is 2
         while(ite.hasNext())
         {
             System.out.println("----"+ite.next());
          }
     }
}

咱们看到效果

java.util.List（接口）

package  tt;

import  java.util.Arrays;
import  java.util.Collections;
import  java.util.Iterator;
import  java.util.LinkedList;
import  java.util.List;

public   class  ListTest  {

    public static void baseUse(){
            //链表实现
            List list = new LinkedList();
            //数组实现
            //List list = new ArrayList();
            list.add("a");//向列表的尾部追加"a"
            System.out.println("使用list接口的add()一个参数的方法："+list);
            list.add(,"b");//在指定位置插入"b"
            System.out.println("使用list接口的add二个参数的方法："+list);
            list.remove("a");//移除列表中"a"
            System.out.println("使用list接口的remove()方法删除a："+list);
     }    
      public static void useSort(){
            String[] strArray = new String[] {"z", "a", "c","C"};
            List list = Arrays.asList(strArray);
            System.out.println(list);
            Collections.sort(list);//根据元素天然顺序排序
            System.out.println("天然顺序："+list);
            Collections.sort(list, String.CASE_INSENSITIVE_ORDER);//根据指定的字母方式排序    
            System.out.println("指定字母方式："+list);
            Collections.sort(list, Collections.reverseOrder());//根据反转天然顺序方式排序
            System.out.println("反转天然顺序："+list);
            Collections.sort(list, String.CASE_INSENSITIVE_ORDER);
            System.out.println(list);
            Collections.reverse(list);//反转列表排序
            System.out.println(list);
      }
           
    public static void main(String[] args) {
    
        baseUse();
    //    useSort();
    }

}

运行
 

java.util.TreeSet（类）

package  tt;

import  java.util.Iterator;
import  java.util.TreeSet;

public   class  TreeSetTest  {
    
     public static void main(String args[]){
          TreeSet a = new TreeSet();
          a.add("1167014513046,hondanna_mousepress");
          a.add("1167014512046,hondanna_mousepress_usefull");
          a.add("1167014511046,hondanna_mousepress_num");
          a.add("1167014515437,hondanna_mousepress");
          a.add("1167014514438,hondanna_mousepress_usefull");
         Iterator iterator = a.iterator();
         while(iterator.hasNext())
             System.out.println(iterator.next());
         }
}

运行结果：

TreeSet为使用树来进行存储的Set接口提供了一个工具，对象按升序存储，访问和存储是很快的，在存储了大量的须要进行快速检索的排序信息的状况下，TreeSet是一个很好的选择。 构造函数定义为： TreeSet()－构造一个空的树集合，该树集合将根据其元素的天然顺序按升序排序。 TreeSet（Collection c）－构造了一个包含了c的元素的树的集合。 TreeSet（Comparator comp）－构造了一个空的树的集合，它按照由comp指定的比较函数进行排序。 TreeSet（SortedSet ss）－构造了一个包含ss的元素的树集合。