Java2EE练习及面试题_chapter11Java集合

/*
定义一个Collection接口类型的变量，引用一个Set集合的实现类，实现添加单个元素，添加另一个集合，删除元素，判断集合中是否包含一个元素，判断是否为空，清除集合，返回集合里元素的个数等常用操作。
 */

package com.jerry.exer1;
import java.util.Collections;
import java.util.HashSet;
/**
 * @author jerry_jy
 * @create 2022-10-06 16:54
 */
public class Exer1 {
    public static void main(String[] args) {
        HashSet set = new HashSet();
        System.out.println("======添加单个元素======");
        set.add("AA");
        set.add("BB");
        System.out.println(set);//[AA, BB]
        HashSet set1 = new HashSet();
        set1.add("CC");
        set1.add("DD");
        System.out.println("=======添加另一个集合========");
        set.addAll(set1);
        System.out.println(set);//[AA, BB, CC, DD]
        System.out.println("=======删除元素========");
        set.remove("DD");
        System.out.println(set);//[AA, BB, CC]
        System.out.println("=======判断集合中是否包含一个元素========");
        System.out.println(set.contains("CC"));//true
        System.out.println("=======判断是否为空========");
        System.out.println(set.isEmpty());//false
        System.out.println("=======返回集合里元素的个数========");
        System.out.println(set.size());//3
        System.out.println("=======清除集合========");
        set.clear();
        System.out.println(set.isEmpty());//true
    }
}

/*创建Set接口的实现类，添加10个以上的元素，通过Iterator遍历此集合元素。*/

package com.jerry.exer1;
import java.util.HashSet;
import java.util.Iterator;
/**
 * @author jerry_jy
 * @create 2022-10-06 17:21
 */
