20165206 第十周课下补做

20165206 第十周课下补做

一、相关知识点

• 泛型类声明：泛型类声明和创建对象时，类名后多了一对“<>”，而且必须要用具体的类型替换“<>”中的泛型。

• 链表：由若干个称作结点的对象组成的一种数据结构，用于动态的减少或增加数据项。

• java.util包中的LinkedList泛型类创建的对象以链表结构存储数据，称这样创建的对象为链表对象。

• 遍历：遍历链表，利用迭代器。链表对象可以使用iterator()方法获取一个Iterator对象，该对象就是针对当前链表的迭代器。

• 排序：
  public static sort(List list) 该方法可以将list中的元素升序排列。

• 查找：
  int binarySearch(List list, T key,CompareTo c) 使用折半法查找list是否含有和参数key相等的元素，如果key链表中某个元素相等，方法返回和key相等的元素在链表中的索引位置（链表的索引位置从0考试），否则返回-1。

• 洗牌与旋转：
  public static void shuffle(List list)
  将list中的数据按洗牌算法重新随机排列。
  static void rotate(List list, int distance)
  旋转链表中的数据。
  public static void reverse(List list)
  翻转list中的数据。

• 堆栈是一种“后进先出”的数据结构，只能在一端进行输入或输出数据的操作。向堆栈中输入数据的操作称为“压栈”，从堆栈中输出数据的操作称为“弹栈”。

• 树集：TreeSet类是实现Set接口的类，它的大部分方法都是接口方法的实现。TreeSet类创建的对象称为树集。树集采用树结构存储数据，树结点中的数据会按存放的数据的“大小”顺序一层一层地依次排列，在同一层中的结点从左到右按字典序从小到大递增排列，下一层都比上一层的小。

二、课上内容补做

- 数据结构-排序

代码：

import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
public class StudentTest {
    public  static void main(String[] args) {
        LinkedList<Student> mylist = new LinkedList<>();
        mylist.add(new Student(20165204,"贾普涵",20,88,92,89));
        mylist.add(new Student(20165205,"刘喆君",20,89,91,75));
        mylist.add(new Student(20165206,"韩啸",20,90,90,90));
        mylist.add(new Student(20165207,"李天林",20,91,89,78));
        mylist.add(new Student(20165208,"孔月",20,92,88,83));
        System.out.println("排序前：");
        for (Student student : mylist)
        {
            System.out.println(student);
        }
        SortByTotal_score sortBytotal_score = new SortByTotal_score();
        Collections.sort(mylist, sortBytotal_score);
        SortByID sortByID = new SortByID();
        Collections.sort(mylist, sortByID);
        System.out.println("按学号进行排序后：");
        for (Student student : mylist) {
            System.out.println(student);
        }

        Collections.sort(mylist, sortBytotal_score);
        System.out.println("按总成绩进行排序后：");
        for (Student student : mylist) {
            System.out.println(student);
        }
    }
}

class Student {

    private int id;//表示学号
    private String name;//表示姓名
    private int age;//表示年龄
    private double computer_score;//表示计算机课程的成绩
    private double english_score;//表示英语课的成绩
    private double maths_score;//表示数学课的成绩
    private double total_score;// 表示总成绩
    private double ave_score; //表示平均成绩

    @Override
    public String toString() {
        return "Student[name:"+name+",age:"+age+",number:"+id+",total_score"+total_score+"]";
    }

