// Collection 常用方法
public class Collection01 {
    @SuppressWarnings({"all"})  // 消除警告
    public static void main(String[] args) {
        // 添加元素
        List list = new ArrayList();
        list.add("西游记");
        list.add("水浒传");
        System.out.println(list);

        // 批量添加元素
        List list1 = new ArrayList();
        list1.add("射雕英雄传");
        list1.add("神雕侠侣");
        list.addAll(list1);
        System.out.println(list);

        // 查找元素
        System.out.println(list.contains("三国演义"));

        // 批量查找
        System.out.println(list.containsAll(list1));

        // 判断集合是否为空
        System.out.println(list.isEmpty());

        // 获取元素个数
        System.out.println(list.size());

        // 删除单个元素
        list.remove("神雕侠侣");
        System.out.println(list);

        // 删除多个元素
        list.removeAll(list1);
        System.out.println(list);

        // 清空集合
        list.clear();
        System.out.println(list);
    }
}

// 迭代器 的使用方法
public class Iterator01 {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(new Book("西游记","罗贯中",100));
        list.add(new Book("红楼梦","不知道",130));
        list.add(new Book("水浒传","施耐庵",99));

        // 得到 集合list 对应的 迭代器
        Iterator iterator = list.iterator();

        // 使用快捷方式 itit, 快速创建遍历循环
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println(obj);
        
        // 再次遍历时，需要对迭代器进行重置
        iterator = list.iterator();
            
        // 使用快捷方式 itit, 快速创建遍历循环
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println(obj);

        }
    }
}

class Book{
    private String name;
    private String author;
    private double price;

    public Book(String name, String author, double price) {
        this.name = name;
        this.author = author;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return  name + author + price + "";
    }
}

for（元素类型 元素名：集合名/数组名）{
    访问元素
}

// 增强 for 循环
public class Iterator01 {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(new Book("西游记","罗贯中",100));
        list.add(new Book("红楼梦","不知道",130));
        list.add(new Book("水浒传","施耐庵",99));
        
        // 增强 for 循环
        for (Object obj:list) {
            System.out.println(obj);
        }
    }
}

// List 接口常用方法 - 案例
public class List01 {
    @SuppressWarnings({"ALL"})
    public static void main(String[] args) {
        List list = new ArrayList();
        // void add(int index, Object ele):	在 index 位置插入 ele 元素
        list.add(0,"钢铁侠");
        list.add(1,"蜘蛛侠");
        list.add(2,"绿巨人");
        System.out.println(list);

        // boolean addAll(int index, Collection eles):	从 index 位置开始将 eles 中的所有元素添加进来
        List list1 = new ArrayList();
        list1.add(0,"黑寡妇");
        list1.add(1,"美国队长");
        list1.add(2,"黑豹");
        list1.add(3,"蜘蛛侠");
        list.addAll(3,list1);
        System.out.println(list1);
        
        // Object get(int index):	获取 index 位置的元素
        System.out.println(list.get(4));

        // int indexOf(Object obj):	返回 obj 在集合中首次出现的位置
        System.out.println(list.indexOf("蜘蛛侠"));

        // int lastIndexOf(Object obj):	返回 obj 在集合中 末次出现的位置
        System.out.println(list.lastIndexOf("蜘蛛侠"));

        // Object remove(int index):	移除 index 位置的元素，并返回此元素
        System.out.println(list.remove(6));
        System.out.println(list.remove("黑寡妇"));

        // Object set(int index,Object ele):	对 index 位置的元素 重新赋值
        list.set(2,"版纳博士");
        System.out.println(list);

        // List subList(int formIndex, int toIndex):	返回 从 fromIndex 到 toIndex 位置的子集合
        System.out.println(list.subList(3,list.size()));
    }
}

// 执行结果----------------------------------------
[钢铁侠, 蜘蛛侠, 绿巨人]
[黑寡妇, 美国队长, 黑豹, 蜘蛛侠]
美国队长
1
6
蜘蛛侠
true
[钢铁侠, 蜘蛛侠, 版纳博士, 美国队长, 黑豹]
[美国队长, 黑豹]