public class Exer2 {
    public static void main(String[] args) {
        HashSet set = new HashSet();
        //添加10个以上的元素
        for (int i = 0; i < 10; i++) {
            set.add(i);
        }
        //通过Iterator遍历此集合元素
        Iterator iterator = set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

/*创建Set接口的实现类，添加10个以上的元素，通过foreach遍历此集合元素。*/

package com.jerry.exer1;
import java.util.HashSet;
/**
 * @author jerry_jy
 * @create 2022-10-06 17:25
 */
public class Exer3 {
    public static void main(String[] args) {
        HashSet set = new HashSet();
        //添加10个以上的元素
        for (int i = 0; i < 10; i++) {
            set.add(i);
        }
        //通过foreach遍历此集合元素
        for (Object o : set) {
            System.out.println(o);
        }
    }
}

/*创建Car类，包含name，price属性，构造器等方法，创建测试类，在main方法中创建Set接口的实现类，添加5个以上的Car对象，遍历集合元素，验证重复元素是否过滤了；如果没有过滤，实现过滤功能；把每个小车的price降10000元，再遍历，查看price是否已改变*/

package com.jerry.exer1;
import java.util.HashSet;
/**
 * @author jerry_jy
 * @create 2022-10-06 17:34
 */
public class Exer5 {
   public static void main(String[] args) {
        HashSet set = new HashSet();
        Car byd = new Car("BYD", 139999);
        Car bmw = new Car("BMW", 339999);
        Car farrier = new Car("Farrier", 939999);
        Car audi = new Car("Audi", 239999);
        Car benz = new Car("Benz", 439999);
        set.add(byd);
        set.add(bmw);
        set.add(farrier);
        set.add(audi);
        set.add(benz);
        set.add(benz);//重复添加，会失败的
        System.out.println(set);
        System.out.println("=====把每个小车的price降10000元，再遍历========");
        byd.setPrice(byd.decreasePrice());
        bmw.setPrice(bmw.decreasePrice());
        farrier.setPrice(farrier.decreasePrice());
        audi.setPrice(audi.decreasePrice());
        benz.setPrice(benz.decreasePrice());
        System.out.println(set);
    }
}
class Car {
    private String name;
    private double price;
    public Car() {
    }
    public Car(String name, double price) {
        this.name = name;
        this.price = price;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
    public double decreasePrice(){
        return price-10000;
    }
}

/*定义一个Collection接口类型的变量，引用一个List集合的实现类，实现添加单个元素，添加另一个集合，删除元素，判断集合中是否包含一个元素，判断是否为空，清除集合，返回集合里元素的个数等常用操作。*/

package com.jerry.exer1;
import java.util.ArrayList;
import java.util.HashSet;
/**
 * @author jerry_jy
 * @create 2022-10-06 17:50
 */
public class Exer6 {
   public static void main(String[] args) {
        ArrayList list = new ArrayList();
        System.out.println("======添加单个元素======");
        list.add("aa");
        list.add("bb");
        list.add("cc");
        System.out.println(list);//[aa, bb, cc]
        System.out.println("=======添加另一个集合========");
        ArrayList list1 = new ArrayList();
        list1.add("dd");
        list1.add("ee");
        list.addAll(list1);
        System.out.println(list);//[aa, bb, cc, dd, ee]
        System.out.println("=======删除元素========");
        list.remove("ee");
        System.out.println(list);//[aa, bb, cc, dd]
        System.out.println("=======判断集合中是否包含一个元素========");
        System.out.println(list.contains("dd"));//true
        System.out.println("=======判断是否为空========");
        System.out.println(list.isEmpty());//false
        System.out.println("=======返回集合里元素的个数========");
        System.out.println(list.size());//4
        System.out.println("=======清除集合========");
        list.clear();
        System.out.println(list.isEmpty());//true
    }
}

/*创建ArrayList实例化对象，添加10个以上的元素，在2号位插入一个元素，获得5号位元素，删除6号位元素，修改7号位的元素；*/

package com.jerry.exer1;
import java.util.ArrayList;
/**
 * @author jerry_jy
 * @create 2022-10-06 17:56
 */
public class Exer7 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        for (int i = 0; i < 10; i++) {
            list.add(i);
        }
        System.out.println("=====原来的list=====");
        System.out.println(list);
        System.out.println("=====在2号位插入一个元素=====");
        list.add(1, "new");
        System.out.println(list);
        System.out.println("=====获得5号位元素=====");
        System.out.println(list.get(4));//3
        System.out.println("=====删除6号位元素=====");
        System.out.println(list.remove(6));//5
        System.out.println(list);
        System.out.println("=====修改7号位的元素=====");
        list.remove(6);
        list.add(6, "new_7");
        System.out.println(list);
    }
}

/*通过四种方法遍历集合*/

package com.jerry.exer1;
import java.util.ArrayList;
import java.util.Iterator;
/**
 * @author jerry_jy
 * @create 2022-10-06 18:04
 */
public class Exer8 {
    /*通过四种方法遍历集合*/
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        for (int i = 0; i < 10; i++) {
            list.add(i);
        }
        System.out.println("for 方式一");
        Object[] array = list.toArray();
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
        System.out.println("iterator 方式二");
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
        System.out.println("for each方式三");
        for (Object o : list) {
            System.out.println(o);
        }
        System.out.println("直接打印list 方式四");
        System.out.println(list);
    }
}

/*创建LinkedList实例化对象，练习具有队列特点的方法*/

package com.jerry.exer1;
import java.util.Collections;
import java.util.LinkedList;
/**
 * @author jerry_jy
 * @create 2022-10-06 18:08
 */
public class Exer9 {
    /*创建LinkedList实例化对象，练习具有队列特点的方法*/
    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
        linkedList.add("AA");
        linkedList.add("BB");
        linkedList.add("CC");
        linkedList.addFirst("first");
        linkedList.addLast("last");
        System.out.println(linkedList);//[first, AA, BB, CC, last]
        System.out.println(linkedList.getFirst());//first
        System.out.println(linkedList.getLast());//last
        linkedList.removeFirst();
        linkedList.removeLast();
        System.out.println(linkedList);//[AA, BB, CC]
        Collections.reverse(linkedList);
        System.out.println(linkedList);//[CC, BB, AA]
    }
}

/*按要求实现下列问题：
1)封装一个新闻类，包含标题和内容属性，提供get、set方法，重写toString方法，打印对象时只打印标题；（10分）
2)只提供一个带参数的构造器，实例化对象时，只初始化标题；并且实例化两个对象：
新闻一：中国多地遭雾霾笼罩空气质量再成热议话题
新闻二：春节临近北京“卖房热”
3)将新闻对象添加到ArrayList集合中，并且使用ListIterator倒序遍历；
4)在遍历集合过程中，对新闻标题进行处理，超过15字的只保留前14个，然后在后边加“…”
5)在控制台打印遍历出经过处理的新闻标题；
*/