    public Student(int id, String name, int age, double computer_score,
                   double english_score, double maths_score) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.computer_score = computer_score;
        this.english_score = english_score;
        this.maths_score = maths_score;
    }

    public int getId() {
        return id;
    }//获得当前对象的学号，

    public double getComputer_score() {
        return computer_score;
    }//获得当前对象的计算机课程成绩,

    public double getMaths_score() {
        return maths_score;
    }//获得当前对象的数学课程成绩,

    public double getEnglish_score() {
        return english_score;
    }//获得当前对象的英语课程成绩,

    public void setId(int id) {
        this.id = id;
    }// 设置当前对象的id值,

    public void setComputer_score(double computer_score) {
        this.computer_score = computer_score;
    }//设置当前对象的Computer_score值,

    public void setEnglish_score(double english_score) {
        this.english_score = english_score;
    }//设置当前对象的English_score值,

    public void setMaths_score(double maths_score) {
        this.maths_score = maths_score;
    }//设置当前对象的Maths_score值,

    public double getTotalScore() {
        total_score=computer_score + maths_score + english_score;
        return total_score;
    }// 计算Computer_score, Maths_score 和English_score 三门课的总成绩。

    public double getAveScore() {
        return getTotalScore() / 3;
    }// 计算Computer_score, Maths_score 和English_score 三门课的平均成绩。

}

class SortByID implements Comparator<Student> {

    @Override
    public int compare(Student o1, Student o2) {
        return o1.getId() - o2.getId();
    }

}
class SortByTotal_score implements Comparator<Student> {

    @Override
    public int compare(Student o1, Student o2) {
        return (int)( o1.getTotalScore() - o2.getTotalScore());
    }
}

运行截图：

- 数据结构-单链表

代码：

import java.util.*;
public class MyList {
    public static void main(String [] args) {
        //选用合适的构造方法，用你学号前后各两名同学的学号创建四个结点
        LinkedList<String> mylist=new LinkedList<String>();
        mylist.add("20165204");
        mylist.add("20165205");
        mylist.add("20165207");
        mylist.add("20165208");
        //把上面四个节点连成一个没有头结点的单链表
        System.out.println("遍历单链表，打印初始链表");
        Iterator<String> iterator=mylist.iterator();
        while(iterator.hasNext()){
            String te=iterator.next();
            System.out.println(te);
        }
        //遍历单链表，打印每个结点的
        mylist.add("20165206");
        Collections.sort(mylist);
        //把你自己插入到合适的位置（学号升序）
        System.out.println("遍历单链表，打印插入我的学号排序后的链表");
        iterator=mylist.iterator();
        while(iterator.hasNext()){
            String te=iterator.next();
            System.out.println(te);
        }
        //遍历单链表，打印每个结点的
        mylist.remove("20165206");
        //从链表中删除自己
        System.out.println("遍历单链表，打印删除我的学号后的链表");
        iterator=mylist.iterator();
        while(iterator.hasNext()){
            String te=iterator.next();
            System.out.println(te);
        }
        //遍历单链表，打印每个结点的
    }
}

class Node<T>                             //单链表结点类，T指定结点的元素类型
{
    public T data;                               //数据域，存储数据元素
    public Node<T> next;                         //地址域，引用后继结点

    public Node(T data, Node<T> next)            //构造结点，data指定数据元素，next指定后继结点
    {
        this.data = data;                        //T对象引用赋值
        this.next = next;                        //Node<T>对象引用赋值
    }
    public Node()
    {
        this(null, null);
    }
    public String toString()                     //返回结点数据域的描述字符串
    {
        return this.data.toString();
    }
}

运行截图：

三、代码分析

• Example15_1

class Cone<E> { 
   double height;
   E bottom;           //用泛型类E声明对象bottom
   public Cone (E b) {
      bottom=b;   //给泛型类对象赋值
   }
   public void setHeight(double h) {
      height=h;
   }
   public double computerVolume() {
      String s=bottom.toString();//泛型变量只能调用从Object类继承的或重写的方法
      double area=Double.parseDouble(s); 
      return 1.0/3.0*area*height; 
   }
}

class Rect {
   double sideA,sideB,area; 
   Rect(double a,double b) {
     sideA=a;
     sideB=b;
   } 
   public String toString() {
      area=sideA*sideB;
      return ""+area;
   }
}

class Circle {
   double area,radius; 
   Circle(double r) {
      radius=r;
   } 
   public String toString() { //重写Object类的toString()方法
      area=radius*radius*Math.PI;
      return ""+area;
   }
}

