大数据预科班作业10

r囧r小猫 2022-06-08 10:52 230阅读 0赞

# 大数据预科班作业10 #

### 1. 填空 ###

#  #

Collection 接口的特点是元素是_________；List 接口的特点是元素_____（有
    |无）顺序，______（可以|不可以）重复； Set 接口的特点是元素_____（有|
    无）顺序，______（可以|不可以）重复； Map 接口的特点是元素是__________,
    其中_____可以重复，________不可以重复。

#  #

1. 对象
    2. 有
    3. 可以
    4. 无
    5. 不可以
    6. 键值对
    7. 值
    8. 键

### 2. （List）有如下代码 ###

#  #

import java.util.*; 
    public class TestList{ 
    public static void main(String args[]){ 
    List list = new ArrayList(); 
    list.add(“Hello”); 
    list.add(“World”); 
    list.add(1, “Learn”); 
    list.add(1, “Java”); 
    printList(list); 
    } 
    public static void printList(List list){ 
    //1 
    } 
    } 
    要求：
    1) 把//1 处的代码补充完整，要求输出 list 中所有元素的内容
    2) 写出程序执行的结果
    3) 如果要把实现类由 ArrayList 换为 LinkedList，应该改哪里？ArrayList 
    和 LinkedList 使用上有什么区别？实现上有什么区别？
    4) 如果要把实现类由 ArrayList 换为 Vector，应该改哪里？ArrayList 和
    Vector 使用上有什么区别？实现上有什么区别？

#  #

1. 题
        package com.peng.demo;
    
        import java.util.ArrayList;
        import java.util.List;
    
        public class TestList {
            public static void main(String args[]) {
                List list = new ArrayList();
                list.add("Hello");
                list.add("World");
                list.add(1, "Learn");
                list.add(1, "Java");
                printList(list);
            }
    
            public static void printList(List list) {
                // 1
                StringBuilder sb = new StringBuilder("[");
                for (int i = 0; i < list.size(); i++) {
                    if (list.get(i) instanceof String) {
                        sb.append(list.get(i).toString()).append(", ");
                    }
                }
                String str = sb.toString();
                if (str.length() > 1) {
                    str = str.substring(0, str.length() - 2);
                }
                System.out.println(str + "]");
            }
        }
    2. 题
        [Hello, Java, Learn, World]
    
    3. 题
        List list=new LinkedList();     
    
        ArrayList
            1. 基于数组
            2. 默认容量为10，每次扩容上一次的一半；内存空间连续
            3. 增删元素较慢--移动元素
            4. 查询较快--下标
            5. 线程不安全
            6. 展示--查询居多时
        LinkedList
             1. 基于链表
             2. 内存空间不连续
             3. 增删元素较快
             4. 查询较慢
             5. 线程不安全
             6. 购物车--增删频繁
    4. 题
        List list=new Vector();     
    
        Vector
            1. 基于数组
            2. 初始大小：10
            3. 扩容：每次扩容一倍，内存空间连续
            4. 增删较慢，查询较快 
            5. 线程安全
            6. java的最早的集合
            7. 原生elementAt==get等
            8. elements返回值为Enumeration，本质为迭代器

### 3. （List）写出下面程序的运行结果 ###

#  #

import java.util.*; 
    public class TestList{ 
    public static void main(String args[]){ 
    List list = new ArrayList(); 
    list.add(“Hello”); 
    list.add(“World”); 
    list.add(“Hello”); 
    list.add(“Learn”); 
    list.remove(“Hello”); 
    list.remove(0); 
    for(int i = 0; i<list.size(); i++){ 
    System.out.println(list.get(i)); 
    } 
    } 
    }

#  #

Hello
    Learn

### 4. （Set，List） ###

#  #

import java.util.*; 
    public class TestListSet{ 
    public static void main(String args[]){ 
    List list = new ArrayList(); 
    list.add(“Hello”); 
    list.add(“Learn”); 
    list.add(“Hello”); 
    list.add(“Welcome”); 
    Set set = new HashSet(); 
    set.addAll(list); 
    System.out.println(set.size()); 
    } 
    } 
    选择正确答案
    A． 编译不通过
    B． 编译通过，运行时异常
    C． 编译运行都正常，输出 3 
    D． 编译运行都正常，输出 4

#  #

C（结果为3）

