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

热门文章

最新文章

相关课程

相关电子书

相关实验场景