【JAVA学习】泛型-CSDN博客

本文链接：https://blog.csdn.net/weixin_51718998/article/details/148089001

传统方法不能对加入到集合ArrayList中的数据类型进行约束，遍历的时候需要进行类型转换，如果集合中的数据量较大，对效率有影响。泛型又称参数化类型，是JDK5.0出现的新特性，解决数据类型的安全性问题，在类声明或实例化时只要指定好需要的具体类型即可。

泛型的好处：1）编译时，检查添加元素的类型，提高了安全性。2）减少了类型转换的次数，提高效率。Dog->Dog->Dog

不加泛型的话：Dog加入->Object取出->Dog

泛型的语法<T>{}和class类<K,V>{}

package com.edu.generic;

import java.util.*;

/**
 * @author JQY
 * @version 1.0
 */
public class GenericExercise {
    public static void main(String[] args) {
        HashSet<Student> students = new HashSet<Student>();
        students.add(new Student("john",20));
        students.add(new Student("tom",21));
        students.add(new Student("mary",23));
        for (Student student :students) {
            System.out.println(student.getAge()+"-"+student.getName());
        }

        //HashMap
        HashMap<String,Student> studentHashMap = new HashMap<String,Student>();
        studentHashMap.put("rose",new Student("rose",32));
        studentHashMap.put("jack",new Student("jack",22));
        studentHashMap.put("celine",new Student("celine",12));
        Set<Map.Entry<String, Student>> entries = studentHashMap.entrySet();
        Iterator<Map.Entry<String, Student>> iterator = entries.iterator();
        System.out.println("=======迭代器======");
        while (iterator.hasNext()) {
            Map.Entry<String, Student> next =  iterator.next();
            System.out.println(next.getKey()+"-"+next.getValue());

        }

    }
}
class Student{
    private String name;
    private int age;

    public Student(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;
    }

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

package com.edu.generic;

import java.util.ArrayList;
import java.util.Comparator;

/**
 * @author JQY
 * @version 1.0
 */
public class Generic03 {
    public static void main(String[] args) {
        ArrayList<Employee> employees = new ArrayList<>();
        employees.add(new Employee("a",2000,new MyDate(10,5,2002)));
        employees.add(new Employee("c",1400,new MyDate(5,10,2003)));
        employees.add(new Employee("b",1800,new MyDate(8,25,2001)));
        System.out.println("employees"+employees);
        System.out.println("====对员工名字排序====");
        employees.sort(new Comparator<Employee>() {
            @Override
            public int compare(Employee o1, Employee o2) {
                //先对传入的参数进行验证，不能为空而且得是employee
                if (!(o1 instanceof Employee && o2 instanceof Employee)){
                    return 0;
                }
                int i = o1.getName().compareTo(o2.getName());
                if(i!=0){
                    return i;
                }
                //如果name相同，就比较brithday-year
                int yearminus = o1.getBrithday().getYear()- o2.getBrithday().getYear();
                if(yearminus!=0){
                    return yearminus;
                }
                //如果年相同就比较month
                int monthminus = o1.getBrithday().getMonth()- o2.getBrithday().getMonth();
                if(monthminus!=0){
                    return monthminus;
                }
                //如果月相同就比较日
                return o1.getBrithday().getDay()- o2.getBrithday().getDay();
            }
        });
        System.out.println(employees);
    }
}
class Employee{
    private String name;
    private double sal;
    private MyDate brithday;

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

    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 getBrithday() {
        return brithday;
    }

    public void setBrithday(MyDate brithday) {
        this.brithday = brithday;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", sal=" + sal +
                ", brithday=" + brithday +
                '}';
    }
}
class MyDate{
    private int month;
    private int day;
    private int year;

    public MyDate(int month, int day, int year) {
        this.month = month;
        this.day = day;
        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;
    }

    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…>{成员

}普通成员可以使用泛型，使用泛型的数组，不能初始化。静态方法中不能使用类的泛型。泛型类的类型，是在创建对象时确定的。如果在创建对象时，没有指定类型，默认为Object。

public void eat(E e){}，修饰符后没有<T,R…>eat方法不是泛型方法，而是使用了泛型。

package com.edu.generic;

import org.junit.Test;

import java.util.*;

/**
 * @author JQY
 * @version 1.0
 */
public class CustomMethodGenericExercise {
    public static void main(String[] args) {
        DAO<User> dao = new DAO<>();
        dao.save("001",new User(1,16,"jack"));
        dao.save("002",new User(2,13,"milan"));
        dao.save("003",new User(1,20,"rose"));

        List<User> list = dao.list();
        System.out.println("list="+list);

    }
//    @Test
//    public void testList(){
//        DAO<User> dao = new DAO<>();
//        dao.save("001",new User(1,16,"jack"));
//        dao.save("002",new User(2,13,"milan"));
//        dao.save("003",new User(1,20,"rose"));
//
//        List<User> list = dao.list();
//        System.out.println("list="+list);
//
//    }
}

class User{
    private int id;
    private int age;
    private String name;

    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 + '\'' +
                '}';
    }
}

//定义泛型类
class DAO<T>{
    private Map<String,T> map = new HashMap<>();
    public T get(String id){
        return map.get(id);
    }
    public void updates(String id,T entity){
        map.put(id,entity);
    }
    //遍历map中所有的T对象，遍历map的[K-V]
    //将map的所有value(T entity),封装到ArrayList返回即可
    
    public List<T> list(){
        List<T> list = new ArrayList<>();
        Set<String> keyset = map.keySet();
        for (String key :keyset) {
            list.add(map.get(key));
        }
        return list;
    }
    public void delete(String id){
        map.remove(id);
    }
    public void save(String id,T entity){
        map.put(id,entity);
    }
}