### 5. （List）已知有一个 Worker 类如下： ###

#  #

public class Worker { 
    private int age; 
    private String name; 
    private double salary; 
    public Worker (){} 
    public Worker (String name, int age, double salary){ 
    this.name = name; 
    this.age = age; 
    this.salary = salary; 
    } 
    public int getAge() { 
    return age; 
    } 
    public void setAge(int age) { 
    this.age = age; 
    } 
    public String getName() { 
    return name; 
    } 
    public void setName(String name) { 
    this.name = name; 
    } 
    public double getSalary(){ 
    return salary; 
    } 
    public void setSalary(double salary){ 
    this.salary = salary; 
    } 
    public void work(){ 
    System.out.println(name + “ work”); 
    } 
    } 
    完成下面的要求
    1) 创建一个 List，在 List 中增加三个工人，基本信息如下：
    姓名 年龄 工资
    zhang3 18 3000 
    li4 25 3500 
    wang5 22 3200 
    2) 在 li4 之前插入一个工人，信息为：姓名：zhao6，年龄：24，工资 3300 
    3) 删除 wang5 的信息
    4) 利用 for 循环遍历，打印 List 中所有工人的信息
    5) 利用迭代遍历，对 List 中所有的工人调用 work 方法。
    6) 为 Worker 类添加 equals 方法

#  #

package com.peng.demo;
    
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    
    public class Worker {
        private int age;
        private String name;
        private double salary;
    
        public Worker() {
        }
    
        public Worker(String name, int age, double salary) {
            this.name = name;
            this.age = age;
            this.salary = salary;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public double getSalary() {
            return salary;
        }
    
        public void setSalary(double salary) {
            this.salary = salary;
        }
    
        public void work() {
            System.out.println(name + "work");
        }
    
        @Override
        public String toString() {
            return "name:" + name + "\tage:" + age + "\tsalary:" + salary;
        }
    
        public boolean equals(Object obj) {
            if (obj == this) {
                return true;
            }
    
            if (obj == null) {
                return false;
            }
            if (obj.getClass() != this.getClass()) {
                return false;
            }
            Worker obj_temp = (Worker) obj;
            if ((this.name == obj_temp.name || obj_temp.name != null
                    && this.name.equals(obj_temp.name))
                    && (this.age == obj_temp.age)
                    && (this.salary == obj_temp.salary)) {
                return true;
            } else {
                return false;
            }
    
        }
    
        public static void main(String[] args) {
            // 1) 创建一个 List，在 List 中增加三个工人，基本信息如下：
            // 姓名 年龄 工资
            // zhang3 18 3000
            // li4 25 3500
            // wang5 22 3200
            List<Worker> list = new ArrayList<Worker>();
            list.add(new Worker("zhang3", 18, 3000));
            list.add(new Worker("li4", 25, 3500));
            list.add(new Worker("wang5", 22, 3200));
            // 2) 在 li4 之前插入一个工人，信息为：姓名：zhao6，年龄：24，工资 3300
            list.add(2, new Worker("zhao6", 24, 3300));
            // 3) 删除 wang5 的信息
            list.remove(3);
            // 4) 利用 for 循环遍历，打印 List 中所有工人的信息
            for (int i = 0; i < list.size(); i++) {
    
            }
            // 5) 利用迭代遍历，对 List 中所有的工人调用 work 方法。
            Iterator<Worker> it = list.iterator();
            while (it.hasNext()) {
                System.out.println(it.next().toString());
            }
            // 6) 为 Worker 类添加 equals 方法--见上equals方法
    
        }
    }

### 6. （Set，Hash 算法）为上一题的 Worker 类，在添加完 equals 方法的基础上，添加一个 hashCode 方法。 ###

#  #

public int hashCode(){ 
    //1 
    } 
    有几种写法：
    1） return 0; 
    2）
    int result = 0; 
    if (name != null) result = name.hashCode(); 
    return result + age; 
    3） return super.hashCode(); 
    现在要把 Worker 类放入 HashSet 中，并希望在 HashSet 中没有重复元素，
    则下面说法正确的是：
    A. 三种写法都正确
    B. 1), 2)写法正确，2)效率更高
    C. 2)写法正确，1),3)写法都不正确

#  #

### 7. （Set，Hash 算法，方法覆盖）代码改错 ###

#  #

