Java基礎之：泛型
在不使用泛型的情況下，在ArrayList 中，添加3個Dog，
Dog物件含有name 和 age, 并輸出name 和 age (要求使用getXxx())，
package class_Generic;
import java.util.ArrayList;
?
public class ClassTest01 {
?
@SuppressWarnings({ "rawtypes", "unchecked" })
public static void main(String[] args) {
ArrayList dog = new ArrayList();
dog.add(new Dog("旺財",2));
dog.add(new Dog("來福",4));
dog.add(new Dog("小黑",6));
for (Object obj : dog) {
Dog temp = (Dog)obj;
System.out.println(temp);
}
//使用泛型改進
//"<>"尖括號內應寫入期望在ArrayList中存放的元素的型別或父類，
ArrayList<Dog> dogList = new ArrayList<Dog>();
dogList.add(new Dog("旺財",2));
dogList.add(new Dog("來福",4));
dogList.add(new Dog("小黑",6));
for (Dog d : dogList) { //在使用dogList內元素時，編譯型別可以直接使用Dog
System.out.println(d);
}
}
}
class Dog{
private String name;
private Integer age;
public Dog(String name, Integer age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "Dog [name=" + name + ", age=" + age + "]";
}
}
?
總結：可以看到在不適用泛型的情況下，每次取出ArrayList中的物件都需要使用Object型別，需要向下轉型才可以獲得原來的資料型別Dog，而使用泛型指定之后讓ArrayList中取出的元素直接就是Dog型別，但同時在加入元素時也只加入Dog型別及其子類的實體物件，而若不適用泛型，那么加入到ArrayList中的元素型別不受約束(不安全)，
泛型介紹
-
泛型又稱引數化型別，是jdk5.0出現的新特性，解決資料型別的安全性問題，
-
Java 泛型可以保證如果程式在編譯時沒有發出警告，那么在運行時就不會出現ClassCastException例外，
-
在類宣告時通過一個標識來表示類中某個屬性的型別或是某個方法的回傳值及引數型別，
泛型實體化
在類名后面指定引數型別的值(型別)，
package com.atguigu.generic;
import java.util.ArrayList;
import java.util.HashMap;
public class Generic02 {
public static void main(String[] args) {
//給public class ArrayList<E> {}
//解讀
//給 E泛型 傳入型別String
//表我們可以給al放入的String, 或者是它的子型別
ArrayList<String> al = new ArrayList<String>();
al.add("tt");
al.add("hello");
//使用HashMap
//public class HashMap<K,V> {}
//解讀
//1. K 指定為 String
//2. V 指定為 Customer
//3. 當我們使用hm 時，編譯器，就會約束 加入 的 k 是String , v 就是 Customer
HashMap<String, Customer> hm = new HashMap<String, Customer>();
hm.put("hello1", new Customer());
hm.put("100", new Person());//多型
HashMap<String, IMy> hm2 = new HashMap<String, IMy>();
hm2.put("200", new Tiger());
}
}
interface IMy {
}
?
class Tiger implements IMy {
}
?
class Customer {
}
?
class Person extends Customer {
}
?
泛型使用
創建 3個學生物件，放入到 HashMap中，要求 Key 是 String, name, 使用泛型, Value 就是 學生物件，使用兩種方式遍歷
package class_Generic;
?
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
?
public class ClassWork01 {
?
public static void main(String[] args) {
?
HashMap<String , Student> hashMap = new HashMap<>();
Student student1 = new Student("小范");
Student student2 = new Student("小黃");
Student student3 = new Student("小雨");
hashMap.put(student1.getName(),student1);
hashMap.put(student2.getName(),student2);
hashMap.put(student3.getName(),student3);
Set<String> keySet = hashMap.keySet();
for (String string : keySet) {
System.out.println("key:" + string + ",value:" + hashMap.get(string));
}
System.out.println("===========================");
Set<Entry<String, Student>> entrySet = hashMap.entrySet();
Iterator<Entry<String, Student>> iterator = entrySet.iterator();
while(iterator.hasNext()) {
Map.Entry<String, Student> node = iterator.next();
System.out.println("key:" + node.getKey() + ",value:" + node.getValue());
}
}
?
}
class Student{
private String name;
?
public Student(String name) {
this.name = name;
}
?
@Override
public String toString() {
return "Student [name=" + name + "]";
}
?
public String getName() {
return name;
}
?
public void setName(String name) {
this.name = name;
}
}
泛型練習題
定義Employee類
1) 該類包含：private成員變數name,age,birthday，其中 birthday 為 MyDate 類的物件；
2) 為每一個屬性定義 getter, setter 方法；
3) 重寫 toString 方法輸出 name, age, birthday
4) MyDate類包含: private成員變數month,day,year；并為每一個屬性定義 getter, setter 方法；
5) 創建該類的 3 個物件，并把這些物件放入 ArrayList 集合中（ArrayList 需使用泛型來定義），對集合中的元素進行排序，并遍歷輸出：
排序方式： 呼叫ArrayList 的 sort 方法 , 傳入 Comparator物件[使用泛型]，先按照name,排序，如果name相同，則按生日日期的先后排序，【即：定制排序】
package class_Generic;
import java.util.ArrayList;
import java.util.Comparator;
public class ClassWork02 {
public static void main(String[] args) {
Employee employee = new Employee("c小范", 20, new MyDate(2000, 3, 26));
Employee employee2 = new Employee("a小黃", 18, new MyDate(1999, 11, 25));
Employee employee3 = new Employee("b小雨", 20, new MyDate(2000, 4, 26));
?
ArrayList<Employee> list = new ArrayList<>(); // 推薦寫法
?
list.add(employee);
list.add(employee2);
list.add(employee3);
System.out.println("=============排序前=============");
for (Employee em : list) {
System.out.println(em);
}
?
list.sort(new Comparator<Employee>() {
// 先按照name,排序，如果name相同，則按生日日期的先后排序，
@Override
public int compare(Employee o1, Employee o2) {
if (!(o1.getName().equals(o2.getName()))) {
return o1.getName().compareTo(o2.getName());
}
?
//未封裝
// MyDate temp1 = o1.getBirthday();
// MyDate temp2 = o2.getBirthday();
// if (temp1.equals(temp2)) {
// return 0;
// } else {
// if (temp1.getYear() != temp2.getYear()) {
// return temp1.getYear() - temp2.getYear();
// }
// if (temp1.getMonth() != temp2.getMonth()) {
// return temp1.getMonth() - temp2.getMonth();
// }
// if (temp1.getDay() != temp2.getDay()) {
// return temp1.getDay() - temp2.getDay();
// }
// return 0;
// }
//封裝方式
return o1.getBirthday().compareTo(o2.getBirthday());
}
?
});
?
System.out.println("=============排序后=============");
?
for (Employee em : list) {
System.out.println(em);
}
}
?
}
?
class Employee {
private String name;
private int age;
private MyDate birthday;
?
public Employee(String name, int age, MyDate birthday) {
super();
this.name = name;
this.age = age;
this.birthday = birthday;
}
?
@Override
public String toString() {
return "Employee [name=" + name + ", age=" + age + ", 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 boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Employee other = (Employee) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
?
class MyDate implements Comparable<MyDate>{//使用泛型指定比較MyDate型別物件
private int year;
private int month;
private int day;
?
public MyDate(int year, int month, int day) {
super();
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 setMouth(int month) {
this.month = month;
}
?
public int getDay() {
return day;
}
?
public void setDay(int day) {
this.day = day;
}
?
@Override
public String toString() {
return year + "-" + month + "-" + day;
}
?
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
MyDate other = (MyDate) obj;
if (day != other.day)
return false;
if (month != other.month)
return false;
if (year != other.year)
return false;
return true;
}
?
@Override
public int compareTo(MyDate o) {//比較
if(year != o.year) {
return year - o.year;
}
if(month != o.month) {
return month - o.month;
}
return day - o.day;
}
?
}
程式輸出：
=============排序前=============
Employee [name=c小范, age=20, birthday=2000-3-26]
Employee [name=a小黃, age=18, birthday=1999-11-25]
Employee [name=b小雨, age=20, birthday=2000-4-26]
=============排序后=============
Employee [name=a小黃, age=18, birthday=1999-11-25]
Employee [name=b小雨, age=20, birthday=2000-4-26]
Employee [name=c小范, age=20, birthday=2000-3-26]
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/255046.html
標籤：Java
上一篇：PriorityQueue詳解