Java泛型详解
1. 泛型
Java泛型是J2 SE1.5中引入的一个新特性,其本质是参数化类型,也就是说所操作的数据类型被指定为一个参数(type parameter)这种参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型接口、泛型方法。泛型的本质是为了参数化类型(在不创建新的类型的情况下,通过泛型指定的不同类型来控制形参具体限制的类型)。
2. 泛型的优点
2.1 类型安全
泛型的主要目标是提高Java程序的类型安全。通过知道使用泛型定义的变量的类型限制,编译器可以在非常高的层次上验证类型假设。通过在变量声明中捕获这一附加的类型信息,泛型允许编译器实施这些附加的类型约束。类型错误就可以在编译时被捕获了,而不是在运行时当作ClassCastException展示出来。将类型检查从运行时挪到编译时有助于Java开发人员更早、更容易地找到错误,并可提高程序的可靠性。
//没有泛型的情况
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
list.add("11");
list.add(123);//编译正常
}
//有泛型的情况
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("11");
list.add(123);//编译报错
}
2.2 消除强制类型转换
泛型的一个附带好处是,消除源代码中的许多强制类型转换
//没有泛型的代码段需要强制转换
public static void main(String[] args) {
List list = new ArrayList();
list.add(123);
Integer integer = (Integer) list.get(0);
}
//有泛型的代码段不需要强制转换
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
list.add(1);
int s = list.get(0);
}
2.3 更高的运行效率
避免了不必要的装箱、拆箱操作,提高程序的性能。在非泛型编程中,将简单类型作为Object传递时会引起Boxing(装箱)和Unboxing(拆箱)操作,这两个过程都是具有很大开销的。引入泛型后,就不必进行Boxing和Unboxing操作了,所以运行效率相对较高,特别在对集合操作非常频繁的系统中,这个特点带来的性能提升更加明显。
//没有使用泛型
public static void main(String[] args) {
//由于是object类型,会自动进行装箱操作。
Object a = 1;
//强制转换,拆箱操作。这样一去一来,当次数多了以后会影响程序的运行效率。
int b = (int) a;
}
//使用了泛型
潜在的性能收益
提高了代码的重用性,泛型的程序设计,意味着编写的代码可以被很多不同类型的对象所重用
3. 泛型的使用
泛型的三种使用方式:泛型类,泛型方法,泛型接口
泛型只在编译阶段有效
3.1 泛型类
泛型类型必须是引用类型(非基本数据类型)。泛型类型用于类的定义中,被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种容器类,如:List、Set、Map。
//格式
public class 类名 <泛型类型1,...> {
}
public static void main(String[] args) {
//泛型类
Generics<String> name = new Generics<>("泛型");
System.out.println(name.getValue());
Generics<Integer> number = new Generics<>(1111);
System.out.println(number.getValue());
}
public static class Generics<T> {
private T value;
public Generics(T value) {
this.value = value;
}
public T getValue() {
return value;
}
public void setValue(T value) {
this.value = value;
}
}
//结果
泛型
1111
3.2 泛型方法
泛型方法,是在调用方法的时候指明泛型的具体类型。
//格式
public <泛型类型> 返回类型 方法名(泛型类型 变量名) {
}
public static void main(String[] args) {
Test d = new Test();
String str = d.function("泛型");
int i = d.function(1);
System.out.println(str);
System.out.println(i);
}
static class Test {
public <T> T function(T t) {
return t;
}
}
//结果
泛型
1
3.3 泛型类接口
? 泛型接口与泛型类的定义及使用基本相同。泛型接口常被用在各种类的生产器中。方法声明中定义的形参只能在该方法里使用,而接口、类声明中定义的类型形参则可以在整个接口、类中使用。当调用fun()方法时,根据传入的实际对象,编译器就会判断出类型形参T所代表的实际类型,使用泛型的时候,前后定义的泛型类型必须保持一致,否则会出现编译异常
//格式
public interface 接口名<泛型类型> {
}
public static void main(String[] args) {
GenericsInterface getString = new getStringImpl();
getString.get("111");
GenericsInterface getInteger = new getIntegerImpl();
getInteger.get(123);
}
public static class getStringImpl implements GenericsInterface<String> {
@Override
public void get(String value) {
System.out.println(value);
}
}
public static class getIntegerImpl implements GenericsInterface<Integer> {
@Override
public void get(Integer value) {
System.out.println(value);
}
}
public interface GenericsInterface<T> {
void get(T value);
}
//结果
111
123
使用注意
- 泛型的类型参数只能是类类型(包括自定义类),不能是简单类型。
- 泛型的类型参数可以有多个。
- 不能对确切的泛型类型使用instanceof操作。如下面的操作是非法的,编译时会出错。
- 不能创建一个确切的泛型类型的数组。
4. 泛型通配符
4.1 常用的通配符
E: Element (在集合中使用,因为集合中存放的是元素)
T:Type(Java 类)
K: Key(键)
V: Value(值)
N: Number(数值类型)
?: 表示不确定的java类型
4.2 通配符上界
<? extends T>,在类型参数中使用 extends 表示这个泛型中的参数必须是 E 或者 E 的子类
使用固定上边界的通配符的泛型, 就能够接受指定类及其子类类型的数据。
要声明使用该类通配符, 采用<? extends E>的形式, 这里的E就是该泛型的上边界。
注. 这里虽然用的是extends关键字, 却不仅限于继承了父类E的子类, 也可以代指显现了接口E的类
public static void main(String[] args) {
List<Father> listF = new ArrayList<>();
List<Son> listS = new ArrayList<>();
List<Daughter> listD = new ArrayList<>();
testExtend(listF);
testExtend(listS);
testExtend(listD);
}
private static <T> void testExtend(List<? extends Father> list) {
}
static class Father {
}
static class Daughter extends Father {
}
static class Son extends Father {
}
4.3 通配符下界
<? super T>,在类型参数中使用 super 表示这个泛型中的参数必须是 E 或者 E 的父类。
使用固定下边界的通配符的泛型, 就能够接受指定类及其父类类型的数据.。
要声明使用该类通配符, 采用<? super E>的形式, 这里的E就是该泛型的下边界.。
注. 你可以为一个泛型指定上边界或下边界, 但是不能同时指定上下边界。
public static void main(String[] args) {
List<Father> listF = new ArrayList<>();
List<Son> listS = new ArrayList<>();
List<Daughter> listD = new ArrayList<>();
testSuper(listF);
testSuper(listS);
testSuper(listD);
}
private static void testSuper(List<? super Son> list){
} {
}
static class Father {
}
static class Daughter extends Father {
}
static class Son extends Father {
}
List<? super Son> list 接受的类型只能是 Son 或者是 Son 的父类,而 Father 和 GrandFather 又都是 Son 的父类,所以以上程序是没有任何问题的,但是如果再来一个类是 Son 的子类(如果不是和 Son 有关联的类那更不行了)
4.4 无界通配符
<?>,即类型参数可以是任何类型无边界的通配符的主要作用就是让泛型能够接受未知类型的数据
public static void main(String[] args) {
List<Integer> arrays = Arrays.asList(1, 1, 1);
List<String> arrayString = Arrays.asList("1", "1", "1");
printList(arrays);
printList(arrayString);
}
public static void printList(List<?> list) {
for (Object elem : list) {
System.out.print(elem + "");
}
System.out.println();
}
//结果
111
111
5.类型擦除
Java的泛型是伪泛型,为什么说Java的泛型是伪泛型呢?因为在编译期间,所有的泛型信息都会被擦除掉,我们常称为泛型擦除。
@Test
public void test() {
List<String> stringList = new ArrayList<String>();
stringList.add("泛型");
List<Integer> integerList = new ArrayList<Integer>();
integerList.add(1);
System.out.println(stringList.getClass() == integerList.getClass());
}
//结果
true
定义了两个List,不过一个是List泛型类型,只能存储字符串。一个是List泛型类型,只能存储整型。最后,我们通过stringList对象和integerList对象的getClass方法获取它们的类的信息,最后发现结果为true。说明泛型类型String和Integer都被擦除掉了,只剩下了原始类型。
泛型的优点、方法及相关细节
泛型—— 一种可以接收数据类型的数据类型。
一、泛型的引入
我们都知道,继承是面向对象的三大特性之一,比如在我们向集合中添加元素的过程中add()方法里填入的是Object类,而Object又是所有类的父类,这就产生了一个问题——添加的类型无法做到统一 由此就可能产生在遍历集合取出元素时类型不统一而报错问题。
例如:我向一个ArrayList集合中添加Person类的对象,但是不小心手贱添加了一个Boy类的对象,这就会导致如下结果
二、使用泛型的好处
1.提升了程序的健壮性和规范性
针对上述问题,当我们采用泛型就会显得非常简单,只需要在编译类型后利用泛型指定一个特定类型,编译器就会自动检测出不符合规范的类并抛出错误提示
3.减少了类型转换的次数,提高效率
- 当不使用泛型时:
4.在类声明时通过一个标识可以表示属性类型、方法的返回值类型、参数类型
class Person<E> {
E s; //可以是属性类型
public Person(E s) {
//可以是参数类型
this.s = s;
}
public E f() {
//可以是返回类型
return s;
}
public void show() {
System.out.println(s.getClass()); //显示S的运行类型
}
}
可以这样理解:上述的class Person< E >
中的“E”相当于这里的E是一个躯壳 占位用的 以后定义的时候程序员可以自己去自定义
就像这样
public static void main(String[] args) {
Person<String> person1 = new Person<String>("xxxx");// E->String
person.show();
Person<Integer> person2 = new Person<Integer>(123); // E->Integer
person.show();
}
运行结果:
class java.lang.String
class java.lang.Integer
三、泛型常见用法
1.定义泛型接口
曾经写接口的时候都没有定义泛型,它默认的就是Object类,其实这样写是不规范的!
如果说接口的存在是一种规范,那泛型接口就是规范中的规范
interface Im<U,R>{
void hi(R r);
void hello(R r1,R r2,U u1,U u2);
default R method(U u){
return null;
}
}
在上述的泛型接口中已经规定传入其中的必须是U,R类的对象,那么当我们传入其他类的对象时就会报错,如图:
2.定义泛型集合
1.使用泛型方式给HashSet中放入三个学生对象,并输出对象信息
HashSet<Student> students = new HashSet<Student>();
students.add(new Student("懒羊羊",21));
students.add(new Student("喜羊羊",41));
students.add(new Student("美羊羊",13));
for (Student student :students) {
System.out.println(student);
}
上述的 泛型中Student的是我事先定义好的一个类,把它放到其中作为泛型来约束传入的对象,以及在遍历时减少转型的次数提高效率
2.使用泛型方式给HashMap中放入三个学生对象,并输出对象信息
HashMap<String, Student> hm = new HashMap<String, Student>();
// K-> String V->Student与下面的对应
hm.put("001",new Student("喜羊羊",21));
hm.put("002",new Student("懒羊羊",32));
hm.put("003",new Student("美羊羊",43));
Set<Map.Entry<String,Student>> ek=hm.entrySet();
Iterator<Map.Entry<String, Student>> iterator = ek.iterator();//取出迭代器
while (iterator.hasNext()) {
Map.Entry<String, Student> next = iterator.next();
System.out.println(next.getKey()+" - "+next.getValue());
}
HashMap是一个双列集合,以[K-V]
的方式存储对象,因此在使用泛型时要向其中传入两个类型
我们都知道使用迭代器遍历HashMap时要先通过
entrySet()
取出键值对,然后通过转型得到对应的类来得到对象信息。而在使用泛型定义[K-V]
就规定了取出的键值对的类型,所以就省去了转型这一步骤,同样也使程序变得简单,高效
四、泛型使用细节
1.<>中类型规范
在给泛型指定具体类型后,可以传入该类型或者其子类类型
P<A> ap = new P<A>(new A());
P<A> ap1 = new P<A>(new B()); //A的子类
class A {
}
class B extends A{
}
3.简写形式
P<A> ap = new P(new A());
五、自定义泛型
1.自定义方法使用类声明的泛型
在形参列表中传入的数据类型与泛型不一致时会报错,体现规范性
public static void main(String[] args) {
U<String, Double, Integer> u = new U<>();
u.hi("hello", 1.0); //X->String Y->Double
}
class U<X, Y, Z> {
public void hi(X x, Y y) {
} //使用类声明的泛型
}
2.自定义泛型方法
public static void main(String[] args) {
U<String, Double, Integer> u = new U<>();
u.m1("xx",22);
//当调用方法时,传入参数编译器会自己确定类型 会自动装箱
}
class U<X, Y, Z> {
public <X,Y> void m1(X x,Y y){
} //自定义泛型方法
}
这里的自动装箱很有意思,他是在三个类型中自动匹配当前输入的数据类型,也不用考虑顺序问题,如图所示
①泛型数组不能初始化,因为数组在 new 不能确定A 的类型,就无法在内存开空间
错误写法: A[] a=new A[];
②静态方法不能使用类定义的泛型