import java.util.*; 
    class Worker{ 
    String name; 
    int age; 
    double salary; 
    public Worker(){} 
    public Worker(String name, int age, double salary){ 
    this.name = name; 
    this.age = age; 
    this.salary = salary; 
    } 
    int hashCode(){ 
    return name.hashCode() + age + salary; 
    } 
    public boolean equals(Worker w){ 
    if (w.name == name && w.salary == salary && w.age == age){ 
    return true; 
    }else return false; 
    } 
    } 
    public class TestWorker{ 
    public static void main(String args[]){ 
    Set set = new HashSet(); 
    set.add(new Worker(“tom”, 18, 2000)); 
    set.add(new Worker(“tom”, 18, 2000)); 
    set.add(0, new Worker(“jerry”, 18, 2000)); 
    System.out.println(set.size()); 
    } 
    }

#  #

1. public int hashCode(){  //重写父类方法，权限不能小于父类
    2. set.add(0, new Worker(“jerry”, 18, 2000));// HashSet是无序的集合，不能在指定位置添加

### 8. （Set，Hash 算法）在前面的 Worker 类基础上，为 Worker 类增加相应的方法，使得 Worker 放入 HashSet 中时，Set 中没有重复元素。 并编写相应的测试代码。 ###

#  #

### 9. （Set，Comparable 接口） ###

#  #

在前面的 Worker 类基础上，为 Worker 类添加相
    应的代码， 使得 Worker 对象能正确放入 TreeSet 中。并编写相应的测试代码。
    注：比较时，先比较工人年龄大小，年龄小的排在前面。如果两个工人年龄相同，
    则再比较其收入，收入少的排前面。如果年龄和收入都相同，则根据字典顺序比
    较工人姓名。例
    如：有三个工人，基本信息如下：
    姓名 年龄 工资
    zhang3 18 1500 
    li4 18 1500 
    wang5 18 1600 
    zhao6 17 2000 
    放入 TreeSet 排序后结果为：
    zhao6 li4 zhang3 wang5

#  #

import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Set;
    import java.util.TreeSet;
    class Worker implements Comparable{
    private int age;
    private String name;
    private double salary;
    public Worker (){}
    public Worker (String name, int age, double salary){
    this.name = name;
    this.age = age;
    this.salary = salary;
    }
    @Override
    public int hashCode() {
     final int prime = 31;
     int result = 1;
     result = prime * result + age;
     result = prime * result + ((name == null) ? 0 : name.hashCode());
     long temp;
     temp = Double.doubleToLongBits(salary);
     result = prime * result + (int) (temp ^ (temp >>> 32));
     return result;
    }
    @Override
    public boolean equals(Object obj) {
     if (this == obj)
      return true;
     if (obj == null)
      return false;
     if (getClass() != obj.getClass())
      return false;
     Worker other = (Worker) obj;
     if (age != other.age)
      return false;
     if (name == null) {
      if (other.name != null)
       return false;
     } else if (!name.equals(other.name))
      return false;
     if (Double.doubleToLongBits(salary) != Double
       .doubleToLongBits(other.salary))
      return false;
     return true;
    }
    public int getAge() {
    return age;
    }
    public void setAge(int age) {
    this.age = age;
    }
    public String getName() {
    return name;
    }
    public void setName(String name) {
    this.name = name;
    }
    public double getSalary(){
    return salary;
    }
    public void setSalary(double salary){
    this.salary = salary;
    }
    public void work(){
    System.out.println(name + " work");
    }
    @Override
    public String toString() {
     return "Worker [age=" + age + ", name=" + name + ", salary=" + salary + "]";
    }
    public int compareTo(Object o) {
     if (o == null) return 1;
     if (o.getClass() != this.getClass()) return 1;
     Worker w = (Worker) o;
     if (w.age != this.age){
      return this.age - w.age;
     }
     else if (w.salary != this.salary){
      return (int)(this.salary - w.salary);
     }else if(!w.name.equals(this.name)){
      return this.name.compareTo(w.name);
     }else
      return 1;
    }
    }
    public class A{
     public static void main(String args[]){
      //List<Worker> list=new ArrayList<Worker>();
      TreeSet<Worker> ss=new TreeSet<Worker>();
      Worker w1=new Worker("zhang3",18,3000);
      Worker w2=new Worker("li4",25,3500);
      Worker w3=new Worker("wang5",22,3200);
      ss.add(w1);
      ss.add(w2);
      ss.add(w3);
      Worker w4=new Worker("zhao6",24,3300);
      //ss.add(1, w4);
      System.out.println(ss);
     }
    }

### 10. （Map）关于下列 Map 接口中常见的方法 ###

#  #

put 方法表示放入一个键值对，如果键已存在则________________，如果键不存
    在则______________。 remove 方法接受___个参数，表示__________________。
    get 方法表示_______________________，get 方法的参数表示______，返回值
    表示_____。 要想获得 Map 中所有的键，应该使用方法___________，该方法返
    回值类型为_______。 要想获得 Map 中所有的值，应该使用方法___________，
    该方法返回值类型为_______。 要想获得 Map 中所有的键值对的集合，应该使
    用方法___________，该方法返回一个_______类型所组成的 Set。

#  #

1. 新值替换旧
    2. 增加一个键值对
    3. 一个
    4. 删除一个键值对
    5. 通过键查找值
    6. 键名
    7. 该键对应的值
    8. keySet
    9. set
    10. values
    11. Collections
    12. entrySet
    13. Map.EntrySet

### 11. （Map）利用 Map，完成下面的功能： ###

#  #

从命令行读入一个字符串，表示一个年份，输出该年的世界杯冠军是哪支球队。
    如果该年没有举办世界杯，则输出：没有举办世界杯。

#  #

key-value
    年份-世界杯冠军
    根据key获取value，如果无此key则输出“没有举办世界杯”

### 12. （Map）已知某学校的教学课程内容安排如下： ###

#  #

老师 课程
    Tom CoreJava 
    John Oracle 
    Susan Oracle 
    Jerry JDBC 
    Jim Unix 
    Kevin JSP 
    Lucy JSP 
    完成下列要求：
    1） 使用一个 Map，以老师的名字作为键，以老师教授的课程名作为值，表示上
    述课程安排。
    2） 增加了一位新老师 Allen 教 JDBC 
    3） Lucy 改为教 CoreJava 
    4） 遍历 Map，输出所有的老师及老师教授的课程
    5） *利用 Map，输出所有教 JSP 的老师。

#  #

1)
    Map<String,String> map=new HashMap<String,String>();
    map.put("Tom","CoreJava");
    map.put("John","Oracle");
    map.put("Susan","Oracle");
    map.put("Jerry","JDBC");
    map.put("Jim","Unix");
    map.put("Kevin","JSP");
    map.put("Lucy","JSP");
    
    2)
    map.put("Allen","JDBC");
    
    3)
    map.remove("Lucy");
    map.put("CoreJava","Jsp");
    
    4)
    Set<String> set = map.keySet();
    for (String s : set) {
        System.out.println(map.get(s));
    }
    
    5)
    Set<String> set = map.keySet();
    for (String s : set) {
        if(map.get(s).equals("JSP")){
            System.out.println(s);
        }
    }