package com.jerry.exer1;
import java.util.ArrayList;
import java.util.Iterator;
/**
 * @author jerry_jy
 * @create 2022-10-06 18:11
 */
public class Exer10 {
    public static void main(String[] args) {
        News news1 = new News("新闻一：中国多地遭雾霾笼罩空气质量再成热议话题");
        News news2 = new News("新闻二：春节临近北京“卖房热”");
        ArrayList<News> list = new ArrayList<>();
        list.add(news1);
        list.add(news2);
        Iterator<News> iterator = list.iterator();
        while (iterator.hasNext()) {
            if (iterator.next().getTitle().length() > 15) {
                int len = iterator.next().getTitle().length() - 1;
                String substring = iterator.next().getTitle().substring(0, len - 1);
//                System.out.println(substring);
                iterator.next().setTitle(substring+ "...");
            } else {
                System.out.println(iterator.next());
            }
        }
    }
}
class News {
    private String title;
    private String content;
    public News() {
    }
    public News(String title) {
        this.title = title;
    }
    public News(String title, String content) {
        this.title = title;
        this.content = content;
    }
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public String getContent() {
        return content;
    }
    public void setContent(String content) {
        this.content = content;
    }
    @Override
    public String toString() {
        return "News{" +
                "title='" + title + '\'' +
                '}';
    }
}

/*
定义一个Map接口类型的变量，引用一个实现类，添加键值对，判断集合中是否包含某一key值，通过某一key值得到value值，通过某一key删除键值对，把另一个map集合添加到此map集合，判断是否为空，清除集合，返回集合里元素的个数等常用操作。
 */

package com.jerry.exer1;
import java.util.HashMap;
/**
 * @author jerry_jy
 * @create 2022-10-06 18:40
 */
public class Exer11 {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        map.put("iPhone14", "5999");
        map.put("HUAWEI", "6999");
        map.put("XIAOMI", 4999);
        System.out.println("========原始的map=======");
        System.out.println(map);//{XIAOMI=4999, iPhone14=5999, HUAWEI=6999}
        System.out.println("========根据key获取values=======");
        System.out.println(map.get("iPhone14"));//5999
        System.out.println("========获取所有的values=======");
        for (Object value : map.values()) {
            System.out.println(value);//4999    5999    6999
        }
        System.out.println("========获取所有的key=======");
        for (Object o : map.keySet()) {
            System.out.println(o);//XIAOMI  iPhone14    HUAWEI
        }
        System.out.println("========map的映射Entry=======");
        for (Object o : map.entrySet()) {
            System.out.println(o);//XIAOMI=4999 iPhone14=5999   HUAWEI=6999
        }
        System.out.println("===判断集合中是否包含某一key值=====");
        System.out.println(map.containsKey("HUAWEI"));//true
        System.out.println("===通过某一key删除键值对=====");
        System.out.println(map.remove("XIAOMI"));//4999
        System.out.println(map);//{iPhone14=5999, HUAWEI=6999}
        System.out.println("===把另一个map集合添加到此map集合=====");
        HashMap map1 = new HashMap();
        map1.put("OPPO", "2999");
        map1.put("VIVO", 3999);
        map.putAll(map1);
        System.out.println(map);//{VIVO=3999, OPPO=2999, iPhone14=5999, HUAWEI=6999}
        System.out.println("===判断是否为空=====");
        System.out.println(map.isEmpty());//false
        System.out.println("===返回集合里元素的个数=====");
        System.out.println(map.size());//4
        System.out.println("===清除集合=====");
        map.clear();
        System.out.println(map.isEmpty());//true
    }
}

/*使用Map接口的实现类完成员工工资(姓名--工资)的摸拟： 1)添加几条信息 2)列出所有的员工姓名 3列出所有员工姓名及其工资 4)删除名叫“Tom”的员工信息 5)输出Jack的工资，并将其工资加1000元(通过取值实现) 6)将所有工资低于1000元的员工的工资上涨20%(通过取值实现)*/

package com.jerry.exer1;
import java.util.Collection;
import java.util.HashMap;
/**
 * @author jerry_jy
 * @create 2022-10-07 9:21
 */
