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 = 0 ;count < colors.length;count ++ )
              list.add(colors[count]); // 加入开始声明的数组中的元素
          
          list.add(Color.cyan);      // 颜色　　导入awt包
          System.out.println( " \nArrayList " );
           for ( int  count = 0 ;count < list.size();count ++ )
             System.out.println(list.get(count) + "   " ); // 从arrayList中读取　元素
          
          removeString(list);
          System.out.println( " \n\nArrayList after calling " + " removeString: " );
           for ( int  count = 0 ;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（类）;

可以看到重复元素 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( 0 , " 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();
    }

}

运行
 

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的元素的树集合。

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

public   class  SetTest
{
      private  String colors[] = { " orange " , " tan " , " orange " , " white " ,   " gray " } ;
      public  SetTest()
      {
              ArrayList list;
  

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