Java基础-泛型

1. 泛型的作用

• JDK1.5之前只能把元素类型设计为Object，JDK1.5后使用泛型来解决。把元素的类型设计成一个参数，这个类型参数叫做泛型。Collection、List、这个就是类型参数，即泛型

2. 集合中使用泛型

/*泛型的使用
* 1.集合接口或集合类在jdk5时都修改为带泛型的机构
* 2.在实例化集合类时，可以指明具体的泛型类型
* 3.泛型的类型必须是类
* 4.没有指明泛型时，默认Object
* */
public class GenericTest {

    //在集合中使用泛型前的情况
    @Test
    public void test1() {
        ArrayList list = new ArrayList();
        list.add(78);
        list.add(79);
        list.add(75);
        list.add(70);
        //类型不安全
        list.add("Tom");
        for (Object o : list) {
            //强转出现问题
            int score = (int) o;
            System.out.println(score);
        }
    }

    //在集合中使用泛型的情况
    @Test
    public void test2() {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(123);
        list.add(321);
        list.add(122);
//        list.add("Tom");
        for (Integer i : list) {
            //避免强转
            int score = i;
            System.out.println(score);
        }
        Iterator<Integer> iterator = list.iterator();
        while (iterator.hasNext()) {
            iterator.next();
        }
    }
}

3. 自定义泛型结构

//自定义泛型类
public class Order<T> {

    String orderName;
    int orderId;

    //类的内部结构就可以使用类的泛型
    T orderT;

    public Order(String orderName, int orderId, T orderT) {
        this.orderName = orderName;
        this.orderId = orderId;
        this.orderT = orderT;
    }

    public T getOrderT() {
        return orderT;
    }

    public void setOrderT(T orderT) {
        this.orderT = orderT;
    }
    //泛型方法，在方法中出现了泛型的结构，泛型参数与类的泛型没有任何关系
    public <E> List<E> copyFromArrayToList(E[] arr) {
        ArrayList<E> list = new ArrayList<>();
        for (E e : arr) {
            list.add(e);
        }
        return list;
    }
}

public class GenericTest1 {

    @Test
    public void test1() {
        //如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型为Object类型
        Order order = new Order();
        order.setOrderT(123);

        //实例化时指明类的泛型
        Order<String> stringOrder = new Order<>("AA", 1001, "orderAA");
        stringOrder.setOrderT("hello");

        SubOrder subOrder = new SubOrder();
        //public class SubOrder extends Order<Integer>
        //子类在继承带泛型的父类时，指明了泛型类型。实例化子类对象是，不再需要指明泛型
        subOrder.setOrderT(1122);

        //public class SubOrder1<T> extends Order<T>
        SubOrder1<String> subOrder1 = new SubOrder1<>();
        subOrder1.setOrderT("BB");
        
        //泛型不同的 引用不能相互赋值
        ArrayList<String> list1 = null;
        ArrayList<Integer> list = new ArrayList<>();
        //list1=list;
    }
}

4. 通配符的使用

public class GenericTest2 {
    //通配符的使用，通配符？
    //类A是类B的父类，G<A>，G<B>共同的父类是G<?>
    @Test
    public void test1() {
        List<Object> list1 = null;
        List<String> list2 = null;
        List<?> list = null;
        list = list1;
        list = list2;
        print(list1);
        print(list2);

        List<String> list3 = new ArrayList<>();
        list3.add("AA");
        list3.add("BB");
        list = list3;
        //添加，对于List<?>除了null不能向其内部添加数据
        //list.add(?);
        list.add(null);
        //读取，允许读取数据，读取的数据类型为Object
        Object o = list.get(0);
        System.out.println(o);
    }

    public void print(List<?> list) {
        Iterator<?> iterator = list.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println(next);
        }
    }

    /*有限制条件的通配符的使用
    * ? extends A
    * ? super A
    * */
    @Test
    public void test2() {
        List<? extends Order> list1 = null;
        List<? super Order> list2 = null;

        List<SubOrder> list3 = null;
        List<Order> list4 = null;
        List<Object> list5 = null;
        list1 = list3;
        list1 = list4;
        //list1 = list5;
        //list2 = list3;
    }
}

5. 具体使用

public class DAO<T> {
    private 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) {
        if (map.containsKey(id)) {
            map.put(id, entity);
        }
    }

    public List<T> list() {
        List<T> list = new ArrayList<>();
        Collection<T> values = map.values();
        for (T t : values) {
            list.add(t);
        }
        return list;
    }

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

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        User user = (User) o;

        if (id != user.id) return false;
        if (age != user.age) return false;
        return name != null ? name.equals(user.name) : user.name == null;
    }

    @Override
    public int hashCode() {
        int result = id;
        result = 31 * result + age;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        return result;
    }
}

public class DAOTest {
    public static void main(String[] args) {
        DAO<User> userDAO = new DAO<User>();
        userDAO.save("1001", new User(1001, 32, "zhou"));
        userDAO.update("1001", new User(1001, 23, "zou"));
        List<User> list = userDAO.list();
        list.forEach(System.out::println);
    }
}