泛型（规定集合中存取数据的类型）
创建集合对象，不使用泛型
好处：集合不使用泛型，默认的类型就是object类型，可以存储任意类型的数据
弊端：不安全，会引发异常
创建集合对象，使用泛型
好处：
1.避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型
2.把运行期异常（代码运行之后抛出异常），提升到编译期（写代码的时候）
弊端：泛型是什么类型，只能存储什么类型的数据
package commonclass;
public class TestGeneric01 {
public static void main(String[] args) {
//不写泛型，默认泛型为object类型
GenericClass genericClass01 = new GenericClass();
genericClass01.setName("object对象");
Object name = genericClass01.getName();//object类型
System.out.println(name);
//在创建对象时，泛型使用Integer类型，
GenericClass<Integer> genericClass02 = new GenericClass<>();
genericClass02.setName(1);//自动装箱
System.out.println(genericClass02.getName());//自动拆箱
//在创建对象时，泛型使用String类型
GenericClass<String> genericClass03 = new GenericClass<>();
genericClass03.setName("张三");
System.out.println(genericClass03.getName());
}
}
/*定义一个含有泛型的类
* 泛型是一个未知的数据类型，只有在创建对象是才被确定，所有当我们不确定使用什么数据类型时，可以使用泛型
* 泛型可以接收任何引用数据类型，不能接收基本数据类型（需要用到其包装类）
* 在创建对象的时候，才能确定泛型的数据类型*/
class GenericClass<E> {
private E name;
public E getName() {
return name;
}
public void setName(E name) {
this.name = name;
}
}
package commonclass;
public class TestGenericMethod01 {
public static void main(String[] args) {
GenericMethod01 genericMethod01 = new GenericMethod01();
//传递什么类型，泛型就是什么类型
genericMethod01.printE(1);
genericMethod01.printE("hello");
}
}
/*定义含有泛型的方法：泛型定义在修饰符和返回值之间
* 格式：
* 修饰符 <泛型> 返回值 方法名(参数列表（使用泛型）){
* 方法体;
* }
* 含有泛型的方法，在调用方法的时候确定泛型的数据类型
* 传递什么参数，泛型就是什么类型*/
class GenericMethod01{
public <E> void printE(E e){
System.out.println(e);
}
}
package commonclass;
//定义含有泛型的接口
public interface GenericIterface<E> {
public abstract void method(E e);
}
package commonclass;
//含有泛型的接口的两种使用方式
//第一种：定义接口的实现类，实现其接口，并指定接口的泛型
public class GenericIterfaceImpl implements GenericIterface<String>{
@Override
public void method(String s) {
System.out.println(s);
}
}
class Test01{
public static void main(String[] args) {
GenericIterfaceImpl genericIterface = new GenericIterfaceImpl();
genericIterface.method("哈哈哈哈");
}
}
package commonclass;
//含有泛型的接口的第二种使用方式：接口使用什么泛型，类就使用什么泛型，类跟着接口走
//就相当于创建了一个含有泛型的类，创建对象时确定泛型
//注意：类名和接口名后都要加泛型格式
public class GenericIterfaceImpl2<E> implements GenericIterface<E>{
@Override
public void method(E e) {
System.out.println(e);
}
}
class Test2{
public static void main(String[] args) {
GenericIterfaceImpl2<String> genericIterfaceImpl2 = new GenericIterfaceImpl2<>();
genericIterfaceImpl2.method("哈哈哈哈哈哈");
}
}
?:代表任意类型的数据
使用方式：不能创建对象时使用，只能作为方法参数使用
package commonclass;
import java.util.ArrayList;
public class TestGeneric02 {
public static void main(String[] args) {
ArrayList<Integer> arrayList = new ArrayList<>();
arrayList.add(1);
arrayList.add(2);
arrayList.add(3);
ArrayList<String> arrayList1 = new ArrayList<>();
arrayList1.add("abc");
arrayList1.add("abc");
arrayList1.add("abc");
printArrayList(arrayList);
printArrayList(arrayList1);
}
/*定义一个方法，能够打印任意数据类型的arrayList集合
* 由于不知道arrayList集合里面的数据类型，可以用通配符来接收数据
* 注意：泛型没有继承关系的*/
public static void printArrayList(ArrayList<?> arrayList){//如果写成ArrayList<object> ，调用方法时会出错，泛型没有继承关系的
for (Object o : arrayList) {
System.out.println(o);
}
}
}
package commonclass;
import java.util.ArrayList;
import java.util.Collection;
/*
* 泛型的上限限定：<? extends E> 代表泛型只能使用其子类/本身
* 泛型的下限限定：<? super E> 代表泛型只能使用其父类/本身
* */
public class TestGeneric03 {
public static void main(String[] args) {
Collection<Integer> list1 = new ArrayList<>();
Collection<String> list2 = new ArrayList<>();
Collection<Number> list3 = new ArrayList<>();
Collection<Object> list4 = new ArrayList<>();
getElement1(list1);
getElement1(list2);//报错
getElement1(list3);
getElement1(list4);//报错
getElement2(list1);//报错
getElement2(list2);//报错
getElement2(list3);
getElement2(list4);
}
/*继承关系
* Integer extends Number extends Object
* String extends Object*/
//泛型的上限限定：<? extends E> 代表泛型只能使用其子类/本身
public static void getElement1(Collection<? extends Number> collection){}
//泛型的下限限定：<? super E> 代表泛型只能使用其父类/本身
public static void getElement2(Collection<? super Number> collection){}
}
分析：
package commonclass;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
//模仿斗地主发牌
public class PracticeAll {
public static void main(String[] args) {
//准备54张牌
Collection<String> arrayList = new ArrayList<>();
arrayList.add("?");
arrayList.add("?");
arrayList.add("?");
arrayList.add("?");
Collection<String> arrayList2 = new ArrayList<>();
for (int i = 2; i <= 10; i++) {
arrayList2.add(Integer.toString(i));
}
arrayList2.add("J");
arrayList2.add("Q");
arrayList2.add("K");
arrayList2.add("A");
ArrayList<String> list = new ArrayList<>();//54张牌集合
for (String al2 : arrayList2) {
for (String al1 : arrayList) {
list.add(al1+al2);
}
}
list.add("joker");
list.add("JOKER");
//输出检查54张牌
for (String s : list) {
System.out.print(s+"\t");
}
System.out.println();
//将54张牌打乱
Collections.shuffle(list);
//输出检查54张牌
for (String s : list) {
System.out.print(s+"\t");
}
System.out.println();
//准备四个集合，容纳三个人的牌和底牌
ArrayList<String> a1 = new ArrayList<>();
ArrayList<String> a2 = new ArrayList<>();
ArrayList<String> a3 = new ArrayList<>();
ArrayList<String> bottom = new ArrayList<>();
//依次每人发一张牌，留下最后三张牌，插底
for (int i = 0; i < list.size(); i++) {
if (i >= 51) {
bottom.add(list.get(i));
continue;
}
if (i % 3 == 0){
a1.add(list.get(i));
continue;
}
if (i % 3 == 1){
a2.add(list.get(i));
continue;
}
if (i % 3 == 2){
a3.add(list.get(i));
continue;
}
}
//对每个人手中的牌进行排序,按花色类型(这儿还可以优化，先按牌大小，再按花色排序)
Collections.sort(a1);
Collections.sort(a2);
Collections.sort(a3);
Collections.sort(bottom);
//查看三个人手中的牌，插底的牌
System.out.println("第一个人手中的牌：");
for (String s : a1) {
System.out.print(s+"\t");
}
System.out.println();
System.out.println("第二个人手中的牌：");
for (String s : a2) {
System.out.print(s+"\t");
}
System.out.println();
System.out.println("第三个人手中的牌：");
for (String s : a3) {
System.out.print(s+"\t");
}
System.out.println();
System.out.println("插底的三张牌：");
for (String s : bottom) {
System.out.print(s+"\t");
}
}
}
原文：https://www.cnblogs.com/zgmzbhqa/p/13471622.html