public class Exer12 {
   public static void main(String[] args) {
        HashMap map = new HashMap();
        System.out.println("=======添加几条信息=======");
        map.put("Tom", "8999");
        map.put("Jerry", "9999");
        map.put("Lily", "7999");
        map.put("Jack", "10999");
        System.out.println(map);//{Tom=8999, Jerry=9999, Jack=10999, Lily=7999}
        System.out.println("=======列出所有的员工姓名=======");
        for (Object o : map.keySet()) {
            System.out.println(o);
        }
        System.out.println("=======列出所有员工姓名及其工资=======");
        for (Object value : map.values()) {
            System.out.println(value);
        }
        System.out.println("=======删除名叫“Tom”的员工信息=======");
        System.out.println(map.remove("Tom"));
        System.out.println("=======输出Jack的工资，并将其工资加1000元(通过取值实现)=======");
        Object jack = map.get("Jack");
        System.out.println(jack);
        int salary = Integer.parseInt(jack.toString());
        salary = salary + 1000;
        System.out.println(salary);
        System.out.println("=======将所有工资低于1000元的员工的工资上涨20%(通过取值实现)=======");
        Collection values = map.values();
        Object[] objects = values.toArray();
        for (int i = 0; i < objects.length; i++) {
            System.out.println(objects[i]);
        }
        System.out.println("=======上涨20%=======");
        for (int i = 0; i < objects.length; i++) {
            objects[i] = Double.parseDouble(objects[i].toString()) * 1.2;
            System.out.println(objects[i]);
        }
    }
}

/*
封装一个新闻类，包含标题、作者、新闻内容和发布时间，新闻标题如下：
新闻一：中国多地遭雾霾笼罩空气质量再成热议话题
新闻二：民进党台北举行“火大游行”
新闻三：春节临近北京“卖房热”
新闻四：春节临近北京“卖房热”
完成如下要求（共50分，每小题10分）：
1）完成对新闻类的设计，要求在初始化新闻类对象时 ，通过构造传参的形式对新闻标题赋值，并要求实例化四个对象，标题内容如题。
2）要求打印新闻对象时，直接打印新闻标题；
3）要求使用equals方法比较新闻时，只要标题相同，就认为是同一新闻，请输出新闻一与新闻二的比较结果，新闻三与新闻四的比较结果。
4）将新闻对象存入HashSet集合中，并且遍历集合，打印新闻类对象；
5）打印集合中新闻数量。
 */

package com.jerry.exer1;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
/**
 * @author jerry_jy
 * @create 2022-10-07 9:45
 */
public class Exer13 {
    public static void main(String[] args) {
        MyNews news1 = new MyNews("中国多地遭雾霾笼罩空气质量再成热议话题");
        MyNews news2 = new MyNews("民进党台北举行“火大游行”");
        MyNews news3 = new MyNews("春节临近北京“卖房热”");
        MyNews news4 = new MyNews("春节临近北京“卖房热”");
        System.out.println("=======打印新闻对象========");
        System.out.println(news1);
        System.out.println("=====只要标题相同，就认为是同一新闻=======");
        System.out.println(news1.equals(news2));
        System.out.println(news3.equals(news4));
        System.out.println("=========将新闻对象存入HashSet集合中，并且遍历集合，打印新闻类对象==============");
        HashSet set = new HashSet();
        set.add(news1);
        set.add(news2);
        set.add(news3);
        set.add(news4);
        for (Object o : set) {
            System.out.println(o);
        }
        System.out.println("=====打印集合中新闻数量========");
        System.out.println(set.size());
    }
}
class MyNews{
    String title;
    String author;
    String context;
    Date time;
    public MyNews(String title) {
        this.title = title;
    }
    @Override
    public String toString() {
        return "MyNews{" +
                "title='" + title + '\'' +
                '}';
    }
    public boolean equals(Object o){
        if (o instanceof MyNews){
            MyNews news = (MyNews) o;
            if (title.equals(news.title)){
                return true;
            }else {
                return false;
            }
        }
        throw new RuntimeException("传入的数据类型不一致！");
    }
}

/*
使用HashMap类实例化一个Map类型的对象m1，键（String类型）和值（int型）分别用于存储员工的姓名和工资，存入数据如下：
张三——800元；李四——1500元；王五——3000元；
1）将张三的工资更改为2600元
2）为所有员工工资加薪100元；
3）遍历集合中所有的员工
4）遍历集合中所有的工资
 */

