标签：set sid obj star student search 功能 key 相等
1.++链表++：由若干个称作结点的==对象==组成的一种数据结构，每个结点含有一个数据和下一个结点的引用，或含有一个数据并含有上一个结点的引用和下一个结点的引用。
2.创建链表：用java.util包中的```LinkedList
LinkedList<String> mylist = new LinkedList<String>(); 3.添加结点：add(E obj)
例如：mylist.add("How")
4.常用方法
5.遍历链表：
iterator()方法获得一个Iterator对象.get(int index)方法返回列表中的第index个对象。6.排序与查找：
public static sort(List<E> list)：将list中的元素按升序排列。int binarySearch(List<T> list, T key, CompareTo<T> c):使用折半法查找list是否含有和参数key相等的元素，如果key与链表中的某个元素相等，方法返回和key相等的元素在链表中的索引位置（从0开始），否则返回-1.String类数据：则字符串按字典序比较大小Comparable接口，即实现该接口中的方法int compareTo(Object b)来规定对象的大小关系。课上题目2：
在数据结构和算法中，排序是很重要的操作，要让一个类可以进行排序，有两种方法：
针对下面的Student类，使用Comparator编程完成以下功能：
分析：因为题目中属于多种排序，所以，要新建一个类，并让类实现Comparator接口，并重写接口中的int ComparaTo(Object b)方法。
课题代码：代码
代码：
import java.util.*;
import java.text.*;
//重写接口中Compare方法
class Compare1 implements Comparator {
@Override
public int compare(Object o1, Object o2) {
Student st1 = (Student)o1;
Student st2 = (Student)o2;
int id1 = Integer.parseInt(((Student) o1).getId());
int id2 = Integer.parseInt(((Student) o2).getId());
return (id1 - id2);
}
}
class Compare2 implements Comparator {
@Override
public int compare(Object o1, Object o2) {
Student st1 = (Student) o1;
Student st2 = (Student) o2;
if (st1.getTotalScore() == st2.getTotalScore()) {
return 0;
}
if (st1.getTotalScore() > st2.getTotalScore()) {
return 1;
}
if (st1.getTotalScore() <= st2.getTotalScore()) {
return -1;
}
return 0;
}
}
class StudentTest {
public static void main(String[] args) {
List<Student> list = new LinkedList<Student>();//创建一个list链表
//向链表中添加结点（对象）
list.add(new Student("20165201", "李梓豪",90,91,95));
list.add(new Student("20165202", "贾海粟",89,93,92));
list.add(new Student("20165203", "夏云霄",93,95,92));
list.add(new Student("20165204", "贾普涵",88,90,91));
list.add(new Student("20165205", "刘喆君",87,90,92));
Iterator<Student> iter = list.iterator();//list链表对象用iterator方法获取一个Iterator对象（针对当前链表的迭代器）
System.out.println("排序前,链表中的数据");
while (iter.hasNext()) {
Student stu = iter.next();
System.out.println(stu.getId() + " " + stu.getName() + " 总成绩：" + stu.getTotalScore());
}
Collections.sort(list,new Compare1());//调用接口中的Compare1方法来就id来排序
System.out.println("按学号排序后,链表中的数据");
iter = list.iterator();
while (iter.hasNext()){
Student stu = iter.next();
System.out.println(stu.getId() + " " + stu.getName() + " 总成绩：" + stu.getTotalScore());
}
Collections.sort(list,new Compare2());//调用接口中的Compare2方法来就总分来排序
System.out.println("按总成绩排序后,链表中的数据");
iter = list.iterator();
while (iter.hasNext()){
Student stu = iter.next();
System.out.println(stu.getId() + " " + stu.getName() + " 总成绩：" + stu.getTotalScore());
}
}
}
class Student {
private char sex;
private String 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; //表示平均成绩
public Student(String id, String name) {
this.id = id;
this.name = name;
}
public Student(String id, String name, char sex, int age) {
this(id, name);
this.sex = sex;
this.age = age;
}
public Student(String id, String name, double computer_score, double english_score, double maths_score) {
this(id, name);
this.computer_score = computer_score;
this.english_score = english_score;
this.maths_score = maths_score;
}
public String getName() {
return name;
}
public String 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(String 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() {
return computer_score + maths_score + english_score;
}// 计算Computer_score, Maths_score 和English_score 三门课的总成绩。
public double getAveScore() {
return getTotalScore() / 3;
}// 计算Computer_score, Maths_score 和English_score 三门课的平均成绩。
}
class Undergraduate extends Student {
private String classID;
public Undergraduate(String id, String name, char sex, int age, String classID) {
super(id, name, sex, age);
this.classID = classID;
}
public String getClassID() {
return classID;
}
public void setClassID(String classID) {
this.classID = classID;
}
} 结果截图：
课上题目3：
参见附件，补充MyList.java的内容，提交运行结果截图（全屏）
课下推送代码到码云
课题代码：代码
代码：
import java.util.*;
public class MyList {
public static void main(String [] args) {
List<String> list=new LinkedList<String>();
list.add("20165201");
list.add("20165202");
list.add("20165204");
list.add("20165205");
System.out.println("打印初始链表");
//把上面四个节点连成一个没有头结点的单链表
Iterator<String> iter=list.iterator();
while(iter.hasNext()){
String te=iter.next();
System.out.println(te);
}
//遍历单链表，打印每个结点的
list.add("20165203");
//把你自己插入到合适的位置（学号升序）
System.out.println("插入我的学号后排序，打印链表");
Collections.sort(list);
iter=list.iterator();
while(iter.hasNext()){
String te=iter.next();
System.out.println(te);
}
//遍历单链表，打印每个结点的
list.remove("20165203");
//从链表中删除自己
System.out.println("删除我的学号后打印链表");
iter=list.iterator();
while(iter.hasNext()){
String te=iter.next();
System.out.println(te);
}
//遍历单链表，打印每个结点的
}
}结果截图：
分析：本例中添加了插入、排序、删除等内容，自己在做插入时，却在“如何插入到正确位置”这个位置上犯了难。 后来，自己经过思考，发现该链表中的结点都是String类，String类中实现了Comparable接口,Collection调用sort排序时，字符串按字典序比较大小，不用重写compareTo方法。
1.Example15_1系列代码分析：
Cone.java
Rect.java
Circle.java
Example15_1.java
这个程序范例很好，帮助我理解了泛型类的概念，Cone.java表示的是计算一个椎体的体积，因为底面的形状不确定，所以，可用泛型类表示底面。之后又定义了Rect.java（计算矩形的面积），Circle.java（计算圆的面积），来在主程序中计算椎体的体积。
2.Example15_2分析：
这个程序主要讲的是链表的遍历，值得学习的是：
利用Iterator<String> iter = list.iterator();创建了一个针对list链表的迭代器。
自己对程序中不懂的代码进行了学习：
iter.hasNext()：该语句的作用是判断链表中下一个结点是否是空结点，如果不是返回true，是返回fale,可用于循环语句中。
iter.next()：该语句也是用来判断列表中下一个结点是否是空结点，如果不是，返回下一个结点.
关键代码分析:
Iterator<String> iter=list.iterator();//创建一个iter链表迭代器
long starttime=System.currentTimeMillis();//以毫秒为单位计算开始使的时间
//遍历整个链表，将链表中的节点赋给te数组
while(iter.hasNext()){
String te=iter.next();
}3.Example15_3分析：
该程序的亮点是利用add(Object obj)向链表中依次添加结点
利用get()获取一个结点中的对象时，要用类型转换运算符转换回原来的类型。
关键代码分析：
Iterator iter=mylist.iterator();//获取针对mylist链表的迭代器
while(iter.hasNext()) {
String te=(String)iter.next(); //必须强制转换取出的数据
System.out.println(te);
} 4.Example15_4分析：
这个程序的功能是排序，让我学到了不少东西。
该程序中链表中存放的Studnet类对象并不是字符串型的，所以，要让Studnet类实现Comparable接口，实现该接口中的compare To(Object b)方法。
程序：
public int compareTo(Object b) { // 两个Student对象相等当且仅当二者的height值相等
Student st=(Student)b;
return (this.height-st.height);
} 给出了排序的根据：两个结点相等的根据是对象的height相等。height值大的排在后面。
关键代码分析：
//通过重写compareTo方法规定排序的依据
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);
}
} 5.Example15_5分析：
该程序主要体现了洗牌，所谓洗牌就是将链表中的数据重新随机排列，可用public static void shuffle(List<E> list)
static void rotate(List<E> list, int distance):distance取正值，向右转动；distance取负值，向左转动。public static void reverse(List<E> list)：翻转list中的数据。关键代码分析：
Collections.shuffle(list)；//洗牌后的重新操作Collections.rotate(list,1);//向右旋转1次后的操作 6.Example15_6分析：
该程序主要是创建了一个堆栈对象stack，并在stack中放入对象，然后输出该递归序列的若干项.
关键代码分析：
Stack<Integer> stack=new Stack<Integer>();//创建一个堆栈对象
//向堆栈中放入对象，注意堆栈中的元素是对象
stack.push(new Integer(1));
stack.push(new Integer(1)); int f1=F1.intValue();//吧Integer类型转化为int类型 7.Example15_7分析：
Example15_7.java
WindowWord.java
WordPolice.java
本程序主要体现散列映射的意义，主要是存储数据便于查找，该程序就是用WordPolice类使用Scanner解析word.txt中的单词，并将英文单词/汉语对应键/值存储到散列映射中供用户查询。
8.Example15_8分析：
本程序体现了用树集存放时，如果对象不是字符串类型，要重写compareTo方法规定排序方法。本程序中，贵司能够排序为按照英语成绩，所以，在树集中的存放方式要按照英语成绩存放。
9.Example15_9分析：
本程序主要是创建树映射，并存储关键字/值对，重写compareTo方法，然后分别对该树中的结点按英语成绩和数学成绩排序。
10.Example15_10分析：
该程序体现了自动装箱和自动拆箱。将链表中的int型数据转换成Integer对象，输出时，将Integer对象转换成int类型。
1.使用堆栈结构输出an的若干项，其中an=2an-1+2an-1，a1=3，a2=8
分析：编程思路如下：
代码如下：
import java.util.*;
public class Exp1 {
public static void main(String args[]) {
Stack<Integer> stack = new Stack<Integer>();//定义一个空堆栈
//将数列前两项放入堆栈中
stack.push(3);
stack.push(8);
int k = 1;
//输出15项
while (k <= 15) {
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 = 2*f1+2*f2;
System.out.println(" "+temp.toString());
stack.push(temp);
stack.push(F2);
k++;
}
}
}
}2.编写一个程序，将链表中的学生英语成绩单存放到一个树集中，使得按成绩自动排序，并输出排序结果。
代码：
import java.util.*;
import static java.sql.DriverManager.println;
class College implements Comparable {
int english=0;
String name;
College(String name, int english ){
this.name=name;
this.english=english;
}
public int comparaTo(Object b) {
College stu = (College) b;
return (this.english-stu.english);
}
}
public class Exp2 {
public static void main(String args[]) {
List<College> list=new LinkedList<College>();
int score [] = {85,88,90,91,88};
String name [] = {"李梓豪","贾海粟","夏云霄","贾普涵","刘喆君"};
for(int i=0; i<score.length;i++){
list.add(new College(name[i],score[i]));
}
Iterator<College> iter = list.iterator();
TreeSet<College> mytree=new TreeSet<College>();
while(iter.hasNext()) {
College stu=iter.next();
mytree.add(stu);
}
Iterator<College> te=mytree.iterator();
while(te.hasNext()) {
College stu = iter.next();
System.out.println(""+stu.name+" "+stu.english);
}
}
}3.3、有10个U盘，有两个重要的属性：价格和容量。编写一个应用程序，使用TreeMap
import java.util.*;
class SandyKey implements Comparable {
double key=0;
SandyKey(double d) {
key=d;
}
public int compareTo(Object b) {
SandyKey disc=(SandyKey)b;
if((this.key-disc.key)==0)
return -1;
else
return (int)((this.key-disc.key)*1000);
}
}
class Sandy{
int amount;
double price;
Sandy(int m,double e) {
amount=m;
price=e;
}
}
public class E {
public static void main(String args[ ]) {
TreeMap<SandyKey,Sandy> treemap= new TreeMap<SandyKey,Sandy>();
int amount[]={1,2,4,8,16};
double price[]={867,266,390,556};
Sandy Sandy[]=new Sandy[4];
for(int k=0;k<Sandy.length;k++) {
Sandy[k]=new Sandy(amount[k],price[k]);
}
SandyKey key[]=new SandyKey[4];
for(int k=0;k<key.length;k++) {
key[k]=new SandyKey(Sandy[k].amount); }
for(int k=0;k<Sandy.length;k++) {
treemap.put(key[k],Sandy[k]); }
int number=treemap.size();
Collection<Sandy> collection=treemap.values();
Iterator<Sandy> iter=collection.iterator();
while(iter.hasNext()) {
Sandy sandy=iter.next();
System.out.println(""+sandy.amount+"G "+sandy.price+"元"); }
treemap.clear();
for(int k=0;k<key.length;k++) {
key[k]=new SandyKey(Sandy[k].price); }
for(int k=0;k<Sandy.length;k++) {
treemap.put(key[k],Sandy[k]); }
number=treemap.size();
collection=treemap.values();
iter=collection.iterator();
while(iter.hasNext()) {
Sandy sandy=iter.next();
System.out.println(""+sandy.amount+"G "+sandy.price+"元");
}
}
}标签：set sid obj star student search 功能 key 相等
原文地址：https://www.cnblogs.com/20165203-xyx/p/8997661.html