//  书本排序 案例
public class List03 {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add(0,new Book("西游记","吴承恩",200));
        arrayList.add(1,new Book("红楼梦","曹雪芹",150));
        arrayList.add(2,new Book("三国志","罗贯中",220));
        System.out.println(arrayList);
        
        sort(arrayList);
        for (Object o:arrayList){
            System.out.println(o);
        }
        
    }
    // 价格从大到小排序
    public static void sort(ArrayList list){
        int size = list.size();
        for (int i = 0; i < size - 1; i++) {
            for (int j = 0; j < size - 1 - i; j++) {
                Book book1 = (Book) (list.get(j));
                Book book2 = (Book) (list.get(j + 1));
                if (book1.getPrice() < book2.getPrice()){
                    list.set(j, book2);
                    list.set(j+1, book1);
                }
                
            }
        }
    }
}

class Book{
    private String name;
    private String author;
    private double price;
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public String getAuthor() {
        return author;
    }
    
    public void setAuthor(String author) {
        this.author = author;
    }
    
    public double getPrice() {
        return price;
    }
    
    public void setPrice(double price) {
        this.price = price;
    }
    
    public Book(String name, String author, double price) {
        this.name = name;
        this.author = author;
        this.price = price;
    }
    
    @Override
    public String toString() {
        return String.format("名称: %s\t\t 价格: %.2f\t\t 作者: %s",name,price,author);
    }
}

// Set - 案例
public class Set01 {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        HashSet hashSet = new HashSet();

        // 添加元素
        for (int i = 0; i < 5; i++) {
            hashSet.add("set - " + i);
        }
        System.out.println(hashSet);

        // 遍历元素
        Iterator iterator = hashSet.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println(next);
        }

        // 删除元素
        hashSet.remove("set - 2");
        System.out.println(hashSet);
    }
}

// HashSet - 案例
public class HashSet01 {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        HashSet hs = new HashSet();
        hs.add(new Employee("老王",18));
        hs.add(new Employee("张三",21));
        hs.add(new Employee("李四",13));
        hs.add(new Employee("老王",18));
        System.out.println(hs);

    }
}

class Employee{
    private String name;
    private int age;

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

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

    // 重写 equals 和 hashCode 方法
    // 如果 equals 和 hashCode 相同,则不加入链表,如果不同,则加入链表最后边
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee employee = (Employee) o;
        return age == employee.age && Objects.equals(name, employee.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "Employee{" + name + '\'' + age +'}';
    }
}

// 运行结果
[Employee{张三'21}, Employee{老王'18}, Employee{李四'13}]

// HashSet - 案例(多个自定义类)
package com.jihe.set_;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Objects;

/**
 * @author Pupper
 * @email pupper.cheng@gmail.com
 */
public class HashSet02 {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        HashSet hs = new HashSet();
        hs.add(new Employee1("张三",10000,new MyDate(1980,2,2)));
        hs.add(new Employee1("李四",12000,new MyDate(1982,4,7)));
        hs.add(new Employee1("王五",16000,new MyDate(1979,12,2)));
        hs.add(new Employee1("张三",18000,new MyDate(1980,2,2)));

        Iterator iterator = hs.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println(next);
        }
    }
}

class Employee1{
    private String name;
    private double asl;
    private MyDate birthday;

    public Employee1(String name, double asl, MyDate birthday) {
        this.name = name;
        this.asl = asl;
        this.birthday = birthday;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getAsl() {
        return asl;
    }

    public void setAsl(double asl) {
        this.asl = asl;
    }

    public MyDate getBirthday() {
        return birthday;
    }

    public void setBirthday(MyDate birthday) {
        this.birthday = birthday;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Employee1 employee1 = (Employee1) o;
        return Objects.equals(name, employee1.name) && Objects.equals(birthday, employee1.birthday);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, birthday);
    }

    @Override
    public String toString() {
        return "Employee1{" +
                "name='" + name + '\'' +
                ", asl=" + asl +
                ", birthday=" + birthday +
                '}';
    }
}

class MyDate{
    private int year;
    private int month;
    private int day;

    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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        MyDate myDate = (MyDate) o;
        return year == myDate.year && month == myDate.month && day == myDate.day;
    }

    @Override
    public int hashCode() {
        return Objects.hash(year, month, day);
    }
}

