下载文档原格式
第1章Java集合和泛型技术及应用（第4/4部分）1.1深入理解和应用Java泛型技术1.1.1有届泛型类型及在项目中的应用1、对泛型的“类型通用性”加以一定的限制（1）泛型的“类型通用性”会为应用系统在运行过程中带来一定的性能开销泛型的“类型通用性”能够为读者带来代码的灵活性和功能实现的通用性，但这样的“灵活性”和“通用性”也为应用系统在运行过程中带来一定的系统性能开销。
因此，如果在具体应用中并不需要程序代码具有非常高的“灵活性”和“通用性”的要求，如果读者能够预知或者能够确定数据的可能类型的编程应用场合下，可以对泛型的“类型通用性”加以一定的限制。
这样的限制能够减少参数的数据类型在转换过程中所可能带来的系统性能开销，而且也能够在一定的程度上避免类型转换过程中有可能会出现的各种可能的错误。
（2）对泛型的“类型通用性”加以一定的限制在许多应用环境下，方法的功能实现代码中的各种参数的数据类型是已知的数据类型或者是有类型范围的，比如下面的泛型类代码示例中的泛型类型GenericType在具体应用时实际只能为UserInfoBase类及其子类的类型范围。
public class GenericTypeDemo<GenericType> {}由于在上面的代码示例中的泛型类型GenericType定义符是没有任何的类型限制的，实际上也就相当于该类为ng.Object类型——也就是相当于下面的有届泛型类定义：public class GenericTypeDemo<GenericType extends Object> {}这样的泛型类定义有点“太泛”了，因为系统中的数据类型实际只能是UserInfoBase 类及其子类的类型范围，不可能为其他的数据类型。
因此，读者可以对上面的有届泛型类型定义进一步类型具体化以缩小数据类型的范围。
2、有届泛型类型定义的语法在Java中的有届泛型类型定义是利用extends关键字来限定类型参数只能是某个类或它的子类的数据类型，如果存在有多个不同的限定时，则要采用“&”符号分开不同的类型名称。
Java中的泛型编程技巧Java 中的泛型编程技巧随着软件系统规模的不断扩大，代码的维护成本也愈来愈高。
泛型编程（Generics Programming）正是为了解决这个问题而生的。
Java 作为一门比较成熟的编程语言，自 J2SE 5.0 版本起加入了泛型机制，使得 Java 的类型安全性得到进一步提高。
本文将介绍一些Java 中的泛型编程技巧，帮助大家编写更加清晰、简洁、安全、可复用的代码。
一、泛型基础1.1 泛型类泛型类（Generic Class）是指可以在类定义时指定类型参数的类。
泛型类可以包含普通成员变量和普通成员方法。
类型参数可以是任意类型，包括基本数据类型和引用类型。
例如：```public class MyGenericClass<T> {private T value;public void setValue(T value) {this.value = value;}public T getValue() {return value;}}```上面的代码中，T 是一个类型参数，可以被任意类型替代。
在实例化泛型类时会指定实际的类型参数，如下所示：```MyGenericClass<String> generic = new MyGenericClass<>();generic.setValue("Hello, World!");String value = generic.getValue();```1.2 泛型接口泛型接口（Generic Interface）与泛型类类似，可以在接口定义时指定类型参数。
泛型接口可以被实现为泛型类、非泛型类以及其他泛型接口。
例如：```public interface MyGenericInterface<T> {void setValue(T value);T getValue();}```可以将泛型接口用于实现非泛型类：```public class MyGenericClass<T> implements MyGenericInterface<T> {private T value;public void setValue(T value) {this.value = value;}public T getValue() {return value;}}```也可以将泛型接口用于实现其他泛型接口：```public interface MyGenericInterface2<U> extends MyGenericInterface<U> {void setOtherValue(U value);U getOtherValue();}```1.3 泛型方法泛型方法（Generic Method）是指可以在方法定义时指定类型参数的方法。
java 泛型的三种定义与使用方法Java中的泛型主要有三种定义方式，分别是：类型参数、类型参数化类和类型参数化方法。
下面是它们的定义和使用方法：1. 类型参数：类型参数是泛型的主要形式，它允许我们在定义类、接口或方法时指定一个或多个类型参数。
这些类型参数在类、接口或方法的实现中被用作类型占位符，以便在运行时确定实际类型。
定义类型参数的方法是在类、接口或方法的名称后面加上尖括号<>，并在其中指定一个或多个类型参数。
例如：```javapublic class Box<T> {private T content;public Box(T content) {= content;}public T getContent() {return content;}}```在上面的例子中，我们定义了一个名为Box的泛型类，它有一个类型参数T。
我们可以使用任何类型来实例化Box对象，例如Box<Integer>、Box<String>等。
2. 类型参数化类：类型参数化类是将一个类作为泛型参数。
这种定义方式主要用于集合框架中的类，例如List、Set、Map等。
定义类型参数化类的方法是在类名后面加上尖括号<>，并在其中指定一个或多个类型参数。
例如：```javaList<String> list = new ArrayList<>();Set<Integer> set = new HashSet<>();Map<String, Integer> map = new HashMap<>();在上面的例子中，我们定义了三个类型参数化类：List、Set和Map，并使用它们创建了三个不同类型的对象。
这些对象在运行时会自动处理实际类型的匹配。
3. 类型参数化方法：类型参数化方法是在方法中使用泛型。
1.1跟我学Java泛型技术及应用实例——Java泛型技术在Java程序中的应用示例1、可以把Java泛型类看成是类的模板、普通类的加工厂由于泛型类声明是一种类的声明，需要为其提供类型实参后才能构成实际的具体类型。
而Java是一种强类型的语言, 在J2SE 1.4以及以前的版本中，如果在定义一个Java类、接口或者方法的时候, 必须指定其类型。
而在声明泛型类、接口或者方法时，定义变量的时候是不需要指定某些变量的具体类型, 而是用一个类型参数符号来代替（类型的占位符）。
而在使用这个类、接口或者方法的时候,必须为这个类型参数指定一个具体类型、并最终被实际所代替。
在下面的示例中的类名后面带有<GenericType>，表明了这个GenericTypeDemo类是泛型类, 其中GenericType被称为类型参数(type parameter)。
在使用泛型的时候, 类型参数可以被替换为任何的实际类的类型名称。
下面的代码示例为Java泛型类的应用示例：package com.px1987.j2eeweb.dao.generictype;package com.bluedream.generics;public class GenericTypeDemo<GenericType> {/**用该类型参数来定义泛型成员变量*/private GenericType oneObject;public GenericTypeDemo(GenericType oneObject) {/*** 利用该类型参数来定义泛型方法变量*/this.oneObject = oneObject;}public GenericTypeDemo() {}public GenericType getOneObject() {return oneObject;}public void setOneObject(GenericType oneObject) {this.oneObject = oneObject;}public void showGenericTypeClassTyep() {System.out.println("GenericType的实际类型是: " +oneObject.getClass().getName());}public void doGenericTypeDemo() {GenericTypeDemo<String> stringObject=new GenericTypeDemo<String>("定义泛型类的String类型");stringObject.showGenericTypeClassTyep();}public static void main(String[] args) {GenericTypeDemo oneGenericTypeDemo=new GenericTypeDemo();oneGenericTypeDemo.doGenericTypeDemo();}}使用<GenericType>来声明一个类型持有者名称，然后就可以把GenericType当作一个类型代表来声明成员、参数和返回值类型。
Java技术——Java泛型详解（转）1．为什么需要泛型转载请注明出处：泛型在Java中有很重要的地位，⽹上很多⽂章罗列各种理论，不便于理解，本篇将⽴⾜于代码介绍、总结了关于泛型的知识。
先看下⾯的代码：[java]1. List list = new ArrayList();2. list.add("CSDN_SEU_Calvin");3. list.add(100);4. for (int i = 0; i < list.size(); i++) {5. String name = (String) list.get(i); //取出Integer时，运⾏时出现异常6. System.out.println("name:" + name);7. }本例向list类型集合中加⼊了⼀个字符串类型的值和⼀个Integer类型的值（这样是合法的，因为此时list默认的类型为Object类型）。
在循环中，由于忘记了之前添加了Integer类型的值或其他原因，运⾏时会出现ng.ClassCastException。
为了解决这个问题，泛型应运⽽⽣。
2．泛型的使⽤Java泛型编程是JDK1.5版本后引⼊的。
泛型让编程⼈员能够使⽤类型抽象，通常⽤于集合⾥⾯。
只要在上例中将第1⾏代码改成如下形式，那么就会在编译list.add(100)时报错。
[java]1. List<String> list = new ArrayList<String>();通过List<String>，直接限定了list集合中只能含有String类型的元素，从⽽在上例中的第6⾏中，⽆须进⾏强制类型转换，因为集合能够记住其中元素的类型信息，编译器已经能够确认它是String类型了。
3．泛型只在编译阶段有效看下⾯的代码：[java]1. ArrayList<String> a = new ArrayList<String>();2. ArrayList b = new ArrayList();3. Class c1 = a.getClass();4. Class c2 = b.getClass();5. System.out.println(c1 == c2); //true上⾯程序的输出结果为true。
java 泛型用法
Java泛型是指在编写Java程序时，使用泛型类型的技术。
泛型类型是指能够允许在代码中使用不同类型的对象。
Java泛型允许我们在编译时检查我们的代码，以确保类型的安全性，从而避免了运行时类型转换错误。
Java泛型的用法包括以下几种：
1. 泛型类
Java泛型类是一种通用类，可以用来创建其他类的对象。
泛型类可以被定义为一个或多个参数化类型，这些参数化类型被称为类型参数。
使用泛型类时，需要在实例化时指定类型参数。
2. 泛型方法
Java泛型方法是一种通用方法，可以在调用时接受不同类型的参数。
泛型方法可以被定义为一个或多个参数化类型，这些参数化类型被称为类型参数。
使用泛型方法时，需要在调用时指定类型参数。
3. 泛型接口
Java泛型接口是一种通用接口，可以用来创建其他接口的实现。
泛型接口可以被定义为一个或多个参数化类型，这些参数化类型被称为类型参数。
使用泛型接口时，需要在实现时指定类型参数。
4. 通配符
Java泛型的通配符指的是一种可以用来匹配任何类型的占位符。
通配符用?来表示，可以被用来定义泛型类型、方法或接口的参数或返回值类型。
5. 类型边界
Java泛型的类型边界指的是限制泛型类型参数的范围。
类型边界可以被用来定义泛型类型、方法或接口的参数或返回值类型。
通过类型边界，可以限制泛型参数的类型必须是某个类或接口的子类或实现类。
以上是Java泛型的主要用法，掌握这些用法可以有效提高Java 编程效率，以及提高代码的可读性和可维护性。
1.1Java集合相关技术及应用实例培训教学示例（第1部分）1、Collection接口的应用示例——理解和说明集合是“动态可变化的数组”（1）添加一个CollectionDemo类，包名称为com.px1987.collectiondemopackage com.px1987.collectiondemo;import java.util.ArrayList;import java.util.Collection;public class CollectionDemo {/***下面的数组模拟集合所操作的一大批数据*/String strMonths[]={"一月","二月","三月","四月","五月","六月","七月","八月","九月","十月","十一月","十二月"};Integer intMonths[]={new Integer(1),new Integer(2),new Integer(3),new Integer(4),new Integer(5),new Integer(6),new Integer(7),new Integer(8),new Integer(9),new Integer(10),new Integer(11),new Integer(12)};public CollectionDemo() {}public void doCollectionArray(){/*** 下面声明一个Collection接口的对象*/Collection months= null;/*** 然后再对该Collection接口的对象进行具体的对象实例化，采用子接口的实现类ArrayList。
Java中泛型的运⽤实例package example6;import java.util.ArrayList;import java.util.HashMap;import java.util.HashSet;import java.util.Iterator;import java.util.List;import java.util.Map;import java.util.Map.Entry;import java.util.Set;import org.junit.Test;/*1.为什么要使⽤泛型？* ⼀般使⽤在集合上，⽐如现在将⼀个字符串类型放在集合⾥⾯，这时候，放⼊集合的字符会失去其本⾝的类型，只能是object类型，⽐如想要对这这个值进⾏转换，* 很容易出现类型转换错误。
可以使⽤泛型解决这个问题。
* 常⽤集合：list set map* list的三种实现（ArrayList LinkedList vector）* 此三者的区别：* 1.这三个类都实现了List接⼝，LinkList即存储在这两个集合中的元素的位置是不连续的，底层数据结构是列表结构。
* 2.ArrayList和Vector都是使⽤数组⽅式存储数据，此数组元素数⼤于实际存储的数据以便增加和插⼊元素，它们都允许直接按序号索引元素，查询速度快，* 但是插⼊元素要涉及数组元素移动等内存操作，所以索引数据快⽽插⼊数据慢。
* 3.LinkedList使⽤双向链表实现存储，按序号索引数据需要进⾏前向或后向遍历，但是插⼊数据时只需要记录本项的前后项即可，所以插⼊,修改，删除速度较快.* 4.Vector是同步处理,性能较低；ArrayList是使⽤异步处理，性能⾼。
* 5.Vector是线程安全的，ArrayList是⾮线程安全。
LinkedList是⾮线程安全。
* 6.⼀般情况都⽤ArrayList，ArrayList占据内存⼩，如果只是查找特定位置的元素或只在集合的末端增加、移除元素，那么使⽤Vector或ArrayList都可以。
1.1跟我学Java入门到精通培训教程——在项目中应用Java泛型技术的实例1.1.1Java泛型相关的应用技术1、什么是泛型----泛型的本质是参数化类型（1）泛型的本质是参数化类型泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。
（2）泛型的种类这种参数类型可以用在类、接口和方法的定义中，分别称为泛型类、泛型接口、泛型方法。
（3）泛型类的代码示例public class SomeGenericsDemo<E> {Collection<E> oneCollection;public void doSomeThing(E oneElement) {oneCollection.add(oneElement);// ...}}2、为什么要应用泛型泛型就好比Word中的模板，在Word的模板中，提供了基本的文档编辑内容，在定义Word 模板时，对具体编辑哪种类型的文档是未知的。
在Java中，泛型则提供了类、接口和方法、变量等的模板，泛型也可以看作是占位符，与定义Word模板时类似，定义泛型时的具体类型是未知的。
（1）Java语言引入泛型的好处是安全和简单在Java SE 1.5之前，没有泛型的情况的下，通过对Object类型的对象引用来实现参数的“任意化”，“任意化”带来的缺点是需要在使用者的代码中要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型是可以预知的情况下进行的。
public class SomeDigitClass{public void doSomeThing(Object oneParameterObject) {if(oneParameterObject instanceof Integer){Integer targetParameterObject=(Integer)oneParameterObject;}else if(oneParameterObject instanceof Float){Float targetParameterObject=(Float)oneParameterObject;}}}而对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个很严重的安全隐患。
（2）泛型的好处是在编译的时候就进行类型安全方面的检查并且所有的强制类型转换都是自动和隐式的，以提高代码的可重用率。
（3）应用泛型能够减少编码量并提高代码的通用性（简化代码结构、提高开发效率）3、泛型在应用中的规则和限制（1）泛型的类型参数只能是对“类”类型（包括自定义类），不能是简单的数据类型。
（2）泛型的参数类型可以使用extends语句，例如<T extends superclass>。
习惯上成为“有界类型”来加以限定其范围。
（3）泛型的参数类型还可以是通配符类型。
例如Class<?> classType = Class.forName(ng.String);（4）泛型类不可以继承Exception类，即泛型类不可以作为异常被抛出（5）不可以定义泛型数组、也不可以用泛型构造对象（即object = new T(); 是错误的），并且在static方法中不可以使用泛型，泛型变量也不可以用static关键字来修饰public static T getSingleInstance() {// 不通过}public static T singleInstance; // 不通过4、泛型的基本语法（1）其定义的基本方式是通过某个类名后面的<>括号中的值指定下面这一段示例代码说明如何定义泛型，其中用E代替在实际中将会使用到的类名（当然也可以使用其它别的名称，习惯上在这里使用大写的E，表示Collection的元素）。
然后就可以采用该E来进行参数的定义。
通过在类名后面使用一对尖括号，中间放一个称为类型参数的“E”来定义泛型，该符号“E”其实是“类型占位符”或者称“类型参数”。
（2）代码示例1public class TestGenerics<E> {Collection<E> col;public void doSth(E elem) {col.add(elem);// ...}}（3）代码示例2package com.px1987.general;import java.util.List;/**** 下面的SomeOneClass类现在为泛型类* public interface SomeOneClass<E>*/public class SomeOneClass<E> {/*** 下面的zhang现在为泛型变量*/SomeOneClass<Integer> zhang =null;List<String> someList=null;/*** 下面的方法现在为泛型方法*/public void doXXX(E someOneVal,E someTwoVal){}/*** 下面的方法现在为泛型方法*/public E doYYY(){return null;}public SomeOneClass() {zhang =new SomeOneClass<Integer>();}public static void main(String[] args) {//SomeOneClass<String> zhang=new SomeOneClass<String>();}}5、泛型与C++ 中的模板不同（1）它很相似于C++中的类模板，但和类模板还是有一定的区别表面上看起来，无论语法还是应用的环境（比如容器类），泛型类型（或者泛型）都类似于 C++ 中的模板。
但是这种相似性仅限于表面：1)Java 语言中的泛型基本上完全在编译器中实现，由编译器执行类型检查和类型推断，然后生成普通的非泛型的字节码。
2)这种实现技术称为擦除（erasure）（编译器使用泛型类型信息保证类型安全，然后在生成字节码之前将其清除；3)最终在*.class文件中是不存在与泛型有关的描述内容。
（2）在Java虚拟机中是没有泛型类型的（所有对象都属于普通类）无论何时定义一个泛型类型，相应的原始类型都会被自动提供。
原始类型的名字就删去或者替代了类型参数的泛型类型的名字。
类型变量被擦除时如果存在限定类型，则用其第一个限定类型替换；如果不存在限定的类型变量则用Object类型替换。
●用其第一个限定类型Comparable替换的示例：public class Interval<T extends Comparable & Serializable>。
●用其第一个限定类型Serializable替换的示例：public class Interval<T extends Serializable & Comparable>●无限定的类型变量时用Object替换的示例：public class Pair<T> {private T first;private T second;public Pair(T first, T second) {this.first = first;this.second = second;}public T getFirst() {return this.first;}public T getSecond() {return this.second;}}因为T是一个无限定的类型变量，所以简单地用Object替换。
Pair<T>的原始类型如下所示：public class Pair {private Object first;private Object second;public Pair(Object first, Object second) {this.first = first;this.second = second;}public Object getFirst() {return this.first;}public Object getSecond() {return this.second;}}因此，要注意的是“泛型技术”还只是一种“编译期技术”。
只能在编译期发挥作用，一旦软件完成编译，成为可执行代码，便失去了利用泛型的机会。
对于现在的多数应用而言，运行时的“多态”能力显得尤为重要。
而现有的泛型无法在这个层面发挥作用。
练习：定义出一个泛型接口，并且在该接口中定义出一个泛型方法。
package com.px1987.general;public interface SomeOneInterface<E> {public void doXXX(E oneVal);public void doXXX(E oneVal,E twoVal);public E doYYY();public E doZZZ(E oneVal);}6、Java泛型类及具体的应用由于泛型类声明是一种类的声明，需要为其提供类型实参后才能构成实际的具体类型。
（1）Java泛型类 (可以把泛型类看成是类的模板、普通类的加工厂)由于Java是一种强类型的语言, 在J2SE 1.4以及以前的版本中，如果我们在定义一个Java类、接口或者方法的时候, 必须指定其类型。
而在声明泛型类、接口或者方法时，定义变量的时候是不需要指定某些变量的具体类型, 而是用一个类型参数符号来代替（类型的占位符）。
而在使用这个类、接口或者方法的时候,必须为这个类型参数指定一个具体类型、并最终被实际所代替。
在下面的示例中的类名后面带有<GenericType>，表明了这个GenericTypeDemo类是泛型类, 其中GenericType被称为类型参数(type parameter)。
在使用泛型的时候, 类型参数可以被替换为任何的实际类的类型名称。
（2）Java泛型类的应用示例package com.px1987.j2eeweb.dao.generictype;public class GenericTypeDemo<GenericType> {private GenericType oneObject; //利用该类型参数来定义泛型成员变量public GenericTypeDemo(GenericType oneObject) { //利用该类型参数来定义泛型方法变量this.oneObject = oneObject;}public GenericTypeDemo() {}public GenericType getOneObject() {return oneObject;}public void setOneObject(GenericType oneObject) {this.oneObject = oneObject;}public void showGenericTypeClassTyep() {System.out.println("GenericType的实际类型是: " + oneObject.getClass().getName());}public void doGenericTypeDemo() {GenericTypeDemo<String> stringObject=new GenericTypeDemo<String>("定义泛型类的String类型");stringObject.showGenericTypeClassTyep();}public static void main(String[] args) {GenericTypeDemo oneGenericTypeDemo=new GenericTypeDemo();oneGenericTypeDemo.doGenericTypeDemo();}}使用<GenericType>来声明一个类型持有者名称，然后就可以把GenericType当作一个类型代表来声明成员、参数和返回值类型。
