2. 程式人生 > >第50節：Java的當中的泛型

第50節：Java的當中的泛型

阿新 • • 發佈：2018-09-27
新技術 最大 可能 gem 構造 出錯 lec cep tor

技術分享圖片

Java當中的泛型

01

import java.util.ArrayList;
import java.util.List;
public class Demo{
 public static void main(String[] args){
  // 創建list集合
  List list = new ArrayList(); // 特性為長度可變，可以存儲對象（對象可以是任意的）
  list.add("abcdefg"); // 為對象
  list.add(1); // 為對象
  // 循環取出對象
  for(Iterator it = list.iterator(); it.hasNext(); ){
   Object object = (Object) it.next();
   System.out.println(object.toString());
  }
  // 打印字符串的長度
  // 因為字符串的長度是字符串的特有方法，所以需要進行轉型
  String str = (String) it.next();
  System.out.println(str.length());
 }
}
 
String str = (String) it.next();
System.out.println(str.length());
// 導致錯誤
java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
// 因為存儲的對象有Integer類型不能轉換為String類型

這就存在一個問題，如果集合存儲元素時，而且存儲對象有很多，而且對象類型不相同，就很容易導致隱患。

在Java中該文件xxx.java在編譯的時候不會出現錯誤是因為該存儲的是Object的任何類型的對象，所以不會出現錯誤，編譯通過了。編譯後為xxx.class

到運行。

如果要解決問題，可以把問題提前到編譯的時候去解決，讓集合更加安全，但是如何解決呢？

在集合中存儲的類型是可以任意的，所以會導致留下隱患，我們認識的數組在存儲的時候就不會出現這種錯誤，因為它一開始就明確了存儲的內存類型，一旦不是它要存儲的類型就會編譯不過去導致出錯。

在集合中，我們可以一開始就明確要在容器中存儲的什麽類型的元素，跟數組一樣就好了啊！那就不會出現ClassCastException的問題啦！

那麽如何創建集合，規定存儲定義的類型呢？這就需要有泛型了，有了泛型，就可以保證安全機制了，可以將運行時期轉移到編譯時期，泛型的出現就是為了給編譯使用的，泛型的出現就可以不用強轉了。

List<String> list = new ArrayList<String>();

泛型類運用

一直以來，你看到的<E>，就是所謂的泛型表達

java.util
接口 Collection<E>

泛型案例

public class Demo{
 public static void main(String[] args){
  // 添加泛型
  Set<String> set = new TreeSet<String>();
  // 添加元素
  set.add("a");
  set.add("ab");
  for(Iterator<String> it = set.iterator(); it.hasNext();){
  // 不用轉換了
  String str = it.next();
  System.out.println(str);
 }
 }
}

進行比較長度：

