Java容器类的应用

一、实训目的

1）了解List、ArrayList、Vector及map、HashTable、HashMap的区别与用法;

2）掌握数组的排序方法;

二、实训要求

1. 深入认识Java容器类,并合理使用Java的容器。

2. 掌握Arrays提供的sort方法的使用.

三、实训内容

（一） 了解Java类库中提供的容器类

Vector 和ArrayList是采用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，都允许直接序号索引元素，但是插入数据要设计到数组元素移动等内存操作，所以索引数据快插入数据慢，Vector由于使用了synchronized方法（线程安全）所以性能上比ArrayList要差，LinkedList使用双向链表实现存储，按序号索引数据需要进行向前或向后遍历，但是插入数据时只需要记录本项的前后项即可，所以插入数度较快！

 

线性表，链表，哈希表是常用的数据结构，在进行Java开发时，JDK已经为我们提供了一系列相应的类来实现基本的数据结构。这些类均在java.util包中,其关系如下:

 

Collection

├List

│├LinkedList

│├ArrayList

│└Vector

│　└Stack

└Set

Map

├Hashtable

├HashMap

└WeakHashMap

 

1、Collection接口

　　Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。一些Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。

　　所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于创建一个空的Collection，有一个Collection参数的构造函数用于创建一个新的Collection，这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection。

　　如何遍历Collection中的每一个元素？不论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个迭代子，使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下：

　　　　Iterator it = collection.iterator(); //获得一个迭代子

　　　　while(it.hasNext()) {

　　　　　　Object obj = it.next(); //得到下一个元素

　　　　}

　　由Collection接口派生的两个接口是List和Set。

 

2、List接口

　　List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。和下面要提到的Set不同，List允许有相同的元素。

　　除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素，还能向前或向后遍历。

　　实现List接口的常用类有LinkedList，ArrayList，Vector和Stack。

 

3、LinkedList类

　　LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert方法在LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。

　　注意LinkedList没有同步方法。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：

　　　　List list = Collections.synchronizedList(new LinkedList(...));

 

4、ArrayList类

　　ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。

size，isEmpty，get，set方法运行时间为常数。但是add方法开销为分摊的常数，添加n个元素需要O(n)的时间。其他的方法运行时间为线性。

　　每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。和LinkedList一样，ArrayList也是非同步的（unsynchronized）。

 

5、Vector类

　　Vector非常类似ArrayList，但是Vector是同步的。由Vector创建的Iterator，虽然和ArrayList创建的Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出ConcurrentModificationException，因此必须捕获该异常。

 

6、Stack类

　　Stack继承自Vector，实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop方法，还有peek方法得到栈顶的元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。

 

7、Set接口

　　Set是一种不包含重复的元素的Collection，即任意的两个元素e1和e2都有e1.equals(e2)=false，Set最多有一个null元素。

　　很明显，Set的构造函数有一个约束条件，传入的Collection参数不能包含重复的元素。

　　请注意：必须小心操作可变对象（Mutable Object）。如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true将导致一些问题。

 

8、Map接口

　　请注意，Map没有继承Collection接口，Map提供key到value的映射。一个Map中不能包含相同的key，每个key只能映射一个value。Map接口提供3种集合的视图，Map的内容可以被当作一组key集合，一组value集合，或者一组key-value映射。

 

9、Hashtable类

　　Hashtable继承Map接口，实现一个key-value映射的哈希表。任何非空（non-null）的对象都可作为key或者value。

　　添加数据使用put(key, value)，取出数据使用get(key)，这两个基本操作的时间开销为常数。

Hashtable通过initial capacity和load factor两个参数调整性能。通常缺省的load factor 0.75较好地实现了时间和空间的均衡。增大load factor可以节省空间但相应的查找时间将增大，这会影响像get和put这样的操作。

使用Hashtable的简单示例如下，将1，2，3放到Hashtable中，他们的key分别是”one”，”two”，”three”：

　　　　Hashtable numbers = new Hashtable();

　　　　numbers.put(“one”, new Integer(1));

　　　　numbers.put(“two”, new Integer(2));

　　　　numbers.put(“three”, new Integer(3));

　　要取出一个数，比如2，用相应的key：

　　　　Integer n = (Integer)numbers.get(“two”);

　　　　System.out.println(“two =” + n);

　　由于作为key的对象将通过计算其散列函数来确定与之对应的value的位置，因此任何作为key的对象都必须实现hashCode和equals方法。hashCode和equals方法继承自根类Object，如果你用自定义的类当作key的话，要相当小心，按照散列函数的定义，如果两个对象相同，即obj1.equals(obj2)=true，则它们的hashCode必须相同，但如果两个对象不同，则它们的hashCode不一定不同，如果两个不同对象的hashCode相同，这种现象称为冲突，冲突会导致操作哈希表的时间开销增大，所以尽量定义好的hashCode()方法，能加快哈希表的操作。

