实验十一集合

实验时间 2018-11-8

1、实验目的与要求

(1) 掌握Vetor、Stack、Hashtable三个类的用途及常用API；

(2) 了解java集合框架体系组成；

(3) 掌握ArrayList、LinkList两个类的用途及常用API。

(4) 了解HashSet类、TreeSet类的用途及常用API。

(5)了解HashMap、TreeMap两个类的用途及常用API；

(6) 结对编程（Pair programming）练习，体验程序开发中的两人合作。

2、实验内容和步骤

实验1：导入第9章示例程序，测试程序并进行代码注释。

测试程序1：

l 使用JDK命令运行编辑、运行以下三个示例程序，结合运行结果理解程序；

l 掌握Vetor、Stack、Hashtable三个类的用途及常用API。

//示例程序1

import java.util.Vector;

class Cat {

private int catNumber;

Cat(int i) {

catNumber = i;

}

void print() {

System.out.println("Cat #" + catNumber);

}

class Dog {

private int dogNumber;

Dog(int i) {

dogNumber = i;

}

void print() {

System.out.println("Dog #" + dogNumber);

}

public class CatsAndDogs {

public static void main(String[] args) {

Vector cats = new Vector();

for (int i = 0; i < 7; i++)

cats.addElement(new Cat(i));

cats.addElement(new Dog(7));

for (int i = 0; i < cats.size(); i++)

((Cat) cats.elementAt(i)).print();

}

//示例程序2

import java.util.*;

public class Stacks {

static String[] months = { "1", "2", "3", "4" };

public static void main(String[] args) {

Stack stk = new Stack();

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

stk.push(months[i]);

System.out.println(stk);

System.out.println("element 2=" + stk.elementAt(2));

while (!stk.empty())

System.out.println(stk.pop());

}

//示例程序3

import java.util.*;

class Counter {

int i = 1;

public String toString() {

return Integer.toString(i);

}

public class Statistics {

public static void main(String[] args) {

Hashtable ht = new Hashtable();

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

Integer r = new Integer((int) (Math.random() * 20));

if (ht.containsKey(r))

((Counter) ht.get(r)).i++;

else

ht.put(r, new Counter());

}

System.out.println(ht);

}

对实例程序1的运行结果如下所示：

该运行结果说明此程序存在运行异常，不能进行将至类型转换，将会在下面对该程序进一步改正之后再运行程序

修改后的代码如下所示

import java.util.Vector;

class Cat {
    private int catNumber;

    Cat(int i) {
        catNumber = i;
    }

    void print() {
        System.out.println("Cat #" + catNumber);
    }
}

class Dog {
    private int dogNumber;

    Dog(int i) {
        dogNumber = i;
    }