public class Example15_1 {
   public static void main(String args[]) {
      Circle circle=new Circle(10);
      Cone<Circle> coneOne=new Cone<Circle>(circle);//创建一个（圆）锥对象  
      coneOne.setHeight(16);
      System.out.println(coneOne.computerVolume());
      Rect rect=new Rect(15,23);
      Cone<Rect> coneTwo=new Cone<Rect>(rect);//创建一个（方）锥对象
      coneTwo.setHeight(98); 
      System.out.println(coneTwo.computerVolume());
  }
}

该例子是使用泛型类声明对象的一个具体事例，应注意的是泛型类声明和创建对象时，类名后多了一对“<>”，而且必须要用具体的类型替换“<>”中的泛型。
在本例子中的Cone类即为泛型类，一个Cone对象计算体积时，只关心它的底能否计算面积，不关心底的类型。

• Example15_2

import java.util.*;
public class Example15_2 {
   public static void main(String args[]){
      List<String> list=new LinkedList<String>();
      //定义一个空链表
      for(int i=0;i<=60096;i++){
             list.add("speed"+i);
      }
      Iterator<String> iter=list.iterator();  //获取链表中的迭代器
      long starttime=System.currentTimeMillis();
      while(iter.hasNext()){
           String te=iter.next();
      }
      //进行遍历
      long endTime=System.currentTimeMillis();
      long result=endTime-starttime;
      System.out.println("使用迭代器遍历集合所用时间:"+result+"毫秒");
      starttime=System.currentTimeMillis();
      for(int i=0;i<list.size();i++){
          String te=list.get(i);
      }
      endTime=System.currentTimeMillis();
      result=endTime-starttime;
      System.out.println("使用get方法遍历集合所用时间:"+result+"毫秒");
    }
}

该例子主要是介绍了链表中迭代器的使用，并比较了使用迭代器遍历链表和使用get(int index)遍历链表所用的时间。

• Example15_3

import java.util.*;
public class Example15_3 {
    public static void main(String args[]){
        LinkedList mylist=new LinkedList();//定义一个空链表
        mylist.add("你");                 //链表中的第一个节点
        mylist.add("好");                 //链表中的第二个节点
        int number=mylist.size();         //获取链表的长度
        for(int i=0;i<number;i++){
          String temp=(String)mylist.get(i); //必须强制转换取出的数据
          System.out.println("第"+i+"节点中的数据:"+temp);
        } 
        Iterator iter=mylist.iterator();
        while(iter.hasNext()) {
          String te=(String)iter.next();  //必须强制转换取出的数据
          System.out.println(te);
        }
   }
}

该例子主要介绍了使用add(Object obj)方法向链表中依次添加结点，以及使用泛型类时不必进行强制类型转换。

• Example15_4

import java.util.*;
class Student implements Comparable { 
   int height=0;
   String name;
   Student(String n,int h) {
      name=n;
      height = h;
     
   }
   public int compareTo(Object b) { // 两个Student对象相等当且仅当二者的height值相等
     Student st=(Student)b;
     return (this.height-st.height);
   }
}
public class Example15_4 {
    public static void main(String args[ ]) { 
       List<Student> list = new LinkedList<Student>();
       //定义一个空链表
       list.add(new Student("张三",188));
       list.add(new Student("李四",178));
       list.add(new Student("周五",198)); 
       //向链表中依次添加元素
       Iterator<Student> iter=list.iterator();
       System.out.println("排序前,链表中的数据");
       while(iter.hasNext()){
          Student stu=iter.next();
          System.out.println(stu.name+ "身高:"+stu.height);
       }
       //对链表进行遍历
       Collections.sort(list);
       //进行升序排序
       System.out.println("排序后,链表中的数据");
       iter=list.iterator();
       while(iter.hasNext()){
          Student stu=iter.next();
          System.out.println(stu.name+ "身高:"+stu.height);
       }
       Student zhaoLin = new Student("zhao xiao lin",178);
       int index = Collections.binarySearch(list,zhaoLin,null);
       if(index>=0) {
            System.out.println(zhaoLin.name+"和链表中"+list.get(index).name+"身高相同");
       }
    }
}

