Java集合---泛型

尐鸣

已于 2022-02-14 14:46:27 修改

阅读量200

点赞数

文章标签： java 开发语言后端

于 2022-02-14 14:43:44 首次发布

本文链接：https://blog.youkuaiyun.com/qq_46184817/article/details/122924261

版权

泛型概述

泛型：是JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型，它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。类似于C++的模板

参数化类型：就是讲类型原来的具体的类型参数化，然后在使用/调用时传入具体类型，这种参数类型可以用在类，方法和接口中，分别被称为泛型类，泛型方法，泛型接口

泛型定义格式：

<类型>:指定一种类型的格式，这里的类型可以看成是形参
<类型1，类型2...>：指定多种类型的格式，多种类型之间用逗号隔开，这里的类型可以堪称是形参
将来具体调用时候给定的类型可以看成是实参，并且实参类型只能是引用数据类型，不能接受基本类型作为类型参数，与C++不同。因为jvm只认识基本类型和引用类型，泛型是通过类型擦除来实现的，这里的泛型会用Object类，所以只接受引用类型；而C++中每个模板的实例化会产生不同的类型，即产生多份代码，模板代码膨胀

泛型好处：

把运行时期的问题提前到编译期间
避免了强制类型转换

泛型类

泛型类的定义格式：

格式：修饰符 class 类名<类型>{}
范例：public class Generic<T> {}

此处T可以随便写为任意标识，常见的如T、E、K、V等

public class Generic <T>{
    T name;

    public T getName() {
        return name;
    }

    public void setName(T name) {
        this.name = name;
    }
}
public class GenericDemo {
    public static void main(String[] args) {
        Generic g = new Generic();
        g.setName(100);
        System.out.println(g.getName());
        g.setName("hello");
        System.out.println(g.getName());
    }
}

泛型方法

public class Generic {
    public <T> void show(T t){
        System.out.println(t);
    }
}
public class GenericDemo {
    public static void main(String[] args) {
        Generic g = new Generic();
        g.show("hello");
        g.show(30);

    }
}

泛型接口

定义格式：

格式：修饰符 interface 接口名<类型>{ }
范例：public interface Generic<T>{ }

public interface Generic<T> {
    public void show(T t);
}
public class GenericImp<T> implements Generic<T>{
    public void show(T t){
        System.out.println(t);
    }
}
public class GenericDemo {
    public static void main(String[] args) {
        Generic g = new GenericImp();
        g.show("hello");
        g.show(30);
    }
}

类型通配符

为了表示各种泛型List的父类，可以使用类型通配符

类型通配符：<?>
List<?>:表示元素类型未知的List，它的元素可以匹配任何的类型
这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中

如果我们不希望List<?>是任何泛型List的父类，只希望它代表一类泛型List的父类，可以使用类型通配符的上限

类型通配符上限：<? extends 类型>
List<? extends Number>：它表示的类型是Number或者其子类型

除了可以指定类型通配符上限，还可以指定类型通配符的下限

类型通配符下限：<? super 类型>
List<? super Number>:它表示的类型是Number或者其父类型

public class GenericDemo {
    public static void main(String[] args) {
        //类型通配符：<?>
        List<?> list1 = new ArrayList<Object>();
        List<?> list2 = new ArrayList<Number>();
        List<?> list3 = new ArrayList<Integer>();

        //类型通配符上限<? extends 类型>
        List<? extends Number> list4 = new ArrayList<Number>();
        List<? extends Number> list5 = new ArrayList<Integer>();
        List<? extends Number> list6 = new ArrayList<Object>();//报错

        //类型通配符下限<? super 类型>
        List<? super Number> list7 = new ArrayList<Number>();
        List<? super Number> list8 = new ArrayList<Integer>();//报错
        List<? super Number> list9 = new ArrayList<Object>();
    }
}

可变参数

可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了

格式：修饰符返回值类型方法名(数据类型...变量名){ }
范例： public static int sum(int...a){ }

public class ArgsDemo {
    public static void main(String[] args) {
        System.out.println(sum(10, 20));
        System.out.println(sum(10, 20, 30));
        System.out.println(sum(10, 20, 30, 40));
        System.out.println(sum(10, 20, 30, 40, 50));
    }

    public static int sum(int... a) {
        int sum = 0;
        for (int i : a) {
            sum = sum + i;
        }
        return sum;
    }
}

可变参数的注意事项

这里的变量其实是一个数组
如果一个方法有多个参数，包含可变参数，可变参数要放在后面

可变参数的使用

Arrays工具类中有一个静态方法：

public static <T> List<T> asList(T...a):返回由指定数组支持的固定大小的列表
返回的集合不能做增删操作，可以做修改操作

public class ArgsDemo {
    public static void main(String[] args) {
        //public static <T> List<T> asList(T...a):返回由指定数组支持的固定大小的列表
        List<String> list = Arrays.asList("hello", "world", "java");
        //list.add("javase");//UnsupportedOperationException
                //list.remove("hello");//UnsupportedOperationException
        list.set(2,"hello");
        System.out.println(list);
    }
}

List接口中有一个静态方法：