【JAVA学习】泛型
传统方法不能对加入到集合ArrayList中的数据类型进行约束，遍历的时候需要进行类型转换，如果集合中的数据量较大，对效率有影响。泛型又称参数化类型，是JDK5.0出现的新特性，解决数据类型的安全性问题，在类声明或实例化时只要指定好需要的具体类型即可。
泛型的好处：1）编译时，检查添加元素的类型，提高了安全性。2）减少了类型转换的次数，提高效率。Dog->Dog->Dog
不加泛型的话：Dog加入->Object取出->Dog
泛型的语法
package com.edu.generic;
import java.util.*;
/**
* @author JQY
* @version 1.0
*/
public class GenericExercise {
public static void main(String[] args) {
HashSet students = new HashSet();
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 studentHashMap = new HashMap();
studentHashMap.put("rose",new Student("rose",32));
studentHashMap.put("jack",new Student("jack",22));
studentHashMap.put("celine",new Student("celine",12));
Set> entries = studentHashMap.entrySet();
Iterator> iterator = entries.iterator();
System.out.println("=======迭代器======");
while (iterator.hasNext()) {
Map.Entry 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 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() {
@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 类名
}普通成员可以使用泛型，使用泛型的数组，不能初始化。静态方法中不能使用类的泛型。泛型类的类型，是在创建对象时确定的。如果在创建对象时，没有指定类型，默认为Object。
public void eat(E e){}，修饰符后没有
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 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 list = dao.list();
System.out.println("list="+list);
}
// @Test
// public void testList(){
// DAO 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 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{
private Map 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 list(){
List list = new ArrayList<>();
Set 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);
}
}