### 13. （泛型）使用泛型，改写第 5 题 ###

#  #

//类泛型
    class A<T,R,E,K,V>{
    
    }
    
    //方法泛型
    修饰符 <T,E,R,K,V> 返回值类型 方法名{
    
    }

### 14. （泛型）使用泛型和 Map.Entry 接口，改写第 12 题的前 4 问 ###

#  #

//关键代码
        for (Map.Entry<String, Integer> e : map.entrySet()) {
            System.out.println(e.getKey() + ":" + e.getValue());
        }

### 15. \*（List）写出下面程序的输出结果 ###

#  #

import java.util.*; 
    class MyClass{ 
    int value; 
    public MyClass(){} 
    public MyClass(int value){ this.value = value; } 
    public String toString(){ 
    return “”+value; 
    } 
    } 
    public class TestList{ 
    public static void main(String args[]){ 
    MyClass mc1 = new MyClass(10); 
    MyClass mc2 = new MyClass(20); 
    MyClass mc3 = new MyClass(30); 
    List list = new ArrayList(); 
    list.add(mc1); 
    list.add(mc2); 
    list.add(mc3); 
    MyClass mc4 = (MyClass) list.get(1); 
    mc4.value = 50; 
    for(int i = 0; i<list.size(); i++){ 
    System.out.println(list.get(i)); 
    } 
    } 
    }

#  #