Set<String> set = new TreeSet<String>(new Comperator>(){
 @Override
 public int compare(String o1, String o2){
  int temp = o1.length() - o2.length();
  return temp == 0 ? o1.compareTo(o2) : temp;
 }
}

泛型類 可能導致ClassCastException

// 簡書作者：達叔小生
public static void main(String[] args){
 Demo d = new Demo();
 d.setObject(23);
 String s = (String) d.getObject();
 System.out.println(s);
}
class Demo{
 private String str;
 public String getStr(){
  return str;
 }
 public void setStr(String str){
  this.str = str;
 }
}
// Object
class Demo{
 private Object object;
 public Object getObject(){
  return object;
 }
 public void setObject(Object object){
  this.object = object;
 }
}

02

JDK1.5開始的新技術

// 泛型類-泛型定義在類上
class Demo(D){
 private D object;
 public D getObject(){
  return object;
 }
 public void setObject(D object){
  this.object = object;
 }
}
Demo<String> d = new Demo<String>();
d.setObject("abc"); // 只能傳遞String類型
String s = d.getObject();
System.out.println(s);

泛型方法的使用

// 簡書作者：達叔小生
class Demo<D>{
 public <D> void show(D d){
  // 泛型方法
  System.out.println("show"+d);
 }
 public static<E> void print(E e){
  // 方法為靜態，使用泛型，需要定義在方法上
  System.out.println("print"+d);
 }
}
public static void mian(String[] args){
 Demo<String> demo = new Demo<String>();
 demo.show("abc");
 demo.print("abc");
}

泛型接口

// 簡書作者：達叔小生
interface Inter<E>{
 void show(E e);
}
class InterDemo implements Inter<String>{
 ...
}

class InterDemo<T> implements Inter<T>{
 public void show(T t){
  ...
 }
}

泛型通配符

public class Demo{
 public static main(String[] args){
  List<Student> list = new ArrayList<Student>();
  list.add(new Student("dashu",20));
  list.add(new Student("dashu1",21));
  list.add(new Student("dashu2",22));
  for(Iterator<Student> it = list.iterator(); it.hasNext();){
  System.out.println(it.next());
  }
 // 打印
 private static void print(Collection<Student> coll){
   for(Iterator<Student> it = coll.iterator(); it.hasNext();){
   System.out.println(it.next());
  }
 // 打印
 private static void printList(Collection<?> coll){
  for(Iterator<?> it = coll.iterator(); it.hasNext();){
   System.out.println(it.next().toString());
 }
 // 打印
 private static void printList(Collection<? extends Person> coll){
  for(Iterator<? extends Person> it = coll.iterator(); it.hasNext();){
   Person p = it.next();
   System.out.println(p.getName());
  }
 }
 }
 }
}

? extends E：接收E類型或者E的子類型
? super E：接收E類型或者E的父類型

// 簡書作者：達叔小生
public class Person{
 // 定義屬性
 private String name;
 private int age;
 // 定義構造方法
 public Person(){
  super();
 }
 // 有參的構造方法
 public Person(String name, int age){
  super();
  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;
 }
 // toString
 @Override
 public String toString(){
  return "Person [ name=" + name + ",age=" + age + "]";
 }
} 
public class Student extends Person{
 public Student(){
  super();
 }
 public Student(String name, int age){
  super(name,age；
 }
@Override
 public String toString(){
  return "Student [getName()=" + getName() + ",getAge()=" + getAge() + "]";
 }
}
public class Worker extends Person{
 public Worker(){
  super();
 }
 public Worker(String name, int age){
  super(name, age);
 }
 @Override
 public String toString(){
  return "Worker [name =" + getName() + ", age =" + getAge() + "]";
 }
}

通配符的體現

Collection<String> c1 = new ArrayList<String>();
c1.add("dashu");
Collection<String> c2 = new ArrayList<String>();
c2.add("dashucoding");
boolean b = c1.containsAll(c2);
// boolean containsAll(Collection<?> c);
System.out.println("b="+b);
// 結果為 false

內源碼

// 簡書作者：達叔小生
public boolean containsAll(Collection<?> c){
 for(Object o : c){
  if(!contains(o)){
   return false;
  }
  return true;
 }
}
java.util
類 TreeSet<E>
java.lang.Object
 -> java.util.AbstractCollection<E>
  -> java.util.AbstractSet<E>
   -> java.util.TreeSet<E>
參數E：為此set要維護的元素類型
public class TreeSet<E>
extends AbstractSet<E>
implements NavigableSet<E>，Cloneable，Serializable

TreeSet的構造方法

方法 說明
TreeSet() 構造方法，更具元素自然排序
TreeSet(Collection<? extends E> c) 構造一個包含collection元素的新TreeSet，按照其元素自然順序進行排序
TreeSet(Comparator<? super E> comparator) 構造一個新的空TreeSet，它根據指定比較進行排序
TreeSet(Sorted s) 構造一個有序的set，具有相同的映射關系與相同排序的TreeSet 
public class Person implements Comparable<Person> {
 // 定義屬性
 private String name;
 private int age;
 // 定義構造方法
 public Person(){
  super();
 }
 // 有參的構造方法
 public Person(String name, int age){
  super();
  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;
 }
 // toString
 @Override
 public String toString(){
  return "Person [ name=" + name + ",age=" + age + "]";
 }
 @Override
 public int compareTo(Person o){
  int temp = this.age - o.age;
  return temp == 0?this.name.compareTo(o.name) : temp;
  return 0;
 }
} 
Collection<Person> c = new ArrayList<Person>();
c.add(new Person("dashu",12));
c.add(new Person("dashucoding",13));

TreeSet<Person> ts = new TreeSet<Person>(c);
ts.add(new Person("dashuxiaosheng",14));

for(Iterator<Person> it = ts.iterator(); it.hasNext();){
 Person person = it.next(();
 System.out.println(person);
}
// 簡書作者：達叔小生
TreeSet<Student> ts = new TreeSet<Student>(new ComparetoName() );
ts.add(new Student("dashu",12));
ts.add(new Student("dashucoding",13));
for(Iterator<Student> it = ts.iterator(); it.hasNext();){
 Student student = it.next();
 System.out.println(student);
}
class ComparetoName implements Comparator<Student>{
 @Override
 public int compare(Student  o1, Student o2){
  int temp = o1.getName().compareTo(o2.getName());
  return temp == 0 ? o1.getAge() - o2.getAge() : temp;
 }
}
ArrayList<Dog> a = new ArrayList<Dog>(); // 可以
ArrayList<Object> a = new ArrayList<String>(); // 不可以

泛型的特點

public class Demo{
 public static void main(String[] args){
  // 獲取集合中的最大值元素
  Collection c = new ArrayList();
  c.add(new Student("da",12));
  c.add(new Student("dashu",13));
  c.ass(new Student("dashucoding",14));
  Student stu = getMax(c);
  System.out.println(stu);
 }
 public static Student getMax(collection<Student> c){
   Iterator<Student> it = c.iterator();
   Student max = it.next();
   while(it.hasNext()){
    Student temp = it.next();
    if(temp.compareTo(max) > 0){
     max = temp;
    }
   }
   return max;
 }
}
// 簡書作者：達叔小生
public static <T extends Comparable<? super T>> T getMax(Collection<? extends T> c){
 Iterator<? extends T> it = c.iterator();
 T max = it.next();
  while(it.haxNext()){
   T temp = it.next();
    if(temp.compareTo(max)>0){
     max = temp;
    }
  }
}

Collections工具類

java.util
類 Collections
java.lang.Object
 -> java.util.Collections
public class Collections
extends Object
public class CollectionsDemo{
 // 集合框架中的操作集合對象的工具類，靜態的方法
 Collection<String> c = new ArrayList<String>();
 c.add("dashu");
 c.add("dashucoding");
 String max = Collections.max(c);
}
max
public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)

源碼

// 簡書作者：達叔小生
public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll){
 Iterator<? extends T> i = coll.iterator();
 T candidate = i.next();
 while(i.hasNext()){
  T next = i.next();
  if(next.compareTo(candidate) > 0){
   candidate = next;
  }
  return candidate;
 }
}
max
public static <T> T max (Collection<? extends T> coll,Comparator<? super T> comp)
// 可以根據比較器產生順序
 Collection<String> c = new ArrayList<String>();
 c.add("dashu");
 c.add("dashucoding");
 String max = Collections.max(c, new Comparator<String>(){
@Override
 public int compare(String o1, String o2){
  int temp = o1.length() - o2.length();
  return temp == 0?o1.compareTo(o2) : temp;
 }
});

源碼

public static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp){
 if(comp == null){
  return (T)max((Collection<SelfComparable>)(Collection) coll);
 Iterator<? extends T> i = coll.iterator();
 T candidate = i.next();
 while(i.hasNext()){
  T next = i.next();
  if(comp.compare(next, candidate) > 0)
   candidate = next;
 }
 return candidate;
 }
}

排序

List<String> llist = new ArrayList<String>();
list.add("a");
list.add("add");
list.add("sl");
list.add("dljf");
Collections.sort(list);

長度排序

public class ComparatorLength implements Comparator<String>{
 @Override
 public int compare(String o1, String o2){
  int temp = o1.length() - o2.length();
  return temp == 0 ? o1.compareTo(o2) : temp;
 }
}

集合和數組

public class ArraysDemo{
 public static void main(String[] args){
 int[] arr = {23,434,575};
 System.out.println(Arrays.toString(arr));
 
 String[] strs = {"dashu","da","shu"};
 
 List<String> list = Arrays.asList(strs);
 System.out.println(list);
 }
}

往後余生，唯獨有你
簡書作者：達叔小生
90後帥氣小夥，良好的開發習慣；獨立思考的能力；主動並且善於溝通
簡書博客： https://www.jianshu.com/u/c785ece603d1

結語

  • 下面我將繼續對 其他知識 深入講解 ，有興趣可以繼續關註
  • 小禮物走一走 or 點贊

第50節：Java的當中的泛型

相關推薦

第50節：Java的當中的泛型

新技術 最大 可能 gem 構造 出錯 lec cep tor Java當中的泛型 01 import java.util.ArrayList; import java.util.List; public class Demo{ public static void m

第39節：Java當中的IO

data 節點 getname output for iter fin 寫入 stack Java當中的IO IO的分類 第一種分：輸入流和輸出流 第二種分：字節流和字符流 第三種分：節點流和處理流 節點流處理數據，處理流是節點流基礎上加工的。 IO中的重點： Inp

第46節：Java當中的常量池

sco one stat 操作系統 修飾 odr 1.0 其中 運行時常量 Java當中的常量池 在Java虛擬機jvm中，內存分布為：虛擬機堆，程序計數器，本地方法棧，虛擬機棧，方法區。 程序計數器是jvm執行程序的流水線，是用來存放一些指令的，本地方法棧是jvm操作

第48節：Java當中的集合框架

ret return 子類 允許 包裝 block -c 排列 不能 Java當中的集合框架 01 在我們班裏有50位同學，就有50位對象。 // 簡書作者：達叔小生 Student[] stus = new Student[20]; 結果來了一位插班生，該同學因為覺得學

第45節：Java當中的變數，面向物件

Java當中的變數 01 Java當中的例項變數和類變數 什麼是例項變數和類變數呢？ 例項變數為沒有用static修飾符修飾的變數，而類變數為用static修飾符修飾的變數。 public class Hello{ // 私有的靜態變數 name priva

Java高級特性 第1節 集合框架和泛型

eric 如果 語法 提高 需要 his testin fir hashset 　　Java中，存儲多個同類型的數據，可以用數組來實現，但數組有一些缺陷： 數組長度固定不變，布恩那個很好的適應元素數量動態變化的情況 可以通過數組.length獲取數組長度，卻無法直接

#乾貨分享：Java 的泛型擦除和執行時泛型資訊獲取

Java 的泛型擦除 程式設計師界有句流行的話，叫 talk is cheap, show me the code，所以話不多說，看程式碼。 如果有想學習java的程式設計師，可來我們的java學習扣qun：79979，2590免費送java的視訊教程噢！我整理了一份適合18年學習的java

第65節：Java後端的學習之Spring基礎

Java後端的學習之Spring基礎 如果要學習spring,那麼什麼是框架,spring又是什麼呢?學習spring中的ioc和bean,以及aop,IOC,Bean,AOP,(配置,註解,api)-springFramework. 各種學習的知識點: spring expressi

第35節：Java面向物件中的多執行緒

Java面向物件中的多執行緒 多執行緒 在Java面向物件中的多執行緒中，要理解多執行緒的知識點，首先要掌握什麼是程序，什麼是執行緒？為什麼有多執行緒呢？多執行緒存在的意義有什麼什麼呢？執行緒的建立方式又有哪些？以及要理解多執行緒的特點等。

Effective Java 第三版——29. 優先考慮泛型

調用 system correct temp per except 語言 程序員 但是 Tips 《Effective Java, Third Edition》一書英文版已經出版，這本書的第二版想必很多人都讀過，號稱Java四大名著之一，不過第二版2009年出版，到現在已

Java高階架構師（一）第12節：Service的實現以及模組化

BaseService.java package com.sishuok.architecture1.common.service; import java.util.List; import com.sishuok.architecture1.common.dao.BaseDAO; import

Java高級架構師（一）第13節：Spring MVC實現Web層開發

long true variable creat stp gis delete list java package com.sishuok.architecture1.customermgr.web; import org.springframework.beans.f

Java高階架構師（一）第21節：通過X-gen生成商品模組

package com.sishuok.architecture1.goodsmgr.vo; import com.sishuok.architecture1.common.vo.BaseModel; public class GoodsModel extends BaseModel{

Java高級架構師（一）第24節：加入ehcache，把工程加入到Git

def encoding -i spa odin default nts end esc ehcache的maven配置： <!-- ehcache的jar --> <dependency> <groupId>net.sf.ehcac

java--ArrayList泛型：使用ArrayList泛型新增5個學生物件， 然後遍歷列印5位學生的自我介紹方法。

import java.util.ArrayList; import java.util.List; /** * 使用ArrayList泛型新增5個學生物件，然後遍歷列印5位學生的自我介紹方法。 * （需建立學生類）Student.java包含 name,age,gen

Java高級架構師（一）第28節：Index、商品詳細頁和購物車

cat condition glib 1.0 dsm attr odin pri public <%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf

Java程式設計思想(第4版) 之 15.5 泛型之匿名內部類

15.5   匿名內部類 泛型還可以應用於內部類以及匿名內部類。下面的示例使用匿名內部類實現了Generator介面：     Customer和Teller類都只有private的構造器，這可以強制你必須使用Generator物件。Customer有一個generator(

【JAVA】基礎：集合、泛型、異常、反射

1.集合 集合就是高階陣列，可以存放任意型別的物件，同時可以自動擴容。 集合主要由兩個介面派生而出：Collection和Map Iterator 介面: 是Collection介面的父介面，主要是用於遍歷Collection中的元素。 語法： //構造 Li

第四節：詳細講解Java中的類和麵向物件思想

前言大家好，我是 Vic，今天給大家帶來詳細講解Java中的類和麵向物件思想的概述，希望你們喜歡類和麵向物件在Java中怎樣理解物件，建立物件和引用；什麼是引用，對於基礎學習的同學，要深入瞭解引用。示例：String str = new String(); ；其中str為引用

《C++primer(第五版)》學習之路-第十六章：模板與泛型程式設計

【宣告：版權所有，轉載請標明出處，請勿用於商業用途。聯絡信箱：[email protected]】 16.1 定義模板 1.模板定義以關鍵字template開始，後跟一個模板引數列表，這是一個逗號分隔的一個或多個模板引數的列表，用小於號(<)和大於號(&