Java集合练习

最新推荐文章于 2023-08-10 23:01:09 发布

大面积秃头

最新推荐文章于 2023-08-10 23:01:09 发布

阅读量219

点赞数 1

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/wode39/article/details/127647688

版权

java 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

定义一个 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). 创建象，按生日日期的先后排序。

public class Employee implements Comparable<Employee>{
    private String name;
    private int age;
    private MyDate birthDay;

    public Employee() {
    }

    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(Employee o) {
        int result=this.getName().compareTo(o.name);
        return  result;
    }
}

//Mydate类
public class MyDate implements Comparable<MyDate>{
    private int year;
    private int month;
    private int 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;
    }

    @Override
    public String toString() {
        return "MyDate{" +
                "year=" + year +
                ", month=" + month +
                ", day=" + day +
                '}';
    }

    @Override
    public int compareTo(MyDate o) {
        int result=this.year-o.year;
        result=result==0?this.month-o.month:result;
        result=result==0?this.day-o.day:result;
        return result;
    }
}

public class Exam6 {
    public static void main(String[] args) {
        TreeSet<Employee> employees = new TreeSet<>();
        employees.add(new Employee("Tack", 22, new MyDate(2000, 3, 20)));
        employees.add(new Employee("Jack", 25, new MyDate(1997, 7, 21)));
        employees.add(new Employee("Mary", 22, new MyDate(2000, 5, 21)));
        employees.add(new Employee("Anna", 20, new MyDate(2002, 12, 1)));
        employees.add(new Employee("Tony", 23, new MyDate(1999, 3, 20)));
        for (Employee employee : employees) {
            System.out.println(employee);
        }

        System.out.println("+++++++++++++++++++++++++++++++++++++");

        TreeSet<Employee> employees1=new TreeSet<Employee>(new Comparator<Employee>() {

            @Override
            public int compare(Employee o1, Employee o2) {
                MyDate d1=o1.getBirthDay();
                MyDate d2=o2.getBirthDay();
                int result=0;
                if ((d1.getYear()-d2.getYear()!=0)){
                     result= d1.getYear()-d2.getYear();
                }else if ((d1.getMonth()-d2.getMonth()!=0)){
                    result= d1.getMonth()-d2.getMonth();
                }else if (d1.getDay()-d2.getDay()!=0){
                    result= d1.getDay()-d2.getDay();
                }
                return result;
            }

        });
        employees1.add(new Employee("Tack", 22, new MyDate(2000, 3, 20)));
        employees1.add(new Employee("Jack", 25, new MyDate(1997, 7, 21)));
        employees1.add(new Employee("Mary", 22, new MyDate(2000, 5, 21)));
        employees1.add(new Employee("Anna", 20, new MyDate(2002, 12, 1)));
        employees1.add(new Employee("Tony", 23, new MyDate(1999, 3, 20)));
        for (Employee employee : employees1) {
            System.out.println(employee);
        }

    }
}

2.定义个泛型类 DAO，在其中定义一个 Map 成员变量，Map 的键为 String 类型，值为 T 类型。
分别创建以下方法：
public void save(String id,T entity)：保存 T 类型的对象到 Map 成员变量中
public T get(String id)：从 map 中获取 id 对应的对象
public void update(String id,T entity)：替换 map 中 key 为 id 的内容,改为 entity 对象
public List list()：返回 map 中存放的所有 T 对象
public void delete(String id)：删除指定 id 对象
定义一个 User 类：
该类包含：private 成员变量（int 类型） id，age；（String 类型）name。
定义一个测试类：
创建 DAO 类的对象，分别调用其 save、get、update、list、delete 方法来操作 User 对象，
创建测试类进行测试。

public class DAO<T>{
    private Map<String,T> map;

    public DAO() {
    }

    public DAO(Map<String, T> map) {
        this.map = map;
    }
    //public void save(String id,T entity)： 保存 T 类型的对象到 Map 成员变量中
    public void save(String id,T entrity){
        map.put(id, entrity);
    }
    //public T get(String id)：从 map 中获取 id 对应的对象
    public T get(String id){
        return map.get(id);
    }
    //public void update(String id,T entity)：替换 map 中 key 为 id 的内容,改为 entity 对象
    public void update(String id,T entity){
        if (map.containsKey(id)){
            map.put(id,entity);
        }
    }
    //public List<T> list()：返回 map 中存放的所有 T 对象
    public List<T> list(){
        List<T> list=new ArrayList<>();
        Set<Map.Entry<String, T>> entries = map.entrySet();
        for (Map.Entry<String, T> entry : entries) {
            list.add(entry.getValue());
        }
        return list;
    }

    //public void delete(String id)：删除指定 id 对象
    public void delete(String id){
        map.remove(id);
    }
}
public class User {
    private int id;
    private int age;
    private String name;

    public User() {
    }