　　如果相同的对象有不同的hashCode，对哈希表的操作会出现意想不到的结果（期待的get方法返回null），要避免这种问题，只需要牢记一条：要同时复写equals方法和hashCode方法，而不要只写其中一个。

　　Hashtable是同步的。

 

10、HashMap类

　　HashMap和Hashtable类似，不同之处在于HashMap是非同步的，并且允许null，即null value和null key。，但是将HashMap视为Collection时（values()方法可返回Collection），其迭代子操作时间开销和HashMap的容量成比例。因此，如果迭代操作的性能相当重要的话，不要将HashMap的初始化容量设得过高，或者load factor过低。

 

11、WeakHashMap类

　　WeakHashMap是一种改进的HashMap，它对key实行“弱引用”，如果一个key不再被外部所引用，那么该key可以被GC回收。

 

小结

　　如果涉及到堆栈，队列等操作，应该考虑用List，对于需要快速插入，删除元素，应该使用LinkedList，如果需要快速随机访问元素，应该使用ArrayList。

　　如果程序在单线程环境中，或者访问仅仅在一个线程中进行，考虑非同步的类，其效率较高，如果多个线程可能同时操作一个类，应该使用同步的类。

　　要特别注意对哈希表的操作，作为key的对象要正确复写equals和hashCode方法。

　　尽量返回接口而非实际的类型，如返回List而非ArrayList，这样如果以后需要将ArrayList换成LinkedList时，客户端代码不用改变。这就是针对抽象编程。

 

（二）数组的排序

1.  数组的基本特性

    数组与其它种类的容器(List/Set/Map)之间的区别在于效率、确定的类型和保存基本类型数据的能力。数组是一种高效的存储和随机访问对象引用序列的方式，使用数组可以快速的访问数组中的元素。但是当创建一个数组对象(注意和对象数组的区别)后，数组的大小也就固定了，当数组空间不足的时候就再创建一个新的数组，把旧的数组中所有的引用复制到新的数组中。

Java中的数组和容器都需要进行边界检查，如果越界就会得到一个RuntimeException异常。

Java中通用的容器类不会以具体的类型来处理对象，容器中的对象都是以Object类型处理的，这是Java中所有类的基类。另外，数组可以保存基本类型，而容器不能，它只能保存任意的Java对象。

一般情况下，考虑到效率与类型检查，应该尽可能考虑使用数组。如果要解决一般化的问题，数组可能会受到一些限制，这时可以使用Java提供的容器类。

 

2.  操作数组的实用功能

         在java.util.Arrays类中，有许多static静态方法，提供了操作数组的一些基本功能：

         equals()方法----用于比较两个数组是否相等，相等的条件是两个数组的元素个数必须相等，并且对应位置的元素也相等。

         fill()方法----用以某个值填充整个数组，这个方法有点笨。

         asList()方法----接受任意的数组为参数，将其转变为List容器。

         binarySearch()方法----用于在已经排序的数组中查找元素，需要注意的是必须是已经排序过的数组。当Arrays.binarySearch()找到了查找目标时，该方法将返回一个等于或大于0的值，否则将返回一个负值，表示在该数组目前的排序状态下此目标元素所应该插入的位置。负值的计算公式是“-x-1”。x指的是第一个大于查找对象的元素在数组中的位置，如果数组中所有的元素都小于要查找的对象，则x = a.size()。如果数组中包含重复的元素，则无法保证找到的是哪一个元素，如果需要对没有重复元素的数组排序，可以使用TreeSet或者LinkedHashSet。另外，如果使用Comparator排序了某个对象数组，在使用该方法时必须提供同样的Comparator类型的参数。需要注意的是，基本类型数组无法使用Comparator进行排序。

         sort()方法----对数组进行升序排序。

         在Java标准类库中，另有static方法System.arraycopy()用来复制数组，它针对所有类型做了重载。

3.  数组的排序

    在Java1.0和1.1两个版本中，类库缺少基本的算法操作，包括排序的操作，Java2对此进行了改善。在进行排序的操作时，需要根据对象的实际类型执行比较操作，如果为每种不同的类型各自编写一个不同的排序方法，将会使得代码很难被复用。一般的程序设计目标应是“将保持不变的事物与会发改变的事物相分离”。在这里，不变的是通用的排序算法，变化的是各种对象相互比较的方式。

Java有两种方式来实现比较的功能，一种是实现java.lang.Comparable接口，该接口只有一个compareTo()方法，并以一个Object类为参数，如果当前对象小于参数则返回负值，如果相等返回零，如果当前对象大于参数则返回正值。另一种比较方法是采用策略(strategy)设计模式，将会发生变化的代码封装在它自己的类(策略对象)中，再将策略对象交给保持不变的代码中，后者使用此策略实现它的算法。因此，可以为不同的比较方式生成不同的对象，将它们用在同样的排序程序中。在此情况下，通过定义一个实现了Comparator接口的类而创建了一个策略，这个策略类有compare()和equals()两个方法，一般情况下实现compare()方法即可。

