【Java的集合框架工具类 泛型 30】
一、泛型：jdk1.5（或者5.0）出现的安全机制。
好处：
1）、将运行时期出现的问题ClassCastException转到编译时期，泛型技术是给编译器使用的技术，用于编译时期。确保了类型的安全
2）、避免了强制类型转换的麻烦
1、<>什么时候用？
当操作的引用数据类型确定的时候。就是用<>。将要操作的引用数据类型传入即可。其实<>就是一个用于接收具体引用数据类型的参数范围。
在程序中，只要用到了带有<>的类或者接口，就要明确传入具体的引用数据类型。
2、泛型的补偿擦除：运行时，会将泛型去掉，生成的class文件中是不带泛型的，这个称为泛型的擦除，为什么擦除呢？因为为了兼容运行的类加载器。
3、泛型的补偿：在运行时，通过获取元素的类型进行转换动作，不用使用者在强制转换了
--->在程序中，只要用到了带有<>的类或者接口，就要明确传入具体的引用数据类型。
--->泛型不可以往里面写基本数据类型：如：<int> 但是可以写成<Integer>
举例1：
package com.JavaStudy01.Generic; import java.util.ArrayList; import java.util.Iterator; /** * @Author wufq * @Date 2020/8/10 09:57 */ public class GenericDemo01 { public static void main(String[] args){ //确定引用类型是String类型，那么在集合内只能存储String类型的数据， // 即：泛指是确定了引用类型（如：String），然后存储的也是特定的类型(如：String) ArrayList<String> al = new ArrayList<>(); al.add("123"); al.add("456"); // al.add(123);只能存储String类型，不能存其他的类型，因为对ArrayList做了泛指 Iterator<String> it = al.iterator(); while (it.hasNext()){ String str = it.next(); System.out.println(str); } } }
举例2：自定义类型的比较（通过年龄和姓名）
----->通过年龄排序：Personew类<-----------
package com.JavaStudy01.Bean; /** * @Author wufq * @Date 2020/8/10 11:03 */ //Comparable<T>接口用于实现对象的比较，比较时指定了对象则可实现指定对象的比较，如果不指定实现的是Object对象的比较 public class Personew implements Comparable<Personew>{ private String name; private int age; public Personew() { super(); } public Personew(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; } @Override public int compareTo(Personew per) { int temp = this.age-per.age; return temp==0?this.name.compareTo(per.name):temp; } /* public boolean equals（Object obj）{} 这个才是方法覆盖，如果是 public boolean equals（Person p）{} 不是方法覆盖，因为equals是Object的方法，所以方法覆盖时参数”Object obj“不能修改。 */ //Comparable<Personew>泛指以后，IDEA直接用快捷方式：command+N来重写equals和hashCode @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Personew personew = (Personew) o; if (age != personew.age) return false; return name != null ? name.equals(personew.name) : personew.name == null; } @Override public int hashCode() { int result = name != null ? name.hashCode() : 0; result = 31 * result + age; return result; } }
----->通过姓名排序：原始Personew类<-----------
package com.JavaStudy01.Bean; /** * @Author wufq * @Date 2020/8/10 11:03 */ //Comparable<T>接口用于实现对象的比较，比较时指定了对象则可实现指定对象的比较，如果不指定实现的是Object对象的比较 public class Personew { private String name; private int age; public Personew() { super(); } public Personew(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; } }
----->通过姓名排序：ComparatorByNamePers类实现姓名排序<-----------
package com.JavaStudy01.Bean; import java.util.Comparator; /** * @Author wufq * @Date 2020/8/10 14:51 */ public class ComparatorByNamePers implements Comparator<Personew>{ @Override public int compare(Personew o1, Personew o2) { int temp = o1.getName().compareTo(o2.getName()); return temp==0?o1.getAge()-o2.getAge():temp; } }
----->测试类:GenericDemo02类<-----------
package com.JavaStudy01.Generic; import com.JavaStudy01.Bean.ComparatorByNamePers; import com.JavaStudy01.Bean.Personew; import java.util.Iterator; import java.util.TreeSet; /** * @Author wufq * @Date 2020/8/10 11:05 */ public class GenericDemo02 { public static void main(String[] args){ //通过age进行比较 TreeSet<Personew> ts = new TreeSet<>(); ts.add(new Personew("lisi1",21)); ts.add(new Personew("lisi2",22)); ts.add(new Personew("lisi10",28)); ts.add(new Personew("lisi8",10)); Iterator<Personew> it = ts.iterator(); while (it.hasNext()){ Personew p = it.next(); System.out.println(p.getName()+"::"+p.getAge()); } System.out.println("----------------"); //通过name进行比较 TreeSet<Personew> tsp = new TreeSet<>(new ComparatorByNamePers()); tsp.add(new Personew("lisi1",21)); tsp.add(new Personew("lisi2",22)); tsp.add(new Personew("lisi10",28)); tsp.add(new Personew("lisi8",10)); Iterator<Personew> itp = tsp.iterator(); while (itp.hasNext()){ Personew p = itp.next(); System.out.println(p.getName()+"::"+p.getAge()); } } }
二、泛型类、方法、接口
泛型类：
1、如果一个工具类想对所有类进行操作，那么就可以定义一个Object
package com.JavaStudy01.GenericDefault; /** * @Author wufq * @Date 2020/8/10 16:05 */ public class Tool { private Object object; public Object getObject() { return object; } public void setObject(Object object) { this.object = object; } }
2、用工具类调用学生类，需要往里面存一个学生和取一个学生
package com.JavaStudy01.Generic; import com.JavaStudy01.GenericDefault.Tool; import com.JavaStudy01.GenericUtil.Student; import com.JavaStudy01.GenericUtil.Work; /** * @Author wufq * @Date 2020/8/10 15:24 */ public class GenericDemo03 { public static void main(String[] args){ Tool tool = new Tool(); //往里面存了一个学生 tool.setObject(new Student()); tool.setObject(new Work()); //什么对象都能往里面存，好处是扩展性强了，但是也有弊端那就是取对象时都必须的强转。所以需要改进Tool类 //取出来一个学生，学生存进去以后就意味着向上转型了(即：Student向上转为Object)，所以需要强制转换 Student stu= (Student) tool.getObject(); } }
发现：由于工具类里面采用了Object，所以任何对象都可以往里面存，但是的需要强转
3、为了解决这个强转问题，也为了更安全，所以在工具类内引入了泛指类
package com.JavaStudy01.GenericDefault; //使用泛型来接受类中要操作的引用数据类型 // 泛型类。什么时候用？当操作类中的引用类型不确定时，就采用泛型类 public class Tool<QQ>{ private QQ q; public QQ getObject() { return q; } public void setObject(QQ q) { this.q = q; } }
4、使用泛型后的引用
package com.JavaStudy01.Generic; import com.JavaStudy01.GenericDefault.Tool; import com.JavaStudy01.GenericUtil.Student; /** * @Author wufq * @Date 2020/8/10 15:24 */ public class GenericDemo03 { public static void main(String[] args){ // 使用泛型类后的引用 Tool<Student> tool = new Tool<>(); tool.setObject(new Student()); Student stu = tool.getObject();// ---->不需要在进行强转了， } }
泛型方法
将泛型定义在方法上，目的是为了对任何类型进行传入或操作
package com.JavaStudy01.GenericDefault; //使用泛型来接受类中要操作的引用数据类型 // 泛型类。什么时候用？当操作类中的引用类型不确定时，就采用泛型类 public class Tool<QQ>{ private QQ q; public QQ getObject() { return q; } public void setObject(QQ q) { this.q = q; } /*将泛型定义在方法上：目的是可以对任何类型进行传入或操作*/ public <W> void show(W str){ System.out.println(str); } public void print(QQ str){ System.out.println(str); } /* * 当方法静态时，不能访问类上定义的泛型。 * 如果静态方法使用泛型，只需要将泛型定义在方法上 * */ public static <W> void method(W w){ System.out.println(w); } }
package com.JavaStudy01.Generic; import com.JavaStudy01.GenericDefault.Tool; /** * @Author wufq * @Date 2020/8/14 09:41 */ public class GenericDemo04 { public static void main(String[] args){ Tool<String> tool = new Tool<>(); //可以传入任意类型的值 tool.show("123"); tool.show(new Integer(888)); tool.show(1.2); //print方法的参数是泛型类型，同样不能传入任何类型的值 tool.print("567"); // tool.print(new Integer(999)); // //静态方法使用泛型 Tool.method(new Integer(123)); Tool.method("456"); } }
泛型接口
package com.JavaStudy01.Generic; import com.sun.org.apache.xpath.internal.operations.String; /** * @Author wufq * @Date 2020/8/18 16:55 */ public class GenericDemo05 { public static void main(String[] args){ Interclass1<Integer> ic2 = new Interclass1<>(); ic2.method(123); } } interface Inter<T>{ public void method(T t); } //在定义类时不明确类型，但是在方法上是明确的 class Interclass1 <K> implements Inter<K> { @Override public void method(K k) { System.out.println(k); } }
三、泛型限定（上下限定）
可以对类型进行限定：
上限：？ extend E：接收E类型或者E的子类型对象。
下限： ? super E：接收E类型或者E的父类型。
1、举例：多个基本类型的集合迭代（上限）
package com.JavaStudy01.Generic; import java.util.*; /** * @Author wufq * @Date 2020/8/19 10:39 * 泛型限定（上限） * 基本类型：多个集合的迭代 */ public class GenericAdvanceDemo01 { public static void main(String[] args){ ArrayList<String> al = new ArrayList<>(); al.add("abc"); al.add("bbb"); LinkedList<String> al2 = new LinkedList<>(); al2.add("abc"); al2.add("bbb"); HashSet<String> al3 = new HashSet<>(); al3.add("abc"); al3.add("bbb"); printCollection(al); printCollection(al2); printCollection(al3); System.out.println("-----------"); printCollection1(al); System.out.println("-----------"); printCollection2(al); } //多个集合，并且每个集合的类型是不一样的，这时候就需要他们的一个父类的集合Collection public static void printCollection(Collection<String> al) { Iterator<String> it = al.iterator(); while (it.hasNext()){ String msg = it.next(); System.out.println(msg); } } //不光集合是不同的，同样集合内的类型也是不同的并且是未知的-->可以用到通配符：？ public static void printCollection1(Collection<?> al) { Iterator<?> it = al.iterator(); while (it.hasNext()){ // String msg = it.next(); -->通配符因为不知道是什么类型，所以不能赋值给特定的类型 System.out.println(it.next()); } } //指定了一个具体的类型，那么这个类型就可以被操作。所以和通配符的区别在于：通配符不能进行操作，而指定类型确可以操作 public static <T> void printCollection2(Collection<T> al) { Iterator<T> it = al.iterator(); while (it.hasNext()){ T msg = it.next(); System.out.println(msg); } } }
2、举例：多个自定义类型的集合迭代（上限）
package com.JavaStudy01.Generic; import com.JavaStudy01.Bean.Person; import com.JavaStudy01.GenericUtil.Student; import com.JavaStudy01.GenericUtil.Work; import java.util.*; /** * @Author wufq * @Date 2020/8/19 10:47 * 自定义类型：多个集合的迭代 */ public class GenericAdvanceDemo02 { public static void main(String[] args){ ArrayList<Work> al = new ArrayList<>(); al.add(new Work("张三",21)); al.add(new Work("李四",22)); LinkedList<Student> lk = new LinkedList<>(); lk.add(new Student("张三",21)); lk.add(new Student("李四",22)); //打印容器中的元素 -->但是这个容器有个条件？只打印person的子类 printCollectionAction(al); printCollectionAction(lk); } /*public static void printCollectionAction(Collection< Person> al) (Collection<Person> al = new ArrayList<Work>()) -->其实参数是这样的，引用和实体其实是泛型不匹配 { Iterator<String> it = al.iterator(); while (it.hasNext()){ String msg = it.next(); System.out.println(msg); } }*/ //针对以上的错（仍然无法打印Person的子类），改进：只需要把通配符继承一下Person类 public static void printCollectionAction(Collection<? extends Person> al) { Iterator<? extends Person> it = al.iterator(); while (it.hasNext()){ //用Person类接受，迭代器就可以对Person类里面的数据进行操作 Person p = it.next(); System.out.println(p.getName()+"::"+p.getAge()); } } }
2、举例：多个自定义类型的集合迭代（下限）
package com.JavaStudy01.Generic; import com.JavaStudy01.Bean.Person; import com.JavaStudy01.GenericUtil.Student; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; import java.util.LinkedList; /** * @Author wufq * @Date 2020/8/19 11:43 * 泛型限定（下限） */ public class GenericAdvanceDemo03 { public static void main(String[] args){ ArrayList<Person> al = new ArrayList<>(); al.add(new Person("张三",21)); al.add(new Person("李四",22)); LinkedList<Student> lk = new LinkedList<>(); lk.add(new Student("张三",21)); lk.add(new Student("李四",22)); //打印容器中的元素 -->但是这个容器有个条件？只打印person的子类 printCollectionAction(al); printCollectionAction(lk); } public static void printCollectionAction(Collection<? super Student> al) { Iterator<? super Student> it = al.iterator(); while (it.hasNext()){ System.out.println(it.next()); } } }
四、泛指上限、下限、通配符体现。
1、泛指上限：一般在存储元素的时候使用上限，因为这样去除都是按照上限类型来运算的。不会出现类型安全隐患
------->addAll(Collection<? extends E> c)<-------
addAll(Collection<? extends E> c) 将指定Collection中的所有元素都添加到此Collection种
package com.JavaStudy01.Generic; import com.JavaStudy01.Bean.Person; import com.JavaStudy01.GenericUtil.Student; import com.JavaStudy01.GenericUtil.Work; import java.util.ArrayList; import java.util.LinkedList; /** * @Author wufq * @Date 2020/8/24 10:49 * 泛指上限高级应用 * 一般在存储元素的时候使用上限，因为这样去除都是按照上限类型来运算的。不会出现类型安全隐患。 * addAll(Collection<? extends E> c) 将指定Collection中的所有元素都添加到此Collection中 */ public class GenericAdvanceDemo04 { public static void main(String[] args){ ArrayList<Person> al = new ArrayList<>(); al.add(new Person("张三",21)); al.add(new Person("李四",22)); LinkedList<Student> lk = new LinkedList<>(); lk.add(new Student("张三1",21)); lk.add(new Student("李四1",22)); ArrayList<Work> al1 = new ArrayList<>(); al1.add(new Work("张三2",21)); al1.add(new Work("李四2",22)); ArrayList al2 = new ArrayList(); al2.add("uuu"); al.addAll(al2); System.out.println(al.toString()); } } class MyCollection<E>{ public void add(E e){ } public void addAll(MyCollection<? extends E> e){ } } ====执行结果==== [张三::21, 李四::22, uuu]