该例子主要是介绍了如何通过Comparable对类的对象进行比较以及通过Collections.sort进行升序排列。

• Example15_5

import java.util.*;
public class Example15_5 {
    public static void main(String args[ ]) { 
       List<Integer> list = new LinkedList<Integer>();
       //定义一个空链表
       for(int i=10;i<=50;i=i+10)
           list.add(new Integer(i));
       System.out.println("洗牌前,链表中的数据");
       Iterator<Integer> iter=list.iterator();
       while(iter.hasNext()){
          Integer n=iter.next();
          System.out.printf("%d	",n.intValue());
       }
       //遍历链表
       Collections.shuffle(list);
       //按洗牌算法重新随机排列
       System.out.printf("
洗牌后,链表中的数据
");
       iter=list.iterator();
       while(iter.hasNext()){
          Integer n=iter.next();
          System.out.printf("%d	",n.intValue());
       }
       System.out.printf("
再向右旋转1次后,链表中的数据
");
       Collections.rotate(list,1);
       //旋转链表中的数据
       iter=list.iterator();
       while(iter.hasNext()){
          Integer n=iter.next();
          System.out.printf("%d	",n.intValue());
       }
      
    }
}

该例子主要介绍了如何通过shuffle()方法进行重新随机排列，以及通过rotate()方法进行旋转链表中的数据。

• Example15_6

import java.util.*;
public class Example15_6 {
   public static void main(String args[]) {
      Stack<Integer> stack=new Stack<Integer>();
      //定义一个堆栈对象
      stack.push(new Integer(1)); 
      stack.push(new Integer(1));
      //进行压栈
      int k=1;
      while(k<=10) {
        for(int i=1;i<=2;i++) {
          Integer F1=stack.pop();
          int f1=F1.intValue();
          Integer F2=stack.pop();
          int f2=F2.intValue();
          Integer temp=new Integer(f1+f2);
          System.out.println(""+temp.toString()); 
          stack.push(temp);
          stack.push(F2);
          k++;
        }
      } 
   }
}

该例子是用堆栈输出递归序列的若干项。

• Example15_7

import java.awt.*;
import javax.swing.*;
import java.awt.event.*;   
import java.io.*;
import java.util.*;
class WindowWord extends JFrame {
   JTextField inputText,showText;
   WordPolice police;           //监视器
   WindowWord() {
      setLayout(new FlowLayout());
      inputText=new JTextField(6);
      showText=new JTextField(6);
      add(inputText); 
      add(showText);
      police=new WordPolice();
      police.setJTextField(showText);
      inputText.addActionListener(police);
      setBounds(100,100,400,280);
      setVisible(true);
      setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   }
}

class WordPolice implements ActionListener {
   JTextField showText;
   HashMap<String,String> hashtable;
   //定义一个散列映射对象
   File file=new File("word.txt");
   Scanner sc=null;
   WordPolice() {
     hashtable=new HashMap<String,String>();
     try{ sc=new Scanner(file);
          while(sc.hasNext()){
             String englishWord=sc.next();
             String chineseWord=sc.next(); 
             hashtable.put(englishWord,chineseWord); 
          }
     }
     catch(Exception e){}  
   }
   public void setJTextField(JTextField showText) {
      this.showText=showText;
   }
   public void actionPerformed(ActionEvent e) {
      String englishWord=e.getActionCommand();
      if(hashtable.containsKey(englishWord)) {
         String chineseWord=hashtable.get(englishWord);
         showText.setText(chineseWord);
      }
      else {
         showText.setText("没有此单词");
      }  
   }
}

public class Example15_7 {
   public static void main(String args[]) {
      WindowWord win=new WindowWord();
      win.setTitle("英-汉小字典");
   }
}

该例子一个基于散列映射的查询。是一个进行英语单词查询的GUI程序，用户输入一个英文单词并确认，另一边显示其汉语翻译。

• Example15_8

import java.util.*;
class Student implements Comparable {
   int english=0;
   String name;
   Student(int english,String name) {
      this.name=name;
      this.english=english;
   }
   public int compareTo(Object b) {
      Student st=(Student)b;
      return (this.english-st.english);
   }
}
public class Example15_8 {
  public static void main(String args[]) {
     TreeSet<Student> mytree=new TreeSet<Student>();
     //定义一个树集对象
     Student st1,st2,st3,st4;
     st1=new Student(90,"赵一");
     st2=new Student(66,"钱二");
     st3=new Student(86,"孙三");
     st4=new Student(76,"李四");
     mytree.add(st1);
     mytree.add(st2);
     mytree.add(st3);
     mytree.add(st4);
     //依次添加数据
     Iterator<Student> te=mytree.iterator();
     while(te.hasNext()) {
        Student stu=te.next();
        System.out.println(""+stu.name+" "+stu.english);
        //遍历并打印数据
     }
  }
}

该例子是通过树集根据英语成绩从低到高的存放四个对象。

• Example15_9

import java.util.*;
class StudentKey implements Comparable { 
   double d=0; 
   StudentKey (double d) {
     this.d=d;
   }
   public int compareTo(Object b) {
     StudentKey st=(StudentKey)b;
     if((this.d-st.d)==0)
        return -1;
     else
        return (int)((this.d-st.d)*1000);
  }
}
class Student { 
    String name=null;
    double math,english;
    Student(String s,double m,double e) {
       name=s; 
       math=m;
       english=e;
    }
}
public class Example15_9 {
   public static void main(String args[ ]) {
      TreeMap<StudentKey,Student>  treemap= new TreeMap<StudentKey,Student>();
      //定义一个树映射对象
      String str[]={"赵一","钱二","孙三","李四"};
      double math[]={89,45,78,76};
      double english[]={67,66,90,56};
      Student student[]=new Student[4];
      for(int k=0;k<student.length;k++) {
         student[k]=new Student(str[k],math[k],english[k]);
      }
      StudentKey key[]=new StudentKey[4] ;
      for(int k=0;k<key.length;k++) {
         key[k]=new StudentKey(student[k].math); //关键字按数学成绩排列大小
      }
      for(int k=0;k<student.length;k++) {
         treemap.put(key[k],student[k]);          
      }
      int number=treemap.size();
      System.out.println("树映射中有"+number+"个对象,按数学成绩排序:");
      Collection<Student> collection=treemap.values();
      Iterator<Student> iter=collection.iterator();
      while(iter.hasNext()) {
         Student stu=iter.next();
         System.out.println("姓名 "+stu.name+" 数学 "+stu.math);
      }
      treemap.clear();
      for(int k=0;k<key.length;k++) {
         key[k]=new StudentKey(student[k].english);//关键字按英语成绩排列大小
      }
      for(int k=0;k<student.length;k++) {
         treemap.put(key[k],student[k]);
      }
      number=treemap.size();
      System.out.println("树映射中有"+number+"个对象:按英语成绩排序:");
      collection=treemap.values();
      iter=collection.iterator();
      while(iter.hasNext()) {
         Student stu=(Student)iter.next();
         System.out.println("姓名 "+stu.name+" 英语 "+stu.english);
      }
    }
}

该例子是使用TreeMap，分别按学生的英语成绩和数学成绩排序。

• Example15_10

import java.util.*;
public class Example15_10 {
   public static void main(String args[]) {
      ArrayList<Integer> list=new ArrayList<Integer>();
      for(int i=0;i<10;i++) {
         list.add(i);  //自动装箱,实际添加到list中的是new Integer(i)。
      }
      for(int k=list.size()-1;k>=0;k--) {
         int m=list.get(k);  //自动拆箱,获取Integer对象中的int型数据
         System.out.printf("%3d",m);
      }
   }
}

该例子是进行了自动装箱和拆箱，即当添加一个基本数据类型到类似链表的数据结构中时自动完成基本数据类型到相应对象的转换以及获取对象时自动完成相应对象到基本数据类型的转换。

四、课后编程题目

• 使用堆栈结构输出an的若干项，其中an=2an-1 +2an-2 ，a1=3，a2=8。

import java.util.*;
public class E {
    public static void main(String args[]) {
        Stack<Integer> stack=new Stack<Integer>();
        stack.push(new Integer(3));
        stack.push(new Integer(8));
        int k=1;
        while(k<=10) {
            for(int i=1;i<=2;i++) {
                Integer F1=stack.pop();
                int f1=F1.intValue();
                Integer F2=stack.pop();
                int f2=F2.intValue();
                Integer temp=new Integer(2*f1+2*f2);
                System.out.println(""+temp.toString());
                stack.push(temp);
                stack.push(F2);
                k++;
            }
        }
    }
}

运行截图：

• 编写一个程序，将链表中的学生英语成绩单存放到一个树集中，使得按成绩自动排序，并输出排序结果。

import java.util.*; 
class Student implements Comparable {
    int english=0; 
String name; 
   Student(int english,String name) {
       this.name=name;
       this.english=english;
    } 
   public int compareTo(Object b) {
       Student st=(Student)b;
       return (this.english-st.english);
    }
 } 
public class E { 
  public static void main(String args[]) { 
     List<Student> list=new LinkedList<Student>();
      int score []={65,76,45,99,77,88,100,79}; 
     String name[]={"张三","李四","旺季","加戈","为哈","周和","赵李","将集"};
       for(int i=0;i<score.length;i++){ 
             list.add(new Student(score[i],name[i]));
      } 
     Iterator<Student> iter=list.iterator(); 
     TreeSet<Student> mytree=new TreeSet<Student>();
      while(iter.hasNext()){
          Student stu=iter.next();
          mytree.add(stu);
      } 
     Iterator<Student> te=mytree.iterator();
      while(te.hasNext()) {
         Student stu=te.next(); 
        System.out.println(""+stu.name+" "+stu.english);
      }
   }
 }

运行截图：

• 有10个U盘，有两个重要的属性：价格和容量。编写一个应用程序，使用TreeMap。

import java.util.*; 
class UDiscKey implements Comparable {
     double key=0;
     UDiscKey(double d) {
      key=d;
    } 
   public int compareTo(Object b) {
      UDiscKey disc=(UDiscKey)b; 
     if((this.key-disc.key)==0)
         return -1;
      else 
        return (int)((this.key-disc.key)*1000);
   }
 } 
class UDisc{
      int amount;
     double price; 
    UDisc(int m,double e) {
        amount=m;
         price=e;
    }
 } 
public class E { 
   public static void main(String args[ ]) { 
      TreeMap<UDiscKey,UDisc>  treemap= new TreeMap<UDiscKey,UDisc>();
       int amount[]={1,2,4,8,16};
       double price[]={867,266,390,556};
       UDisc UDisc[]=new UDisc[4];
       for(int k=0;k<UDisc.length;k++) { 
         UDisc[k]=new UDisc(amount[k],price[k]);
       } 
      UDiscKey key[]=new UDiscKey[4];
        for(int k=0;k<key.length;k++) { 
         key[k]=new UDiscKey(UDisc[k].amount);        } 
      for(int k=0;k<UDisc.length;k++) { 
         treemap.put(key[k],UDisc[k]);                 } 
      int number=treemap.size(); 
      Collection<UDisc> collection=treemap.values();
       Iterator<UDisc> iter=collection.iterator();
       while(iter.hasNext()) {
          UDisc disc=iter.next(); 
         System.out.println(""+disc.amount+"G "+disc.price+"元");       } 
      treemap.clear(); 
      for(int k=0;k<key.length;k++) { 
 key[k]=new UDiscKey(UDisc[k].price);       } 
      for(int k=0;k<UDisc.length;k++) {
          treemap.put(key[k],UDisc[k]);       } 
      number=treemap.size();
       collection=treemap.values();
       iter=collection.iterator();
       while(iter.hasNext()) {
          UDisc disc=iter.next(); 
         System.out.println(""+disc.amount+"G "+disc.price+"元");
       }
     }
 }

运行截图：