使用上述两种方法即可对任意基本类型的数组进行排序，也可以对任意的对象数组进行排序。再提示一遍，基本类型数组无法使用Comparator进行排序。

第1中排序的实例，注意实现Comparable接口

public class Student implements Comparable{

       private String name=null;

       private String sex=null;

       private int age=0;

       public Student(){}

       public Student(String name,String sex,int age){

              this.name=name;

              this.sex=sex;

              this.age=age;

       }

//以下代码是实现Comparable接口的compareTo方法

       public int compareTo(Object o){

             if(!(o instanceof Student))return -1;

             Student s=(Student)o;

             if(age>s.getAge())return -1;

             else if(age<s.getAge())return 1;

             return 0;

      }

       public String getName() {

              return name;

       }

       public void setName(String name) {

              this.name = name;

       }

       public String getSex() {

              return sex;

       }

       public void setSex(String sex) {

              this.sex = sex;

       }

       public int getAge() {

              return age;

       }

       public void setAge(int age) {

              this.age = age;

       }

 

}

 

 

//运行代码类

import java.util.*;

public class Sort_Demo {

 

       public static void main(String[] args) {

              Vector<Student> sv=new Vector<Student>();

        for(int i=0;i<10;i++){

               sv.add(new Student("aaa"+i,i%2==0?"男":"女",i+10));

        }

        Object[] students=sv.toArray();

        Arrays.sort(students);       

      for(int i=0;i<students.length;i++)

             System.out.println(((Student)students[i]).getName()+" "+((Student)students[i]).getSex()+" "+((Student)students[i]).getAge());       

       }

}

 

第2种排序的实例：

//创建一个对象类Student

public class Student {

       private String name=null;

       private String sex=null;

       private int age=0;

       public Student(){}

       public Student(String name,String sex,int age){

              this.name=name;

              this.sex=sex;

              this.age=age;

       }

       public String getName() {

              return name;

       }

       public void setName(String name) {

              this.name = name;

       }

       public String getSex() {

              return sex;

       }

       public void setSex(String sex) {

              this.sex = sex;

       }

       public int getAge() {

              return age;

       }

       public void setAge(int age) {

              this.age = age;

       }

 

}

 

 

//创建一个使用排序的运行代码类

import java.util.*;

public class Sort_Demo {

 

       public static void main(String[] args) {

              Vector<Student> sv=new Vector<Student>();//创建一个Vector容器

        for(int i=0;i<10;i++){//创建十个Studnet对象，并添加到Vector中

               sv.add(new Student("aaa"+i,i%2==0?"男":"女",i+10));

        }

        Object[] students=sv.toArray();//从容器中获得一个Object数组

       //下面有颜色文字代码为一个实现Comparator接口的匿名类,实现对对象的比较

        Arrays.sort(students,new Comparator(){

         public int compare(Object o1,Object o2){

                Student s1=null,s2=null;              

                if(o1 instanceof Student && o2 instanceof Student){

                   s1=(Student)o1;

                   s2=(Student)o2;

                }

                if(s1==null)return 1;

                if(s2==null) return -1;                 

                if(s1.getAge()>s2.getAge())return -1;

                else if(s1.getAge()<s2.getAge())return 1;

                return 0;

         }

       });//修改返回值可以进行升降控制

      for(int i=0;i<students.length;i++)

             System.out.println(((Student)students[i]).getName()+" "+((Student)students[i]).getSex()+" "+((Student)students[i]).getAge());

       

       }

 

}

（三）完成测试试题

  题目：多关键词排序问题

    学生考试成绩的统计利用计算机软件将变得十份简单的事，如果一个年级的学生参加了有语文、数学和英语三科目的考试，需要计算出每个学生的总分和平均成绩，并且要按照总分排序，如果总分相同，则依照语文、数学再英语的成绩排序，即排序关键词依次为总分、语文、数学、英语。请你设计一个程序解决该问题。

标准输入：

   第一行为一个正整数N，表示该年纪共有的学生数，接下来的N行，每行为一个学生的信息，依次为学号、班级、语文成绩、数学成绩和英语成绩，其中学号为10个字符的字符串，班级和成绩为正整数，他们之间由一个空格隔开。

标准输出：

   输出该年级学生的成绩单，即根据总分和语文、数学、英语成绩为次关键词的排序后的成绩单，每行输出一个学生的成绩，使用一个空格隔开，依次输出如下数据：

学号班级语文数学英语总分平均

其中平均成绩四舍五入保留2位小数。