// LinkedHashSet - 案例
public class LinkedHashSet02 {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        Set lhs = new LinkedHashSet();
        lhs.add(new Car("保时捷",900000));
        lhs.add(new Car("纳智捷",100000));
        lhs.add(new Car("保时捷",900000));
        lhs.add(new Car("奥迪",666666));

        Iterator it = lhs.iterator();
        while (it.hasNext()) {
            Object o = it.next();
            System.out.println(o);
        }
    }

}

class Car{
    private String name;
    private double price;

    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 boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Car car = (Car) o;
        return Double.compare(car.price, price) == 0 && Objects.equals(name, car.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, price);
    }

    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

// TreeSet 有参构造器 - 有序
// 匿名内部类
TreeSet treeSet = new TreeSet(new Comparator(){
    @Override
    public int compare(Object o1, Object o2){
        // 根据 ASCii 码进行排序
        return ((String)o2).compareTo((String) o1);
    };
});

// 从大到小排序 - 案例
public class TreeSet1 {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        // 使用匿名内部类,重写排序方法
        TreeSet t = new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                // 从大到小排序
                return ((String)o2).compareTo((String) o1);
            }
        });
        t.add("a1");
        t.add("b3");
        t.add("d6");
        t.add("c4");

        System.out.println(t);
    }
}

// 运行结果
[d6, c4, b3, a1]

// Map 常用方法
public class Map01 {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        HashMap hm = new HashMap();
        // 判断集合是否为空,返回布尔值
        System.out.println(hm.isEmpty());

        // 添加元素
        hm.put("张三",18);
        hm.put("李四",20);
        hm.put("王五",30);
        hm.put("赵六",18);
        System.out.println(hm);

        // 如果 key 相同,则更新值
        hm.put("张三",99);
        System.out.println(hm);

        // 删除元素
        System.out.println(hm.remove("王五"));

        // 获取元素
        System.out.println(hm.get("张三"));

        // 判断 key value 是否存在
        System.out.println(hm.containsKey("123"));
        System.out.println(hm.containsKey("李四"));

        // 获取 key value 的集合
        System.out.println(hm.keySet());
        System.out.println(hm.values());
        
        // 通过 EntrySet 来获取 k-v
        Set entrySet = hm.entrySet();
        for (Object entry : entrySet) {
            // 将 entry 向下转型为 Map.Entry
            Map.Entry m = (Map.Entry) entry;
            System.out.println(m.getKey() + "-" + m.getValue());
        }

        // 清空集合
        hm.clear();
        System.out.println(hm);
    }
}

// 运行结果
true
{李四=20, 张三=18, 王五=30, 赵六=18}
{李四=20, 张三=99, 王五=30, 赵六=18}
30
99
false
true
[李四, 张三, 赵六]
[20, 99, 18]
李四-20
张三-99
赵六-18
{}

// HashMap - 案例
public class Map02 {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        HashMap hashMap = new HashMap();
        hashMap.put("001",new Person("001","张三",20000));
        hashMap.put("002",new Person("002","李四",12000));
        hashMap.put("003",new Person("003","王五",26000));
        hashMap.put("004",new Person("004","赵六",18000));

        Set keySet = hashMap.keySet();
        for (Object value :keySet) {
            // 向下转型
            Person p = (Person) hashMap.get(value);
            if (p.getSal() > 18000){
                System.out.println(p);
            }
        }
    }
}

class Person{
    private String name,id;
    private double sal;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getId() {
        return id;
    }

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

    public double getSal() {
        return sal;
    }

    public void setSal(double sal) {
        this.sal = sal;
    }

    public Person(String id,String name, double sal) {
        this.name = name;
        this.id = id;
        this.sal = sal;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", id='" + id + '\'' +
                ", sal=" + sal +
                '}';
    }
}

// HashTable - 案例
public class HashTable01 {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        Hashtable hashtable = new Hashtable();

        // 添加
        hashtable.put("001","张三");
        hashtable.put("002","李四");
        hashtable.put("003","王五");
        System.out.println(hashtable);

        // 修改
        hashtable.put("001","令狐冲");
        System.out.println(hashtable);

        // 删除
        hashtable.remove("003");
        System.out.println(hashtable);