    public User(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}
public class Exam7 {
    public static void main(String[] args) {

        User user4=new User(1,10,"jane");
        User user1=new User(2,12,"jack");
        User user2=new User(3,10,"jenny");
        User user3=new User(4,11,"joe");

        DAO<User> userDAO=new DAO<>(new HashMap<>());
        userDAO.save("101",user1);
        userDAO.save("102",user2);
        userDAO.save("103",user3);
        userDAO.save("104",user4);

        //修改
        userDAO.update("101",new User(5,15,"Marry"));

        userDAO.get("104");

        List<User> list= userDAO.list();
        System.out.println(list);

        userDAO.delete("102");

        List<User> list2= userDAO.list();
        System.out.println(list2);
    }
}

3.开发一个泛型Apple类，要求有一个重量属性weight
在测试类中实例化不同的泛型对象，
要求
对象a1的这一属性是String类型，
对象a2的这一属性是Integer型，
对象a3的这一属性是Double型。
分别为a1，a2，a3的重量属性赋值为：”500克”，500,500.0，在测试类中通过对象调用访问器得到属性值并输出。
另外思考，为什么a2和a3的属性需要是Integer和Double而不是int和double？

public class Apple<T>{
    private T weight;

    public Apple() {
    }

    public Apple(T weight) {
        this.weight = weight;
    }

    public T getWeight() {
        return weight;
    }

    public void setWeight(T weight) {
        this.weight = weight;
    }

    @Override
    public String toString() {
        return "Apple{" +
                "weight=" + weight +
                '}';
    }
}
public class Test {
    public static void main(String[] args) {
        Apple<Integer> apple1=new Apple<>(200);
        Apple<Double> apple2=new Apple<>(200d);
        Apple<String> apple3=new Apple<>("200");
        System.out.println(apple1);
        System.out.println(apple2);
        System.out.println(apple3);


    }
}

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

public static void main(String[] args) {
        Map<String,Integer> m1=new HashMap<String,Integer>();
        m1.put("张三",800);
        m1.put("李四",1500);
        m1.put("王五",3000);
        m1.put("张三",2600);
        System.out.println(m1);
        Collection<Integer> values = m1.values();
        Set<String> keys = m1.keySet();
        for (String key : keys) {
            Integer value= m1.get(key)+100;
            m1.put(key,value);
        }

        System.out.println(m1);
        //遍历所有的员工
        for (String s : keys) {
            System.out.println(s);
        }
        //遍历所有的工资
        for (Integer value : values) {
            System.out.println(value);

        }
    }

（Map）利用Map，完成下面的功能：
从命令行读入一个字符串，表示一个年份，输出该年的世界杯冠军是哪支球队。如果该年没有举办世界杯，则输出：没有举办世界杯。
附：世界杯冠军以及对应的夺冠年份，请参考本章附录。附录
历届世界杯冠军

届数举办年份举办地点冠军
第一届 1930年乌拉圭乌拉圭
第二届 1934年意大利意大利
第三届 1938年法国意大利
第四届 1950年巴西乌拉圭
第五届 1954年瑞士西德
第六届 1958年瑞典巴西
第七届 1962年智利巴西
第八届 1966年英格兰英格兰
第九届 1970年墨西哥巴西
第十届 1974年前西德西德
第十一届 1978年阿根廷阿根廷
第十二届 1982年西班牙意大利
第十三届 1986年墨西哥阿根廷
第十四届 1990年意大利西德
第十五届 1994年美国巴西
第十六届 1998年法国法国
第十七届 2002年韩日巴西
第十八届 2006年德国意大利
第十九届 2010年南非西班牙
第二十届 2014年巴西德国

public class Exam10 {
    public static void main(String[] args) {
        //创建集合
        TreeMap<Integer,String> mess=new TreeMap<Integer,String>();
        String [] winners={"第一届 1930年 乌拉圭 乌拉圭",
                "第二届	1934年	意大利	意大利",
                "第三届	1938年	法国	意大利",
                "第四届	1950年	巴西	乌拉圭",
                "第五届	1954年	瑞士	西德",
                "第六届	1958年	瑞典	巴西",
                "第七届	1962年	智利	巴西",
                "第八届	1966年	英格兰	英格兰",
                "第九届	1970年	墨西哥	巴西",
                "第十届	1974年	前西德	西德",
                "第十一届	1978年	阿根廷	阿根廷",
                "第十二届	1982年	西班牙	意大利",
                "第十三届	1986年	墨西哥	阿根廷",
                "第十四届	1990年	意大利	西德",
                "第十五届	1994年	美国	巴西",
                "第十六届	1998年	法国	法国",
                "第十七届	2002年	韩日	巴西",
                "第十八届	2006年	德国	意大利",
                "第十九届	2010年	南非	西班牙",
                "第二十届	2014年	巴西	德国"
        };
        int index=1930;
        for (int i = 0; i < winners.length; i++) {
            String value=winners[i];
            mess.put(index,value);
            index+=4;
        }

        System.out.println("请输入年份：");
        Scanner sc=new Scanner(System.in);
        int year=sc.nextInt();
        if (mess.containsKey(year)){
            System.out.println(mess.get(year));
        }else{
            System.out.println("该年没有举办世界杯！");
        }

    }
}

大面积秃头

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java集合练习

（1. 使用HashMap类实例化一个Map类型的对象m1，键（String类型）和值（int型）分别用于存储员工的姓名和工资，存入数据如下：张三——800元；分别为a1，a2，a3的重量属性赋值为：”500克”，500,500.0，在测试类中通过对象调用访问器得到属性值并输出。2.定义个泛型类 DAO，在其中定义一个 Map 成员变量，Map 的键为 String 类型，值为 T 类型。对象a1的这一属性是String类型，第十一届 1978年阿根廷阿根廷。第十三届 1986年墨西哥阿根廷。
复制链接

扫一扫