    void print() {
        System.out.println("Dog #" + dogNumber);
    }
}

public class CatsAndDogs {
    public static void main(String[] args) {
       Vector cats = new Vector();
        for (int i = 0; i < 7; i++)
        cats.addElement(new Cat(i));
        cats.addElement(new Dog(7));
        for (int i = 0; i < cats.size(); i++) {
            if (cats.elementAt(i) instanceof Cat) {
            ((Cat) cats.elementAt(i)).print();
        }
            else {
                ((Dog) cats.elementAt(i)).print();
            }
                
            }
    }
}

修改之后的，对程序的运行结果如下图所示

实例2的测试程序测试结果如下所示：

此程序是对栈的一个构建

对测试程序3的理解结果

随机数生成的数据具有随机的一个特征，这个表当中存储的数据具有渐值对。

测试程序2：

使用JDK命令编辑运行ArrayListDemo和LinkedListDemo两个程序，结合程序运行结果理解程序；

import java.util.*;

public class ArrayListDemo {

public static void main(String[] argv) {

ArrayList al = new ArrayList();

// Add lots of elements to the ArrayList...

al.add(new Integer(11));

al.add(new Integer(12));

al.add(new Integer(13));

al.add(new String("hello"));

// First print them out using a for loop.

System.out.println("Retrieving by index:");

for (int i = 0; i < al.size(); i++) {

System.out.println("Element " + i + " = " + al.get(i));

}

import java.util.*;

public class LinkedListDemo {

public static void main(String[] argv) {

LinkedList l = new LinkedList();

l.add(new Object());

l.add("Hello");

l.add("zhangsan");

ListIterator li = l.listIterator(0);

while (li.hasNext())

System.out.println(li.next());

if (l.indexOf("Hello") < 0)

System.err.println("Lookup does not work");

else

System.err.println("Lookup works");

}

在Elipse环境下编辑运行调试教材360页程序9-1，结合程序运行结果理解程序；

掌握ArrayList、LinkList两个类的用途及常用API。

对第一个程序的注释

import java.util.*;

public class ArrayListDemo {
    public static void main(String[] argv) {
        ArrayList al = new ArrayList();
        // 向ArrayList添加很多元素…
        al.add(new Integer(11));
        al.add(new Integer(12));
        al.add(new Integer(13));
        al.add(new String("hello"));
        // 首先使用for循环将它们打印出来。
        System.out.println("Retrieving by index:");
        for (int i = 0; i < al.size(); i++) {
            System.out.println("Element " + i + " = " + al.get(i));
        }
    }
}

对第一个程序测试结果的显示结果如下：

添加一个输出一个集合对象的结果：

对第二个测试程序的结果如下所示：

编辑运行调试教材360页程序9-1,对程序运行的结果如下：

对程序源代码的注释如下

package linkedList;

import java.util.*;

/**
 * This program demonstrates operations on linked lists.
 * @version 1.11 2012-01-26
 * @author Cay Horstmann
 */
public class LinkedListTest
{
   public static void main(String[] args)
   {
      List<String> a = new LinkedList<>();
      a.add("Amy");
      a.add("Carl");
      a.add("Erica");

      List<String> b = new LinkedList<>();
      b.add("Bob");
      b.add("Doug");
      b.add("Frances");
      b.add("Gloria");

      // 把单词从b合并到a

      ListIterator<String> aIter = a.listIterator();
      Iterator<String> bIter = b.iterator();

      while (bIter.hasNext())
      {
         if (aIter.hasNext()) aIter.next();
         aIter.add(bIter.next());
      }

      System.out.println(a);

      //从b中删除每一个单词

      bIter = b.iterator();
      while (bIter.hasNext())
      {
         bIter.next(); //跳过一个元素
         if (bIter.hasNext())
         {
            bIter.next(); // 跳过下一个元素
            bIter.remove(); // 删除该元素
         }
      }

      System.out.println(b);

      // 批量操作:将b中的所有单词从a中删除

      a.removeAll(b);

      System.out.println(a);
   }
}

测试程序3：

l 运行SetDemo程序，结合运行结果理解程序；

import java.util.*;

public class SetDemo {

public static void main(String[] argv) {

HashSet h = new HashSet(); //也可以 Set h=new HashSet()

h.add("One");

h.add("Two");

h.add("One"); // DUPLICATE

h.add("Three");

Iterator it = h.iterator();

while (it.hasNext()) {

System.out.println(it.next());

}

l 在Elipse环境下调试教材365页程序9-2，结合运行结果理解程序；了解HashSet类的用途及常用API。

l 在Elipse环境下调试教材367页-368程序9-3、9-4，结合程序运行结果理解程序；了解TreeSet类的用途及常用API。

对SetDom的运行结果如下：

调试教材365页程序9-2

调试教材367页-368程序9-3、9-4

测试结果如下所示

测试程序4：

l 使用JDK命令运行HashMapDemo程序，结合程序运行结果理解程序；

import java.util.*;

public class HashMapDemo {

public static void main(String[] argv) {

HashMap h = new HashMap();

// The hash maps from company name to address.

h.put("Adobe", "Mountain View, CA");

h.put("IBM", "White Plains, NY");

h.put("Sun", "Mountain View, CA");

String queryString = "Adobe";

String resultString = (String)h.get(queryString);

System.out.println("They are located in: " + resultString);

}

l 在Elipse环境下调试教材373页程序9-6，结合程序运行结果理解程序；

l 了解HashMap、TreeMap两个类的用途及常用API。】

对HashMap程序的运行结果如下所示:

实验2：结对编程练习：

l 关于结对编程：以下图片是一个结对编程场景：两位学习伙伴坐在一起，面对着同一台显示器，使用着同一键盘，同一个鼠标，他们一起思考问题，一起分析问题，一起编写程序。

l 关于结对编程的阐述可参见以下链接：

http://www.cnblogs.com/xinz/archive/2011/08/07/2130332.html

http://en.wikipedia.org/wiki/Pair_programming

l 对于结对编程中代码设计规范的要求参考：

http://www.cnblogs.com/xinz/archive/2011/11/20/2255971.html

以下实验，就让我们来体验一下结对编程的魅力。

确定本次实验结对编程合作伙伴；

合作伙伴：苏浪浪

各自运行合作伙伴实验九编程练习1，结合使用体验对所运行程序提出完善建议；

苏浪浪编程练习1的代码

package aaa;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;

public class b{
    private static ArrayList<Student> studentlist;
    public static void main(String[] args) {
        studentlist = new ArrayList<>();
        Scanner scanner = new Scanner(System.in);
        File file = new File("身份证号.txt");//文件的导入模块
        try {
            FileInputStream fis = new FileInputStream(file);
            BufferedReader in = new BufferedReader(new InputStreamReader(fis));
            String temp = null;
            while ((temp = in.readLine()) != null) {
                
                Scanner linescanner = new Scanner(temp);
                
                linescanner.useDelimiter(" ");    
                String name = linescanner.next();
                String number = linescanner.next();
                String sex = linescanner.next();
                String age = linescanner.next();
                String province =linescanner.nextLine();
                Student student = new Student();
                student.setName(name);
                student.setnumber(number);
                student.setsex(sex);
                int a = Integer.parseInt(age);
                student.setage(a);
                student.setprovince(province);
                studentlist.add(student);

            }
        } catch (FileNotFoundException e) {
            System.out.println("学生信息文件找不到");
            e.printStackTrace();
        } catch (IOException e) {
            System.out.println("学生信息文件读取错误");
            e.printStackTrace();
        }
        boolean isTrue = true;
        while (isTrue) {   //选择模块
            System.out.println("选择你的操作， ");
            System.out.println("1.字典排序  ");
            System.out.println("2.输出年龄最大和年龄最小的人  ");
            System.out.println("3.寻找老乡  ");
            System.out.println("4.寻找年龄相近的人  ");
            System.out.println("5.退出 ");
            String m = scanner.next();
            switch (m) {
            case "1":
                Collections.sort(studentlist);              
                System.out.println(studentlist.toString());
                break;
            case "2":
                 int max=0,min=100;
                 int j,k1 = 0,k2=0;
                 for(int i=1;i<studentlist.size();i++)
                 {
                     j=studentlist.get(i).getage();
                 if(j>max)
                 {
                     max=j; 
                     k1=i;
                 }
                 if(j<min)
                 {
                   min=j; 
                   k2=i;
                 }
                 
                 }  
                 System.out.println("年龄最大："+studentlist.get(k1));
                 System.out.println("年龄最小："+studentlist.get(k2));
                break;
            case "3":
                 System.out.println("地址?");
                 String find = scanner.next();        
                 String place=find.substring(0,3);
                 for (int i = 0; i <studentlist.size(); i++) 
                 {
                     if(studentlist.get(i).getprovince().substring(1,4).equals(place)) 
                         System.out.println("老乡"+studentlist.get(i));
                 }             
                 break;
                 
            case "4":
                System.out.println("年龄：");
                int yourage = scanner.nextInt();
                int near=agenear(yourage);
                int value=yourage-studentlist.get(near).getage();
                System.out.println(""+studentlist.get(near));
                break;
            case "5 ":
                isTrue = false;
                System.out.println("退出程序!");
                break;
                default:
                System.out.println("输入有误");

            }
        }
    }
        public static int agenear(int age) {      
        int j=0,min=53,value=0,ok=0;
         for (int i = 0; i < studentlist.size(); i++)
         {
             value=studentlist.get(i).getage()-age;
             if(value<0) value=-value; 
             if (value<min) 
             {
                min=value;
                 ok=i;
             } 
          }    
         return ok;         
      }
}

package aaa;

public class Student implements Comparable<Student> {//接口模块

    private String name;
    private String number ;
    private String sex ;
    private int age;
    private String province;
   
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getnumber() {
        return number;
    }
    public void setnumber(String number) {
        this.number = number;
    }
    public String getsex() {
        return sex ;
    }
    public void setsex(String sex ) {
        this.sex =sex ;
    }
    public int getage() {

        return age;
        }
        public void setage(int age) {
            // int a = Integer.parseInt(age);
        this.age= age;
        }

    public String getprovince() {
        return province;
    }
    public void setprovince(String province) {
        this.province=province ;
    }

    public int compareTo(Student o) {
       return this.name.compareTo(o.getName());
    }

    public String toString() {
        return  name+"	"+sex+"	"+age+"	"+number+"	"+province+"
";
    }    
}

完善建议：

接口的定义的代码稍作修改，尽量简化代码，使实验简单

各自运行合作伙伴实验十编程练习2，结合使用体验对所运行程序提出完善建议；

苏浪浪编程练习2的代码;

package duanyan;
  import java.io.FileNotFoundException;
  import java.io.PrintWriter;
  import java.util.Scanner;
  public class z {
      public static void main(String[] args) {
  
         Scanner in = new Scanner(System.in);
         Student student=new Student();
         PrintWriter out = null;
         try {
            out = new PrintWriter("text.txt");//保存文件模块
        } catch (FileNotFoundException e) {
             e.printStackTrace();
         }
         int sum = 0;
 
         
         //随机生成a、b的值以及随机的运算模块
         for (int i = 1; i <=10; i++) {
             int a = (int) Math.round(Math.random() * 100);
             int b = (int) Math.round(Math.random() * 100);
            int c= (int) Math.round(Math.random() * 3);
 
             
            switch(c)
            {
            case 0:
                System.out.println(i+": "+a+"/"+b+"=");
                
                while(b==0)
                { 
                    b = (int) Math.round(Math.random() * 100);
             }
                
            int C = in.nextInt();
            out.println(a+"/"+b+"="+C);
            if (C == student.d(a, b)) {
                 sum += 10;
                 System.out.println("恭喜答案正确");
             }
             else {
                System.out.println("抱歉，答案错误");
           }
             
             break;
            
           case 1:
               System.out.println(i+": "+a+"*"+b+"=");
                int D = in.nextInt();
                out.println(a+"*"+b+"="+D);
                if (D == student.m(a, b)) {
                   sum += 10;
                    System.out.println("恭喜答案正确");
               }
               else {
                    System.out.println("抱歉，答案错误");
                }
               break;
            case 2:
                System.out.println(i+": "+a+"+"+b+"=");
                while(a<b)
                { 
                    a = (int) Math.round(Math.random() * 100);
             }
                int E = in.nextInt();
               out.println(a+"+"+b+"="+E);
               if (E == student.add(a, b)) {
                   sum += 10;
                    System.out.println("恭喜答案正确");
                }
                else {                    System.out.println("抱歉，答案错误");
                }
                
                break ;
           case 3:
               System.out.println(i+": "+a+"-"+b+"=");
               int F = in.nextInt();
                out.println(a+"-"+b+"="+F);
                if (F == student.r(a, b)) {              
                    sum += 10;
                    System.out.println("恭喜答案正确");
                }
                else {
                    System.out.println("抱歉，答案错误");
                }
                break ;
               } 
           }
        System.out.println("成绩"+sum);
         out.println("成绩:"+sum);
          out.close();       
   }  
   }

View Code

package duanyan;
public class Student {
       private int a;
       private int b;
        public int  add(int a,int b)
        {
            return a+b;
        }
        public int   reduce(int a,int b)
        {
            return a-b;
        }
        public int   multiplication(int a,int b)
        {
            return a*b;
        }
        public int   division(int a,int b)
        {
            if(b!=0)
            return a/b;
            else return 0;
        }

    }

View Code

完善建议：

在做除法运算时应该带程序的代码加以修改，尽量考虑到除法的分母不能等于0

采用结对编程方式，与学习伙伴合作完成实验九编程练习1；

程序代码：

Main

package Test;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;

public class Main{
    private static ArrayList<Student> studentlist;
    public static void main(String[] args) {
        studentlist = new ArrayList<>();
        Scanner scanner = new Scanner(System.in);
        File file = new File("D:\身份证号.txt");
        try {
            FileInputStream fis = new FileInputStream(file);
            BufferedReader in = new BufferedReader(new InputStreamReader(fis));
            String temp = null;
            while ((temp = in.readLine()) != null) {
                
                Scanner linescanner = new Scanner(temp);
                
                linescanner.useDelimiter(" ");    
                String name = linescanner.next();
                String number = linescanner.next();
                String sex = linescanner.next();
                String age = linescanner.next();
                String province =linescanner.nextLine();
                Student student = new Student();
                student.setName(name);
                student.setnumber(number);
                student.setsex(sex);
                int a = Integer.parseInt(age);
                student.setage(a);
                student.setprovince(province);
                studentlist.add(student);

            }
        } catch (FileNotFoundException e) {
            System.out.println("学生信息文件找不到");
            e.printStackTrace();
        } catch (IOException e) {
            System.out.println("学生信息文件读取错误");
            e.printStackTrace();
        }
        boolean isTrue = true;
        while (isTrue) {
            System.out.println("选择你的操作，输入正确格式的选项");
            System.out.println("a.字典排序");
            System.out.println("b.输出年龄最大和年龄最小的人");
            System.out.println("c.寻找老乡");
            System.out.println("d.寻找年龄相近的人");
            System.out.println("e.退出");
            String m = scanner.next();
            switch (m) {
            case "a":
                Collections.sort(studentlist);              
                System.out.println(studentlist.toString());
                break;
            case "b":
                 int max=0,min=100;
                 int j,k1 = 0,k2=0;
                 for(int i=1;i<studentlist.size();i++)
                 {
                     j=studentlist.get(i).getage();
                 if(j>max)
                 {
                     max=j; 
                     k1=i;
                 }
                 if(j<min)
                 {
                   min=j; 
                   k2=i;
                 }
                 
                 }  
                 System.out.println("年龄最大："+studentlist.get(k1));
                 System.out.println("年龄最小："+studentlist.get(k2));
                break;
            case "c":
                 System.out.println("老家?");
                 String find = scanner.next();        
                 String place=find.substring(0,3);
                 for (int i = 0; i <studentlist.size(); i++) 
                 {
                     if(studentlist.get(i).getprovince().substring(1,4).equals(place)) 
                         System.out.println("老乡"+studentlist.get(i));
                 }             
                 break;
                 
            case "d":
                System.out.println("年龄：");
                int yourage = scanner.nextInt();
                int near=agenear(yourage);
                int value=yourage-studentlist.get(near).getage();
                System.out.println(""+studentlist.get(near));
                break;
            case "e":
                isTrue = false;
                System.out.println("退出程序!");
                break;
                default:
                System.out.println("输入有误");

            }
        }
    }
        public static int agenear(int age) {      
        int j=0,min=53,value=0,k=0;
         for (int i = 0; i < studentlist.size(); i++)
         {
             value=studentlist.get(i).getage()-age;
             if(value<0) value=-value; 
             if (value<min) 
             {
                min=value;
                k=i;
             } 
          }    
         return k;         
      }

}

View Code

Student

package Test;

public class Student implements Comparable<Student> {

    private String name;
    private String number ;
    private String sex ;
    private int age;
    private String province;
   
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getnumber() {
        return number;
    }
    public void setnumber(String number) {
        this.number = number;
    }
    public String getsex() {
        return sex ;
    }
    public void setsex(String sex ) {
        this.sex =sex ;
    }
    public int getage() {

        return age;
        }
        public void setage(int age) {
            // int a = Integer.parseInt(age);
        this.age= age;
        }

    public String getprovince() {
        return province;
    }
    public void setprovince(String province) {
        this.province=province ;
    }

    public int compareTo(Student o) {
       return this.name.compareTo(o.getName());
    }

    public String toString() {
        return  name+"	"+sex+"	"+age+"	"+number+"	"+province+"
";
    }    
}

View Code

实验结果：

采用结对编程方式，与学习伙伴合作完成实验十编程练习2。

实验程序代码

suanfa

public class Suanfa<T> {
   private T a;
   private T b;
   public Suanfa() {
       a = null;
       b = null;
   }
  
   public Suanfa(T a, T b) {
       this.a = a;
       this.b = b;
   }
    public int   suanfa1(int a,int b)
    {
        return a+b;
    }
    public int   suanfa2(int a,int b)
    {
        return a-b;
    }
    public int   suanfa3(int a,int b)
    {
        return a*b;
    }
    public int   suanfa4(int a,int b)
    {
        if(b!=0)
        return a/b;
        else return 0;
    }

    
}

View Code

Demo

import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.Scanner;


public class Demo {
    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);
        Suanfa counter=new Suanfa();
        PrintWriter out = null;
        try {
            out = new PrintWriter("text.txt");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        int sum = 0;

        
        
        for (int i = 0; i <10; i++) {
            int a = (int) Math.round(Math.random() * 100);
            int b = (int) Math.round(Math.random() * 100);
            int m= (int) Math.round(Math.random() * 3);

            
           switch(m)
           {
           case 0:
               System.out.println(a + "+" + b + "=");
               int d0 = in.nextInt();
               out.println(a + "+" + b + "=" + d0);
               if (d0 == counter.suanfa1(a, b)) {
                   sum += 10;
                   System.out.println("恭喜答案正确");
               } else {
                   System.out.println("抱歉，答案错误");
               }
               break;
           case 1:
               while (a < b) {
                   int x = a;
                   a = b;
                   b = x;
               }
               System.out.println(a + "-" + b + "=");
               int d1 = in.nextInt();
               out.println(a + "-" + b + "=" + d1);
               if (d1 == counter.suanfa2(a, b)) {
                   sum += 10;
                   System.out.println("恭喜答案正确");
               } else {
                   System.out.println("抱歉，答案错误");
               }
               break;
           case 2:
               System.out.println(a + "*" + b + "=");
               int d2 = in.nextInt();
               out.println(a + "*" + b + "=" + d2);
               if (d2 ==counter.suanfa3(a, b)) {
                   sum += 10;
                   System.out.println("恭喜答案正确");
               } else {
                   System.out.println("抱歉，答案错误");
               }
               break;
           case 3:
               while (b == 0 || a % b != 0) {
                   a = (int) Math.round(Math.random() * 100);
                   b = (int) Math.round(Math.random() * 100);
               }
               System.out.println(a + "/" + b + "=");
               int d3 = in.nextInt();
               out.println(a + "/" + b + "=" + d3);
               if (d3 == counter.suanfa4(a, b)) {
                   sum += 10;
                   System.out.println("恭喜答案正确");
               } else {
                   System.out.println("抱歉，答案错误");
               }
               break;

           }

       
}
        System.out.println("成绩"+sum);
        out.println("成绩:"+sum);
         out.close();

         
    }
    }

View Code

实验结果：

实验总结：

对本周学习的理论知识的总结：数据结构介绍：一般将数据结构分为两大类：线性数据结构和非线性数据结构。

线性数据结构：线性表、栈、队列、串、数组和文件。非线性数据结构：树和图。

线性表：线性表的逻辑结构是n个数据元素的有限序列:(a1,a2,a3,…an)n为线性表的长度(n≥0)，n=0的表称为空表。l数据元素呈线性关系：必存在唯一的称为“第一个”的数据元素；必存在唯一的称为“最后一个”的数据元素；除第一个元素外，每个元素都有且只有一个前驱元素；除最后一个元素外，每个元素都有且只有一个后继元素。

所有数据元素在同一个线性表中必须是相同的数据类型。线性表按其存储结构可分为顺序表和链表；用顺序存储结构存储的线性表称为顺序表；顺序表将线性表中的数据元素依次存放在某个，存储区域中。一维数组就是用顺序方式存储的线性表。用链式存储结构存储的线性表称为链表。

栈：栈(Stack)也是一种特殊的线性表，是一种后进先出的结构。栈是限定仅在表尾进行插入和删除运算的线性表，表尾成为栈顶部，表头成为栈底

队列：队列(Queue)是限定所有的插入只能在表的一端进行，而所有的删除都在表的另一端进行的线性表。表中允许插入的一端称为队尾(Rear)，允许删除的一端称为队头(Front)。队列的操作是按先进先出(FIFO)的原则进行的。队列的物理存储可以用顺序存储结构，也可以用链式存储结构

散列表：散列表又称为哈希表。散列表算法的基本思想是：以结点的关键字为自变量，通过一定的函数关系（散列函数）计算出对应的函数值，以这个值作为该结点存储在散列表中

的地址。

集合类的作用：Java的集合类提供了一些基本数据结构的支持。–例如Vector、Hashtable、Stack等。

集合类的使用：Java的集合类包含在java.util包中。 importjava.util.*;

Vector类：

vector类类似长度可变的数组。 Vector中只能存放对象。Vector的元素通过下标进行访问。

Vector类关键属性： capacity表示集合最多能容纳的元素个数。

capacityIncrement表示每次增加多少容量。
size表示集合当前元素个数。

Stack类：Stack类是Vector的子类。Stack类描述堆栈数据结构，即LIFO。Stack类的关键方法：publicvoidpush(Objectitem)；publicObjectpop()；publicObjectpeek()；publicbooleanempty()；把项压入栈顶；移除栈顶对象并作为此函数的值返回该对象；查看栈顶对象而不移除它；测试堆栈是否为空

Hashtable类：Hashtable通过键来查找元素。Hashtable用散列码（hashcode）来确定键。所有对象都有一个散列码，可以通过Object类的hashCode()方法获得。

符合框架的基本结构：

Collection：集合层次中的根接口，JDK未提供这个接口的直接实现类。

Set：不能包含重复的元素。对象可能不是按存放的次序存放，也就是说不能像数组一样按索引的方式进行访问，SortedSet是一个按照升序排列元素的Set。

List：是一个有序的集合，可以包含重复的元素。提供了按索引访问的方式。

Map：包含了key-value对。Map不能包含重复的key

SortedMap是一个按照升序排列key的Map。

实验总结：通过本周的学习，我对理论知识在实验过程当中有进行了验证，而且还在后期的学习过程，助教以及老师还给我们提过结对练习的过程当中学会了很多，懂得在发现同伴的错误同时提升自己的能力，在这个过程当中收获很多。

相关阅读:
前端开发——HTML学习笔记
 前端开发——HTML学习笔记
 前端开发——HTML学习笔记
 日记2018/1/4
物联网概念
 安卓常见英文缩写的全拼
 快速排序和计数排序API
Hash表API
栈/队列API（push和pop）
链表API实现(插入，删除，查找)
原文地址：https://www.cnblogs.com/791683057mxd/p/9930847.html

实验十一 集合

实验十一集合