java定义一个泛型list java定义泛型list参数

一、泛型1、定义

泛型：Java 5后，Java引入了“参数类型”的概念，允许程序在创建集合时指定集合元素的类型。例如，Listt<String>，显示List只能保存字符类型的对象，java的参数类型称为泛型。

一般类型的本质是参数类型（在不创建新类型的情况下，通过一般类型指定的不同类型来控制形状参数的具体限制类型）。也就是说，在一般使用过程中，操作的数据类型被指定为一个参数，可用于类别、接口和方法，分别称为一般类型、一般接口和一般方法。

import java.util.ArrayList;import java.util.List;public class List_text {    public static void main(String[] args) {    ///创建List集合，只保存字符串    List<String> strList = new ArrayList<String>();    strList.add(语文);    strList.add(“英语”);       /*     * Strng类型对象只能添加，Integer对象不能丢入集合    strList.add(5);    */       strList.forEach(str->System.out.println(str.length()));    }}

如果java7以前使用带泛型的接口和类定义变量，则在调用构造器创建对象时，也必须在构造器后面带泛型，例如：

List<String> strList = new ArrayList<String>();Map<String,Integer> scores = new HashMap<String,Integer>();

从Java7开始，只需给出一对尖括号，即可在构造器结束后不需要带来完整的泛型信息（<>）Java可以推断出尖括号中的泛类型是什么

List<String> strList = new ArrayList<>();Map<String,Integer> scores = new HashMap<>();

菱形语法：

package Text;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;public class List_text {    public static void main(String[] args) {    ///创建一个List集合，只保存字符串    List<String> books = new ArrayList<>();    books.add(语文);    books.add(数学);       ///遍历books集合，集合元素是String类型    books.forEach(ele->System.out.println(ele.length()));    //java自动推断Haspmap<>String应该在里面，List<String>    Map<String,List<String>>schoolsInfo = new  HashMap<>();    //java自动推断ArrayList<>应该是String    List<String> schools = new ArrayList<>();    schools.add(“语文选修”);    schools.add(“数学选修”);    schoolsInfo.put(英语”， schools);    ///遍历Map时，Mapkey是String类型，value是List<String>类型    schoolsInfo.forEach((key,value)->System.out.println(key+"-->"+value));    }}

输出：

2

2

英语-->[语文选修， 数学选修]

通用类型是指在实例类型中指出通用类型的具体类型。同一接口可以通过通用类型完成对一组类的操作。最典型的是各种容器类别，如：List、Set、Map。

泛型类是在实例化类中指出泛型的具体类型

public interface List<E>{    ///在这个接口中，E可以用作类型    以下方法可以使用E作为参数类型    void add(E x);    Iterator<E> iteraator();    ...}//定义界面时指定了一种类型的形参，这个形式的参名是EPublic interface Iterator<E>{    ///在这个接口中，E可以作为类型使用    E next();    boolean hasNext();    ..}//定义界面时，指定了两种形参，其形参名为K，Vpublic interface Map<K,V>{    ///在这个接口中K，V可以作为类型使用    Set<K> keySet()    V put(K key,V values)    ……  }

用泛型声明定义Apple<T>Apple用于类别<T>类时可以将T类型引入实际类型，从而生成Apple<String>、Apple<Double>...形式的多个逻辑子类(物理上不存在)

public class Apple<T>{    //使用T型参定理实例变量    private T info;    public Apple() {}        ///在以下方法中使用T类型参类定义构造器        public Apple(T info) {             this.info = info;        }        public void setInfo(T info) {             this.info = info;        }        public T getInfo() {             return this.info;        }        public static void main(String[] args) {             //因为传给T形参的是String，因此，构造器参数只能是String             Apple<String> a1 = new Apple<>(苹果);             //因为Double是传给T形参的，因此，构造器参数只能是Double或Double             Apple<Double> a2 = new Apple<>(5.67);             System.out.println(a2.getInfo());            }}

contnet实例变量在ArryBag类中被声明为“T[]类型，白哦是泛型数组类型。ArryBag类的main()方法首先创建了String类型的数组，然后将其传递给ArrayBag类的结构方法。但是T[]在泛型中是不能通过的 content = new T创建一个数组，也就是说，只能声明泛型数组，不能创建泛型数组的例子。

///这两种创建泛型数组的方法都是正确的<String>[] ls = new ArrayList[10];List<?>[] ls = new ArrayList<?>[10];  ///这种方法不能用来创建泛型数组Listt<String>[] ls = new ArrayList<String>[10];

代码：

public class ArrayBag<T>{     //private T[] content = new T[10];     private T[] content;          public ArrayBag(T[] content) {         this.content = content;     }              public T[] get() {         return this.content;     }              public void set(T[] content) {         this.content = content;     }          public static void main(String[] args) {         String[] content = {book1，“book2”，“book3”};         ArrayBag<String>bag=new  ArrayBag<String>(content);                  for(String c:bag.get())              System.out.println(c);     }}

在定义泛型时，extends关键字可以用来限制类型参数，语法是：

<T extends 类名>    ///T必须是指定类或其子类   或者：<T extends 接口名>    ///T必须是指定接口的实现类

由于对Limitbag类型参数‘’T‘’做了限制‘’<T extends Number>因此，在main()方法中，‘’LimitBag<List>‘’是非法的，因为List不是Number类的子类，不允许给Limitbag类型参数‘’赋值T而‘’。而‘’。LimitBag<Integer>‘’是合法的，因为Integer是Number类的子类，可以赋值Limitbag类型参数‘’T‘’

import java.util.*;public class LimitBag<T extends Number>{     private T content;     public LimitBag(T content) {         this.content = content;     }          public T get() {         return this.content;     }          public void set(T content) {         this.content = content;     }          public static void main(String[] args) {         LimitBag<List>bag1 = new LimitBag<List>(new  ArrayList());    ///编译错误         LimitBag<Integer>bag2 = new  LimitBag<Integer>(12);      ///合法编译     }}

<? super T> 表示类型下界（Java Core被称为超类型限制)，表示参数类型是这类超类型(父类型)，直到Object

为了表示各种泛型List的父类，可以使用类型通配符。类型通配符是问号(？)，将问号作为类型参考传递给List集，写作:List<?>(意思是未知元素类型的List)。这个问号叫通配符，它的元素类型可以与任何类型相匹配。

使用List<?>这种形式表明，这个List集合可以是任何一般List的父类。但是还有一个特殊的情况，我们不想要这个List<?>是任何泛型List的父类，只想说明它是某一类泛型List的父类。

Java泛型不仅可以在使用通配符形参时设置类型上限，还可以在定义类型形参时设置上限，表示创造该类型形参的实际类型必须是上限类型或子类。

在一种方法中，如果该方法的参数或返回值的类型具有”<T>“形式的类型参数，所以这种方法被称为泛型方法。泛型方法可以在普通类型或泛型类型中定义。泛型方法是指在调用该方法时指出泛型的具体类型 。

定义泛型方法语法格式如下：

调用泛型法的语法格式如下：

?泛型对象只读，不能修改，因为类型不确定，可以代表范围内的任何类型；

泛型方法中的泛型参数对象可以修改，因为类型参数T是确定的（在调用方法中确定的），因为T可以在范围内指定任何类型；

Java集合框架中的Tresetet<E>这种设定通配符下限的语法使用了一个结构器，语法如下所示：

TreeSet(Comparator<? super E> c)