package com.jerry.exer1;
import java.util.HashMap;
/**
 * @author jerry_jy
 * @create 2022-10-07 10:09
 */
public class Exer14 {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        map.put("Zhang3", 800);
        map.put("Li4", 1500);
        map.put("Wang5", 3000);
        System.out.println("=======原始map=======");
        System.out.println(map);
        System.out.println("=======将张三的工资更改为2600元=======");
        Object o = map.get("Zhang3");
//        System.out.println(o);
        int z3 = Integer.parseInt(o.toString());
        z3=2600;
        System.out.println(z3);
        System.out.println("=======为所有员工工资加薪100元=======");
        Object[] objects = map.values().toArray();
        for (int i = 0; i < objects.length; i++) {
            objects[i]=Integer.parseInt(objects[i].toString())+100;
            System.out.println(objects[i]);
        }
        System.out.println("=======遍历集合中所有的员工=======");
        for (Object o1 : map.keySet()) {
            System.out.println(o1);
        }
        System.out.println("=======遍历集合中所有的工资=======");
        for (Object value : map.values()) {
            System.out.println(value);
        }
    }
}

/*
创建一个List集合的对象，添加几个数字，反转对象中元素的顺序；根据元素的自然顺序排序；
创建一个List集合的对象，添加几个字符串，反转对象中元素的顺序；根据元素的自然顺序排序；
创建一个List集合的对象，添加几条数据，将1号位和2号位交换；获得最大值，最小值，
 */

package com.jerry.exer1;
import java.util.ArrayList;
import java.util.Collections;
/**
 * @author jerry_jy
 * @create 2022-10-07 10:33
 */
public class Exer15 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(5);
        list.add(4);
        list.add(3);
        list.add(2);
        list.add(1);
        System.out.println(list);
        Collections.reverse(list);
        System.out.println(list);
        System.out.println("========================");
        ArrayList list1 = new ArrayList();
        list1.add("AA");
        list1.add("BB");
        list1.add("CC");
        list1.add("DD");
        System.out.println(list1);
        Collections.reverse(list1);
        System.out.println(list1);
        System.out.println("========================");
        System.out.println(Collections.max(list));
        System.out.println(Collections.min(list));
        Collections.swap(list, 0, 1);
        System.out.println(list);
    }
}

/*
按要求完成如下操作
1.  生成10个随机数，值在100到200之间；
2.  将这十个数存入HashSet集合中（有可能集合的长度小于10）。
3.  将这个HashSet集合转换成ArrayList集合
4.  重新为ArrayList集合排序，按照从小到大的顺序；
5.  使用foreach遍历集合；
 */

package com.jerry.exer1;
import java.util.Arrays;
import java.util.HashSet;
/**
 * @author jerry_jy
 * @create 2022-10-07 10:40
 */
public class Exer16 {
    public static void main(String[] args) {
        System.out.println("生成10个随机数，值在100到200之间: ");
        HashSet set = new HashSet();
        for (int i = 0; i < 10; i++) {
             int num = (int) (Math.random() * 100 + 100);
             set.add(num);
        }
        System.out.println(set);
        Object[] array = set.toArray();
        //重新排序
        Arrays.sort(array);
        //遍历输出
        for (Object o : array) {
            System.out.println(o);
        }
    }
}

/*
1 ）封装一个汽车类，包含String  name、int  speed属性，在测试类中实例化三个对象：c1，c2，c3，分别设置name为：“奥拓”，“宝马”，“奔驰”，速度分别设置为：100,200,300
2 ）使用Map集合对象m1将这三个汽车类对象保存成key，然后将int型的汽车价钱作为值保存在m1的value中，上述三款汽车分别对应的价钱是10000,500000,2000000
3 ）遍历m1的键，打印name属性
4 ）通过合适的方法，求出m1中“宝马”的价格，并打印结果；
5 ）经过折旧，所有汽车都降价到原来的80%，请打印降价后“宝马”的价格
 */

package com.jerry.exer1;
import java.util.Collection;
import java.util.HashMap;
import java.util.Set;
/**
 * @author jerry_jy
 * @create 2022-10-07 10:46
 */