        // null 报错,NullPointerException
         hashtable.put(null,"test");
        // hashtable.put("test",null);
    }
}

// Properties - 案例
public class Properties01 {
    public static void main(String[] args) {
        Properties p = new Properties();

        // 增加
        p.put("001","张三疯");
        p.put("002","张三丰");
        p.put("003","张君宝");
        System.out.println(p);

        // 修改
        p.put("001","张无忌");
        System.out.println(p);

        // 获取值
        System.out.println(p.get("002"));

        // 删除
        p.remove("003");
        System.out.println(p);
    }
}

// TreeMap - 案例
public class TreeMap1 {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        // 使用匿名内部类,重写排序方法
        TreeMap t = new TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                // 从大到小排序,以 key 的 ASCII 码排序
                return ((String)o2).compareTo((String) o1);
            }
        });
        t.put("a1","张三");
        t.put("b2","李四");
        t.put("d4","王五");
        t.put("c3","赵六");

        System.out.println(t);
    }
}

// 运行结果
{d4=王五, c3=赵六, b2=李四, a1=张三}

// Collection 工具类 - 排序 案例
public class Collections1 {
    public static void main(String[] args) {
        ArrayList al = new ArrayList();
        al.add("张三");
        al.add("张三疯");
        al.add("张山峰");
        al.add("张三芬");
        System.out.println("原始数组= "+al);

        // 反转排序
        Collections.reverse(al);
        System.out.println("反转排序= "+al);

        // 随机排序
        Collections.shuffle(al);
        System.out.println("随机排序= " + al);

        // 自然排序
        Collections.sort(al);
        System.out.println("根据元素自然排序= "+ al);

        // 自定义排序
        Collections.sort(al, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                // 从大到小排序,以 key 的 ASCII 码排序
                return ((String)o2).compareTo((String) o1);
            }
        });
        System.out.println("自定义排序(从大到小)= "+ al);

        // 元素位置交换
        Collections.swap(al,1,2);
        System.out.println("下标 1 和 2 互换位置" + al);
    }
}

// Collections - 查找、替换 案例
public class Collections1 {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        ArrayList al = new ArrayList();
        al.add("张三");
        al.add("欧阳疯子");
        al.add("鸡儿拖洛夫斯基");
        al.add("张三芬");
        al.add("张三");
        System.out.println("原始数组= "+al);

        // 获取最大值
        System.out.println("最大值= " + Collections.max(al));

        // 根据规则排序,获取最大值
        Object maxs = Collections.max(al, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                return ((String)o1).length() - ((String)o2).length();
            }
        });
        System.out.println("最大值= "+ maxs);

        // 查看元素出现的次数
        System.out.println("元素出现的次数= "+ Collections.frequency(al,"张三"));

        // 复查集合
        // 新的集合元素个数需要和旧的元素集合个数一致,否则报错
        ArrayList al1 = new ArrayList();
        for(int i = 0; i< al.size(); i++){
            al1.add(null);
        }
        Collections.copy(al1, al);
        System.out.println(al1);

        // 替换集合元素
        Collections.replaceAll(al, "张三", "张无忌");
        System.out.println(al);
    }
}

// 创建两个新闻，处理标题，倒序输出
public class HomeWork1 {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        ArrayList al = new ArrayList();
        al.add(new News("新冠确诊病例超千万,数百万印度教信徒赶赴恒河\"圣浴\"引民众担忧"));
        al.add(new News("男子突然想起 2 月前钓的鱼还在网兜里,捞起一看赶紧放生"));

        //倒序遍历
        Collections.reverse(al);
        Iterator iterator = al.iterator();
        while (iterator.hasNext()) {
            Object o = iterator.next();
            // 方式一
            // 向下转型
            News news = (News) o;
            if (news.getTitle().length() > 15){
                // 截取字符串,进行拼接
                String title = news.getTitle().substring(0,15) + "...";
                news.setTitle(title);
            }
            System.out.println(o);
        }

    }
}

class News {
    private String title, body;