10
    50
    30

### 16. \*（Set，HashSet，空指针）有下面代码 ###

#  #

import java.util.*; 
    class Student { 
    int age; 
    String name; 
    public Student(){} 
    public Student(String name, int age){ 
    this.name = name; 
    this.age = age; 
    } 
    public int hashCode(){ 
    return name.hashCode() + age; 
    } 
    public boolean equals(Object o){ 
    if (o == null) return false; 
    if (o == this) return true; 
    if (o.getClass() != this.getClass()) return false; 
    Student stu = (Student) o; 
    if (stu.name.equals(name) && stu.age == age) return true; 
    else return false; 
    } 
    } 
    public class TestHashSet{ 
    public static void main(String args[]){ 
    Set set = new HashSet(); 
    Student stu1 = new Student(); 
    Student stu2 = new Student(“Tom”, 18); 
    Student stu3 = new Student(“Tom”, 18); 
    set.add(stu1);
    set.add(stu2); 
    set.add(stu3); 
    System.out.println(set.size()); 
    } 
    } 
    下列说法正确的是：
    A. 编译错误
    B. 编译正确，运行时异常
    C. 编译运行都正确，输出结果为 3 
    D. 编译运行都正确，输出结果为 2

#  #

B空指针异常

### 17. \*（Set）有如下两个类（只写了类的属性，请自行添加相应的构造方法和get/set 方法） ###

#  #

要求，完善 Worker 和 Address 类，使得 Worker 对象能够正确放入 HashSet 
    中：即将 Worker 放入 HashSet 中时不会出现重复元素。并编写相应测试代码。

#  #

public int hashCode() {
        return name.hashCode() + age;
    }
    
    public boolean equals(Object o) {
        if (o == null)
            return false;
        if (o == this)
            return true;
        if (o.getClass() != this.getClass())
            return false;
        Student stu = (Student) o;
        if (stu.name.equals(name) && stu.age == age)
            return true;
        else
            return false;
    }

### 18. \*（Map） ###

#  #

在原有世界杯 Map 的基础上，增加如下功能：
    读入一支球队的名字，输出该球队夺冠的年份列表。
    例如，读入“巴西”，应当输出
    1958 1962 1970 1994 2002 
    读入“荷兰”，应当输出
    没有获得过世界杯

#  #

//思路：每一年只能有一个冠军，所以用年份来做key，用冠军来做value
    package homework001;
    
    import java.util.HashMap;
    import java.util.Scanner;
    
    public class Map {
    
        public static void main(String[] args) {
    
    
            java.util.Map<String, String> m1 = new HashMap<>();
            m1.put("1930", "乌拉圭");
            m1.put("1934", "意大利");
            m1.put("1938", "意大利");
            m1.put("1950", "乌拉圭");
            m1.put("1954", "西德");
            m1.put("1958", "巴西");
            m1.put("1962", "巴西");
            m1.put("1966", "英格兰");
            m1.put("1970", "巴西");
            m1.put("1974", "西德");
            m1.put("1978", "阿根廷");
            m1.put("1982", "意大利");
            m1.put("1986", "阿根廷");
            m1.put("1990", "西德");
            m1.put("1994", "巴西");
            m1.put("1998", "法国");
            m1.put("2002", "巴西");
            m1.put("2006", "意大利");
            m1.put("2010", "西班牙");
            m1.put("2014", "德国");
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入年份");
            String str = sc.nextLine();
            if(m1.containsKey(str)==false)
            {
                System.out.println(str+"年没有举办世界杯");
            }
            else
            {
                System.out.println(str+"年的夺冠球队是："+m1.get(str));
            }
    
            Scanner sc1 = new Scanner(System.in);
            System.out.println("请输入夺冠球队");
            String str1 = sc1.nextLine();
            if(m1.containsValue(str1)==false)
            {
                System.out.println(str1+"队没有获得过冠军");
            }
            else
            {
                System.out.println(str1+"队的夺冠年份是：");
                for(String k :m1.keySet())
                {
                    if(m1.get(k).equals(str1))
                    {
                        System.out.print(" "+k);
                        }
                }
    
            }
    
    
        }
    
    }

### 19. \*（Map）设计 Account 对象如下： ###

#  #