public class Exer17 {
    public static void main(String[] args) {
        Car1 c1 = new Car1("奥拓", 100);
        Car1 c2 = new Car1("宝马", 200);
        Car1 c3 = new Car1("奔驰", 300);
        HashMap map = new HashMap();
        map.put(c1, 10000);
        map.put(c2, 500000);
        map.put(c3, 2000000);
        //遍历m1的键，打印name属性
        for (Object o : map.keySet()) {
            Car1 o1 = (Car1) o;
            System.out.println(o1.name);
        }
        //求出m1中“宝马”的价格，并打印结果
        System.out.println(map.get(c2));
        Object[] array = map.values().toArray();
        for (int i = 0; i < array.length; i++) {
            array[i] = Double.parseDouble(array[i].toString()) * 0.8;
            System.out.println(array[i]);
        }
        System.out.println(array[2]);
    }
}
class Car1 {
    String name;
    int speed;
    public Car1(String name, int speed) {
        this.name = name;
        this.speed = speed;
    }
}

/*
1. 定义一个 Employee 类。
该类包含：private 成员变量 name,age,birthday，其中 birthday 为
MyDate 类的对象；
并为每一个属性定义 getter, setter 方法；
并重写 toString 方法输出 name, age, birthday
MyDate 类包含:
private 成员变量 year,month,day；并为每一个属性定义 getter, setter
方法；
创建该类的 5 个对象，并把这些对象放入 TreeSet 集合中（下一章：
TreeSet 需使用泛型来定义）
分别按以下两种方式对集合中的元素进行排序，并遍历输出：
1). 使 Employee 实现 Comparable 接口，并按 name 排序
2). 创建 TreeSet 时传入 Comparator 对象，按生日日期的先后排序。
 */

package com.jerry.exer1;
import java.util.Arrays;
import java.util.Comparator;
import java.util.TreeSet;
/**
 * @author jerry_jy
 * @create 2022-10-07 11:15
 */
public class Exer18 {
    public static void main(String[] args) {
        Employee e1 = new Employee("Tom", 22, new MyDate(1997, 5, 6));
        Employee e2 = new Employee("Jerry", 21, new MyDate(1998, 6, 6));
        Employee e3 = new Employee("Jack", 23, new MyDate(1996, 7, 6));
        Employee e4 = new Employee("Jim", 24, new MyDate(1999, 8, 6));
        Employee e5 = new Employee("Lily", 25, new MyDate(1995, 9, 6));
        TreeSet<Employee> set = new TreeSet<>();
        set.add(e1);
        set.add(e2);
        set.add(e3);
        set.add(e4);
        set.add(e5);
        //1). 使 Employee 实现 Comparable 接口，并按 name 排序
        System.out.println(set);
        //创建 TreeSet 时传入 Comparator 对象，按生日日期的先后排序
        Object[] array = set.toArray();
        Arrays.sort(array, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                Employee emp1 = (Employee) o1;
                Employee emp2 = (Employee) o2;
                return compare(emp1.getBirthday(), emp2.getBirthday());
            }
        });
    }
}
class Employee implements Comparable{
    private String name;
    private int age;
    private MyDate birthday;
    public Employee(String name, int age, MyDate birthday) {
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public MyDate getBirthday() {
        return birthday;
    }
    public void setBirthday(MyDate birthday) {
        this.birthday = birthday;
    }
    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", birthday=" + birthday +
                '}';
    }
    @Override
    public int compareTo(Object o) {
        if (o instanceof Employee){
            Employee emp = (Employee) o;
            return this.getName().compareTo(emp.getName());
        }
        throw new RuntimeException("传入的数据类型不一致！");
    }
}
class MyDate{
    private int year, month, day;
    public MyDate() {
    }
    public MyDate(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
    public int getYear() {
        return year;
    }
    public void setYear(int year) {
        this.year = year;
    }
    public int getMonth() {
        return month;
    }
    public void setMonth(int month) {
        this.month = month;
    }
    public int getDay() {
        return day;
    }
    public void setDay(int day) {
        this.day = day;
    }
}

Java2EE练习及面试题_chapter11Java集合_下

题目16

题目17

题目18

题目19

题目20

题目21

题目22

题目23

题目24

题目25

题目26

题目27

题目28

题目29

题目30

题目31

题目32

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Java2EE练习及面试题_chapter11Java集合_下

题目16

题目17

题目18

题目19

题目20

题目21

题目22

题目23

题目24

题目25

题目26

题目27

题目28

题目29

题目30

题目31

题目32

热门文章

最新文章

相关课程

相关电子书

相关实验场景