测试用例输入：

4

0806401001    1     56    64    77

0806401002    1     75    68    54

0806401003    1     68    79    76

0806401004    1     56    57    84

测试用例输出：

0806401003 1 68 79 76 223 74.33

0806401002 1 75 68 54 197 65.67

0806401001 1 56 64 77 197 65.67

0806401004 1 56 57 84 197 65.67

附录：同步性问题

Vector是同步的。这个类中的一些方法保证了Vector中的对象是线程安全的。而ArrayList则是异步的，因此ArrayList中的对象并不是线程安全的。因为同步的要求会影响执行的效率，所以如果你不需要线程安全的集合那么使用ArrayList是一个很好的选择，这样可以避免由于同步带来的不必要的性能开销。

数据增长

从内部实现机制来讲ArrayList和Vector都是使用数组(Array)来控制集合中的对象。当你向这两种类型中增加元素的时候，如果元素的数目超出了内部数组目前的长度它们都需要扩展内部数组的长度，Vector缺省情况下自动增长原来一倍的数组长度，ArrayList是原来的50%,所以最后你获得的这个集合所占的空间总是比你实际需要的要大。所以如果你要在集合中保存大量的数据那么使用Vector有一些优势，因为你可以通过设置集合的初始化大小来避免不必要的资源开销。

使用模式

在ArrayList和Vector中，从一个指定的位置（通过索引）查找数据或是在集合的末尾增加、移除一个元素所花费的时间是一样的，这个时间我们用O(1)表示。但是，如果在集合的其他位置增加或移除元素那么花费的时间会呈线形增长：O(n-i)，其中n代表集合中元素的个数，i代表元素增加或移除元素的索引位置。为什么会这样呢？以为在进行上述操作的时候集合中第i和第i个元素之后的所有元素都要执行位移的操作。这一切意味着什么呢？

这意味着，你只是查找特定位置的元素或只在集合的末端增加、移除元素，那么使用Vector或ArrayList都可以。如果是其他操作，你最好选择其他的集合操作类。比如，LinkList集合类在增加或移除集合中任何位置的元素所花费的时间都是一样的?O(1)，但它在索引一个元素的使用缺比较慢－O(i),其中i是索引的位置.使用ArrayList也很容易，因为你可以简单的使用索引来代替创建iterator对象的操作。LinkList也会为每个插入的元素创建对象，所有你要明白它也会带来额外的开销。

import java.io.*;

import java.text.DecimalFormat;

import java.util.StringTokenizer;

class student

{

 String id;

 int classnum,yw,sx,yy,total;

 double ave;

 student(String s)  //构造函数，给成员赋值

 {

        StringTokenizer st=new StringTokenizer(s);//默认以空格隔开

        this.id=st.nextToken();  //st.nextToken()读取的就是一个字符串

        this.classnum=Integer.parseInt(st.nextToken()); //将字符串转换成整型

          this.yw=Integer.parseInt(st.nextToken());

          this.sx=Integer.parseInt(st.nextToken());

          this.yy=Integer.parseInt(st.nextToken());

          total=yw+sx+yy;

          ave=(double)total/(double)3;

        

        

 }

};

public class Main214

{

        public static void main(String args[])throws Exception

        {

                BufferedReader bin=new BufferedReader(new InputStreamReader

                  (System.in));

                int n,i,j,t;

                DecimalFormat f=new DecimalFormat("0.00");  //doubel精度，0.00表示保留2位小数

                n=Integer.parseInt(bin.readLine());

                student a[],temp;  //定义对象数组

                a=new student[n+1];

                String line;

                for(i=0;i<n;i++)

                {

                 line=bin.readLine(); //读入每行数据

                 a[i]=new student(line); //调用构造函数，将数据赋给a[i]，line为参数

                }

                for(i=0;i<n-1;i++)

                       for(j=0;j<n-1-i;j++)

                              if(!compare(a[j],a[j+1]))

                              {

                                     temp=a[j];

                                     a[j]=a[j+1];

                                     a[j+1]=temp;

                              }

                for(i=0;i<n;i++)

                       System.out.println(a[i].id+" "+a[i].classnum+" "+a[i].yw+" "+a[i].sx+" "+a[i].yy

                                     +" "+a[i].total+" "+f.format(a[i].ave));

                                

        }

 public static boolean compare(student a,student b)

 {//a>b返回 true else false;

     if(a.total>b.total) return true;

     else if(a.total<b.total)return false;

     else

     {

       if(a.yw >b.yw)return true;

          else if(a.yw <b.yw)return false;

          else

          {

                 if(a.sx>b.sx)return true;

                // else return false; 

                 else if(a.sx<b.sx) return false;

                 else

                 {

                        if(a.yy>b.yy) return true;

                        else return false;

                 }

          }

    }

 }

}