要求完善设计，使得该 Account 对象能够自动分配 id。
    给定一个 List 如下：
    List list = new ArrayList(); 
    list.add(new Account(10.00, “1234”)); 
    list.add(new Account(15.00, “5678”)); 
    list.add(new Account(0, “1010”)); 
    要求把 List 中的内容放到一个 Map 中，该 Map 的键为 id，值为相应的 Account 
    对象。
    最后遍历这个 Map，打印所有 Account 对象的 id 和余额。

#  #

package Test03;
    
    public class Account {
    
            private long id;  
            private double balance;  
            private String password;
    
        Account(double balance,String password)
        {
            this.balance=balance;
            this.password=password;
        }
    
        public long getId() {
            return id;
        }
    
        public void setId(long id) {
            this.id = id;
        }
    
        public double getBalance() {
            return balance;
        }
    
        public void setBalance(double balance) {
            this.balance = balance;
        }
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    }
    
    
    
    package Test03;
    
    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    public class TestAccount {
    
        public static void main(String[] args) {
    
            List<Account> list = new ArrayList<>(); 
    
            list.add(new Account(10.00, "1234")); 
            list.add(new Account(15.00, "5678")); 
            list.add(new Account(0, "1010")); 
    
    
            Map<Long,Account> m1 = new HashMap<>();
            m1.put((long) 0, list.get(0));
            m1.put((long) 1, list.get(1));
            m1.put((long) 2, list.get(2));
    
            for(Long k:m1.keySet())                //遍历
            {
                System.out.println(m1.get(k).getBalance());
            }
    
    
        }
    
    }

### 20. \*（List）写一个函数 reverseList，该函数能够接受一个 List，然后把该List 倒序排列。 ###

#  #

例如：
    List list = new ArrayList(); 
    list.add(“Hello”); 
    list.add(“World”); 
    list.add(“Learn”); //此时 list 为 Hello World Learn 
    reverseList(list); 
    //调用 reverseList 方法之后，list 为 Learn World Hello

#  #

package Test03;
    
    import java.util.ArrayList;
    import java.util.List;
    
    public class ReverseList {
    
        public static void main(String[] args) {
    
            List<String> list = new ArrayList<>(); 
            list.add("Hello"); 
            list.add("World"); 
            list.add("Learn");                     //此时list 为Hello World Learn 
    
            StringBuffer a = new StringBuffer();
            for(String s:list){
                    a.append(s);
            }
            System.out.println(a.toString());
            //reverseList(list);
    
            //StringBuilder b = new StringBuilder(list.toString());
    
            //System.out.println(list);
            System.out.println(a.reverse().toString());
    
        }
    
    }

### 21. \*\*（Map，Hash 算法）有如下代码： ###

#  #

import java.util.*; 
    class MyKey{ 
    int keyValue; 
    public MyKey(){} 
    public MyKey(int value){this.keyValue = value;} 
    } 
    class MyValue{ 
    String value; 
    public MyValue(){} 
    public MyValue(String value){this.value = value;} 
    public String toString(){return value;} 
    } 
    public class TestMap{ 
    public static void main(String args[]){ 
    Map map = new HashMap(); 
    MyKey key1 = new MyKey(10); 
    map.put(key1, new MyValue(“abc”)); 
    map.put(new MyKey(10), new MyValue(“cde”)); 
    System.out.println(map.get(key1)); 
    System.out.println(map.size()); 
    } 
    } 
    写出该代码的输出结果。

#  #

abc
    2

### 22. \*\*（Id，hashCode，equals）为 Worker 类增加 id 属性，用来唯一标识一个员工。即：如果员工的 id 不同，则不管其姓名、年龄、工资是否相同，都认为是不同的员工。部分代码如下： ###

#  #

class Worker{ 
    private final Long id; 
    private String name; 
    private double salary; 
    private int age; 
    //构造方法„
    //get/set 方法„
    public boolean equals(Object obj){ 
    //1 此处仅判断 id 是否相同
    } 
    public int hashCode(){ 
    //2 此处返回 hashCode 
    } 
    } 
    要求：
    1） 完善构造方法和 get/set 方法。要求自动分配 Worker 的 id 
    2） 完善 equals 方法。要求仅判断 id 是否相同
    3） //2 处，如果写成
    return (int)(name.hashCode() + id.hashCode() + age + salary); 
    是否正确？为什么？

#  #