    public News(String title) {
        this.title = title;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    @Override
    public String toString() {
        // 方式二
        //return title.length() > 15 ? title.substring(0, 15) + "..." : title;
        return title;
    }

    public String getBody() {
        return body;
    }

    public void setBody(String body) {
        this.body = body;
    }
}

// 运行结果
男子突然想起 2 月前钓的鱼还...
新冠确诊病例超千万,数百万印度...

// 创建两个新闻，处理标题，倒序输出
public class HomeWork2 {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        HashMap hm = new HashMap();
        hm.put("jack",650);
        hm.put("tom",1200);
        hm.put("smith",2900);
        System.out.println(hm);

        // 修改 jack 的工资
        hm.put("jack",2600);
        System.out.println("修改 jack 的工资= " + hm);

        // 为所有员工工资加薪 100
        for (Object o : hm.keySet()) {
            hm.put(o,(int)hm.get(o) + 100);
        }
        System.out.println("全体加薪 100=" + hm);

        // 遍历所有 员工
        Iterator i = hm.keySet().iterator();
        while (i.hasNext()) {
            Object o = (String) i.next();
            System.out.println(o);
        }

        // 遍历所有 工资
        for (Object o :hm.values()) {
            System.out.println(o);
        }
    }
}

// 运行结果
{tom=1200, smith=2900, jack=650}
修改 jack 的工资= {tom=1200, smith=2900, jack=2600}
全体加薪 100={tom=1300, smith=3000, jack=2700}
tom
smith
jack
1300
3000
2700

interface 接口<T>
class 类<K,V>{}

public class Generic01 {
    public static void main(String[] args) {
        // 指定对象 E 的数据类型
        Person<String> per = new Person<>("1");
        per.f();
    }
}

class Person<E>{
    // E 表示 s 的数据类型在创建对象时指定
    E s;

    // 表示参数类型使用 E
    public Person(E s){
        this.s = s;
    }

    // 表示返回类型使用 E
    public E f(){
        return s;
    }
}

// 对员工进行排序，（先按名称排序，再按生日排序）
public class Generic03 {
    public static void main(String[] args) {
        ArrayList<Employee> e = new ArrayList<>();
        e.add(new Employee("Jack",20000,new MyDate(2,22,1999)));
        e.add(new Employee("Jack",20000,new MyDate(1,22,1999)));
        e.add(new Employee("Tom",18000,new MyDate(9,9,2003)));
        e.add(new Employee("Rose",12000,new MyDate(12,2,1988)));
        e.add(new Employee("Jack",20000,new MyDate(1,21,1999)));
        e.add(new Employee("Jack",20000,new MyDate(1,22,1979)));

        for (Object o :e) {
            System.out.println(o);
        }

        e.sort(new Comparator<Employee>() {
            @Override
            public int compare(Employee o1, Employee o2) {
                int res = (o1.getName()).compareTo(o2.getName());
                if (res != 0){
                    return res;
                }
                return o1.getBirthday().compareTo(o2.getBirthday());
            }
        });
        System.out.println("=========排序后=========");
        for (Object o :e) {
            System.out.println(o);
        }

    }
}

class Employee{
    private String name;
    private double sal;
    private MyDate birthday;

    public Employee(String name, double sal, MyDate birthday) {
        this.name = name;
        this.sal = sal;
        this.birthday = birthday;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getSal() {
        return sal;
    }

    public void setSal(double sal) {
        this.sal = sal;
    }

    public MyDate getBirthday() {
        return birthday;
    }

    public void setBirthday(MyDate birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", sal=" + sal +
                ", birthday=" + birthday +
                '}';
    }
}

class MyDate implements Comparable<MyDate>{
    private int month,day,year;

    public MyDate(int month, int day, int year) {
        this.month = month;
        this.day = day;
        this.year = year;
    }

    // 重写 比较方法
    @Override
    public int compareTo(MyDate o) {
        int resYear = year - o.getYear();
        if (resYear != 0){
            return resYear;
        }

        int resMonth = month - o.getMonth();
        if (resMonth != 0){
            return resMonth;
        }

        return day - o.getDay();
    }

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

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

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

// 泛型标识可以有多个
class 类名 <T,R...>{
    成员
}

// 自定义泛型
public class Generic01 {
    public static void main(String[] args) {
        Test<Double, String, Integer> test = new Test<>();
        test.setD(3.1);
        test.setS("老王");
    }
}

class Test<D,S,I>{
    // 属性使用泛型
    private D d;
    private S s;
    private I i;