1）getter/setter;自动分配员工id--可以采用自动生成的uuid
    2）
        if(null==obj){
            return false;
        }
    
        if(this.id==((Worker)obj).id){
            return true;
        }
    
        return false;
    
    3)不正确--id为基本数据类型，不能调用方法hashCode

### 23. \*\*（综合）有如下 Student 对象 ###

#  #

其中，classNum 表示学生的班号，例如“class05”。
    有如下 List 
    List list = new ArrayList(); 
    list.add(new Student(“Tom”, 18, 100, “class05”)); 
    list.add(new Student(“Jerry”, 22, 70, “class04”)); 
    list.add(new Student(“Owen”, 25, 90, “class05”)); 
    list.add(new Student(“Jim”, 30,80 , “class05”)); 
    list.add(new Student(“Steve”, 28, 66, “class06”)); 
    list.add(new Student(“Kevin”, 24, 100, “class04”)); 
    在这个 list 的基础上，完成下列要求：
    1） 计算所有学生的平均年龄
    2） 计算各个班级的平均分

#  #

1)
            age_all+=list.get(i).age;
    2)
            1.将班级名取出并去重【可以使用set】list.get(i).className;
            2.循环遍历set班级，然后并循环遍历取出次className中的分数相加，并记录该班学生总数；最后求班级的平均分
            3.打印输出班级和平均分数

### 24. \*\*（综合）已知有十六支男子足球队参加 2008 北京奥运会。写一个程序， ###

把这 16 支球队随机分为 4 个小组。
    注：参赛球队列表见附录
    注 2：使用 Math.random 来产生随机数。

#  #

1. 创建两个数组 int[] arr=new int[16]; boolan[] arr2=new boolean[16];
    2. 随机生成0-15；即int ran=new Random().nextInt(16);//0-15
    3. while循环并随机生成数字0-15，如果将对应随机数下标的Boolean数组的单元置为true，并将随机数加1放入int数组中
    4. 最后按int数组的4个为一组，进行球队的划分

### 25. \*\*（综合）写一个 MyStack 类，表示“栈”这种数据结构。 ###

栈在表示上，就如同一个单向开口的盒子，每当有新数据进入时，都是进入栈顶。
    其基本操作为 push 和 pop。push 表示把一个元素加入栈顶，pop 表示把栈顶元
    素弹出。
    示意图如下：
    
    栈的特点：先进后出。
    栈的基本操作：
    1） push(Object o)：表示把元素放入栈
    2） Object pop()：返回栈顶元素，并把该元素从栈中删除。如果栈为空，
    则返回 null 值
    3） Object peek()：返回栈顶元素，但不把该元素删除。如果栈为空，则
    返回 null 值。
    4） boolean isEmpty()：判断该栈是否为空
    5） int size()：返回该栈中元素的数量
    要求：
    1） 利用 List，实现栈。
    2） 讨论：应当用 ArrayList 作为实现类还是用 LinkedList？为什么？、

#  #

package com.peng.demo;
    
    import java.util.Arrays;
    import java.util.EmptyStackException;
    
    /*
     * 数组实现Stack
     */
    public class Test3 {
        String[] arr = new String[10];
        int size = 0;
    
        String pop() {
            // 判空
            if (size <= 0) {
                throw new EmptyStackException();
            } else {
                String temp = arr[size - 1];
                size--;
                return temp;
            }
    
        }
    
        String peek() {
            // 判空
            if (size <= 0) {
                throw new EmptyStackException();
            } else {
                String temp = arr[size - 1];
                return temp;
            }
        }
    
        void push(String s) {
            // 判断是否需要扩容
            if (size >= arr.length) {
                // 扩容
                arr = Arrays.copyOf(arr, arr.length * 2);
            }
            arr[size] = s;
            size++;
        }
    
        int search(String s) {
            for (int i = 0; i < size; i++) {
                if (arr[i] == s || s != null && arr[i].equals(s)) {
                    return size - 1 - i + 1;
                }
            }
            return -1;
        }
    
        boolean empty() {
            if (size == 0) {
                return true;
            } else {
                return false;
            }
        }
    
        public static void main(String[] args) {
            Test3 t = new Test3();
            t.push("a");
            t.push("b");
            t.push("c");
            System.out.println(t.pop());
            System.out.println(t.peek());
            System.err.println(t.size);
    
        }
    
    }