    // 方法使用 泛型
    public D getD() {
        return d;
    }

    public void setD(D d) {
        this.d = d;
    }

    public S getS() {
        return s;
    }

    public void setS(S s) {
        this.s = s;
    }

    public I getI() {
        return i;
    }

    public void setI(I i) {
        this.i = i;
    }
}

// 泛型标识可以有多个
interface 接口名 <T,R...>{
    成员
}

// 接口泛型
interface IUsb<U, R> {
    // 静态属性成员不能使用泛型
    // U name; 
    
    R get(U u);
    // 抽象方法
    void hi(R r);

    void run(R r1, R r2, U u1,U u2);

    default R method(U u) {
        return null;
    }
}

// 继承接口时需要指定泛型的类型
interface Ib extends IUsb<String, Double>{

}

// 实现接口时,指定泛型的类型
class Fa implements IUsb<Integer,Float>{
    @Override
    public Float get(Integer integer) {
        return null;
    }

    @Override
    public void hi(Float aFloat) {

    }

    @Override
    public void run(Float r1, Float r2, Integer u1, Integer u2) {

    }
}

修饰符<T,R...> 返回类型 方法名(参数列表){}

// 泛型方法
public class MethodGeneric {
    public static void main(String[] args) {
        Car car = new Car();
        // 调用方法时,自动确定 泛型的类型
        car.eat("老王", 18);
    }
}

class Car{
    // 普通方法
    public void run(){};

    //泛型方法
    public <T,R> void eat(T t, R r){}
}

class Fish<E>{
    // 泛型方法, 方法使用了泛型, 自己声明
    public void eat(E e){}

    // 泛型方法 定义了泛型, 类声明
    public<X> void cat(X x){}
}

// 通配符的使用
public class GenericExtends01 {
    public static void main(String[] args) {
        List<Object> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        List<AA> list3 = new ArrayList<>();
        List<BB> list4 = new ArrayList<>();
        List<CC> list5 = new ArrayList<>();

        // <?> : 表示支持任意泛型类型;
        collection1(list1);
        collection1(list2);
        collection1(list3);
        collection1(list4);
        collection1(list5);

        // <? extends A> : 表示支持 A 类 以及 A 类的子类, 规定了 泛型的上限;
        collection2(list1);     // 报错 Object
        collection2(list2);     // 报错 String
        collection3(list3);
        collection2(list4);
        collection2(list5);

        // <? super A> : 表示支持 A 类 以及 A 类的父类, 规定了泛型的 下限;
        collection3(list1);
        collection3(list2);     // 报错   String
        collection3(list3);
        collection3(list4);     // 报错   BB
        collection3(list5);     // 报错   CC
    }

    public static void collection1(List<?> list){};
    public static void collection2(List<? extends AA> list){};
    public static void collection3(List<? super AA> list){};
}

class AA{}

class BB extends AA{}

class CC extends BB{}

// JUnit 使用
public class JUnit01 {
    public static void main(String[] args) {

    }

    @Test
    public void m1(){
        System.out.println("m1被调用");
    }

    @Test
    public void m2(){
        System.out.println("m2被调用");
    }
}

public class HomeWork01 {
    public static void main(String[] args) {

    }

    @Test
    public void tests(){
        DAO<User> dao = new DAO<>();
        dao.save("1001",new User(1001,20,"tom"));
        dao.save("1002",new User(1002,20,"jack"));
        dao.save("1003",new User(1003,20,"wear"));
        dao.save("1004",new User(1004,20,"sam"));

        System.out.println(dao.list());
    }

}

class DAO<T>{
    Map<String,T> map = new HashMap<>();

    public void save(String id, T entity){
        map.put(id, entity);
    }

    public T get(String id){
        return map.get(id);
    }

    public void update(String id, T entity){
        map.put(id, entity);
    }

    public List<T> list(){
       List<T> list = new ArrayList<>();
        for (String key : map.keySet()) {
            list.add(get(key));
        }
        return list;
    }
    public void delete(String id){
        map.remove(id);
    }
}

class User{
    private int id,age;
    private String 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;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}