Java基础16 泛型

一、泛型概念

1.**定义： 泛型是一个变量 用于接受数据类型
使用泛型的场景：在实例化集合 不确定其数据类型的时候 就可以使用泛型 **
2.使用泛型：在实例化集合的时候 需要确定其数据类型
语法 ： Lidt<泛型> 集合的名称 = new ArrayList<泛型>();
例子：List< Student> 集合的名称 = new ArrayList< Student>()
3.注意点 ：
A.泛型不能是基本数据类型 只能是引用数据类型
B. 前后的泛型的数据类型必须一致
C. 在jdk1.7之后 出现了灵性的泛型 后面的数据类型可以省略
4.好处：
A.避免多次进行强制类型转换（集合取出对象类型值时，会自动转为Object类，需要强转回来才能正常使用）
B.将运行时异常提前成编译异常
5.泛型常用的一些字母符号 一般是由一些大写字母来构成
例如： E T K V T W …

二、泛型类

1.语法:
访问修饰符 class 类名<泛型> {
类中的所有成员都可以使用使用定义的泛型
}
public class MyList< E> {
…
}

import java.util.ArrayList;
import java.util.List;
public class MyList<E> {
private List<E> li = new ArrayList<>();
public void add(E e){
li.add(e);
}
public E get(int index){
return li.get(index);
}
}

package com.qf.demo01;
public class Test01 {
public static void main(String[] args) {
MyList<String> my = new MyList<>();
my.add("女足给力");
my.add("男足吃烧烤");
System.out.println(my.get(0));
System.out.println(my.get(1));
}
}

三、泛型方法

1.语法:
访问修饰符 <泛型> 返回值类型 方法的名称(参数的列表) {
//方法中的所有的成员 都可以使用其泛型
方法体;
return 返回值;
}
2.例子:public < T> void showInfo(T t){
…
}
3.注意点:
A.普通的成员方法与静态方法都可以定义泛型
B.静态方法是不能使用类的泛型

public class Student {
/**
* 普通的成员方法
* @param t
* @param <T>
*/
public <T> void showInfo(T t){
System.out.println(t);
}
/**
* 静态方法
* @param t
* @param <T>
*/
public static <T> void show(T t){
System.out.println(t);
}
}

public class Test01 {
public static void main(String[] args) {
//实例化Student
Student stu = new Student();
stu.showInfo(9);
stu.showInfo("dddd");
//直接通过类名来进行调用
Student.show(12);
Student.show("ddd");
}
}

例子 ：可以交换任意类型数组内的两个元素
1.参数:带泛型的数组 两个索引值
2.返回值 数组带泛型
3.方法体:根据索引来交换值

public class Student {
/**
*
* @param t
* @param startIndex
* @param endIndex
* @param <T>
* @return
*/
public static <T> T[] showInfo(T[] t,int startIndex,int endIndex){
T temp= t[startIndex];
t[startIndex]=t[endIndex];
t[endIndex]=temp;
return t;
}
}

import java.util.Arrays;
public class Test01 {
public static void main(String[] args) {
Integer [] num= Student.showInfo(new Integer[]{2,3,4,5,6},0,1);
System.out.println(Arrays.toString(num));
}
}

四、泛型接口

1.定义泛型接口两种体现:
A.实现类确定其泛型
B.实现类也不确定其泛型
2.案例
第一种情况
接口类:
public interface Iterator< E>{
E next()
}
实现类:
public final class Scanner implements Iterator< String>{
public String next()
}
第二种情况
接口类:
public interface List< E>{
boolean add(E e)
}
实现类:
public class ArrayListimplements List< E>{
public boolean add(E e)
}
第一种情况

public interface Inner<T>{
T showInfo( T t);
}

public class Impl implements Inner<String> {
@Override
public String showInfo(String s) {
return s;
}
}

public class Test01 {
public static void main(String[] args) {
Impl in = new Impl();
System.out.println(in.showInfo("ddd"));
}
}

第二种情况

public interface Inner<E> {
E showInfo(E e);
}

public class Impl<E> implements Inner<E>{
@Override
public E showInfo(E e) {
return e;
}
}

在声名接口时已经命名了泛型，所以接口内都可以调用，无需再命名

public class Test01 {
public static void main(String[] args) {
Impl<String> im = new Impl<>();
System.out.println(im.showInfo("ddd"));
}
}

五、泛型的通配符

1.泛型的通配符使用?来进行表示 ?可以表示任意的数据类型 一般通配符作为方法的参数使用 实例化
的对象或者是集合的时候不能使用通配符
2.泛型没有继承的概念
3.特例：

<? extends E> ==> E 表示其本身或者是其子类
<? super E> E表示本身或者是其父类
Integer ==> Number ==> Object 继承关系
String ==>Object 继承关系

public class Test01 {
public static void main(String[] args) {
//List<?> list = new ArrayList<?>();
// List<String> list = new ArrayList<>();
// list.add("aa");
// list.add("bb");
// list.add("cc");
// showInfo(list);
List<String> list01 = new ArrayList<>();
List<Integer> list02 = new ArrayList<>();
List<Number> list03 = new ArrayList<>();
List<Object> list04 = new ArrayList<>();
show(list01);
show(list02);
show(list03);
show(list04);
}
public static void showInfo(List<?> list){
System.out.println(list);
}
public static void show(List<? super Number> list){
System.out.println(list);
}
}

六、嵌套Map集合的遍历

1.使用第一个map来存储 不同班级的学员
2.使用map来存储 不同的学科

package day16;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Test03 {
    public static void main(String[] args) {
        //将学生存入JavaMap集合中即java班
        Map<Integer,Student> javaMap = new HashMap<>();
        Student stu1 = new Student(1001,"沈腾");
        Student stu2 = new Student(1002,"马丽");
        Student stu3 = new Student(1003,"贾玲");
        Student stu4 = new Student(1004,"职业法师刘铁柱");
        javaMap.put(1001,stu1);
        javaMap.put(1002,stu2);
        javaMap.put(1003,stu3);
        javaMap.put(1004,stu4);
        //将学生存入webMap集合中即web班
        Map<Integer,Student> webMap = new HashMap<>();
        Student stu5 = new Student(1005,"张小斐");
        Student stu6 = new Student(1006,"常远");
        Student stu7 = new Student(1007,"艾伦");
        Student stu8 = new Student(1008,"潮汐海皇袁华");
        webMap.put(1005,stu5);
        webMap.put(1006,stu6);
        webMap.put(1007,stu7);
        webMap.put(1008,stu8);
        //将javaMap和 webMap 存入qfMap中
        Map<String,Map<Integer,Student>> qfMap = new HashMap<>();
        qfMap.put("java",javaMap);
        qfMap.put("web",webMap);
        //用keySet遍历map
        Set<String> keySet = qfMap.keySet();
        //使用增强for循环
        for (String s : keySet) {
            System.out.println(s);
            //取出第一层map的value，即第二层map 班级map
            Map<Integer, Student> studentMap = qfMap.get(s);
            //对第二层map进行遍历输出
            Set<Integer> integers = studentMap.keySet();
            for (Integer s1 : integers) {
                System.out.println(s1+"\t"+studentMap.get(s1));
            }
        }
        System.out.println("*******************************");
        //用entrySet遍历map
        Set<Map.Entry<String, Map<Integer, Student>>> entry01 = qfMap.entrySet();
        //用迭代器遍历第一层map集合
        Iterator<Map.Entry<String, Map<Integer, Student>>> iterator = entry01.iterator();
        while (iterator.hasNext()){
            Map.Entry<String, Map<Integer, Student>> next01 = iterator.next();
            System.out.println(next01.getKey());
            //取出第一层map的value，即第二层map 班级map
            Map<Integer, Student> value = next01.getValue();
            //对第二层map进行遍历输出
            Set<Map.Entry<Integer, Student>> entry02 = value.entrySet();
            Iterator<Map.Entry<Integer, Student>> entryIterator = entry02.iterator();
            while (entryIterator.hasNext()){
                Map.Entry<Integer, Student> next02 = entryIterator.next();
                System.out.println(next02.getKey()+"\t"+next02.getValue());

            }
        }
    }
}

七、集合工具类 Collections

import com.sun.org.apache.xalan.internal.xsltc.trax.XSLTCSource;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Test {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
int num = Collections.binarySearch(list, 3);
System.out.println(num);
List<Integer> list02 = new ArrayList<>();
list02.add(1);
list02.add(1);
list02.add(1);
list02.add(1);
list02.add(1);
list02.add(1);
Collections.copy(list02,list);
System.out.println(list02);
System.out.println(list);
//Collections.fill(list,10);
System.out.println(list);
int n = Collections.frequency(list, 1);
System.out.println(n);
System.out.println(Collections.max(list));
System.out.println(Collections.min(list));
Collections.reverse(list);
System.out.println(list);
Collections.shuffle(list);
System.out.println(list);
Collections.sort(list);
System.out.println(list);
Collections.swap(list,0,1);
System.out.println(list);
}
}

八、斗地主代码

package doudizhu;

import java.util.*;

public class Doudizhu {
    public static void main(String[] args) {
        //实例化一个map集合   存牌
        Map<Integer,String> map  = new HashMap<>();
        //定义一个list来存储索引   通过索引即key来获取map集合里的value即牌;
        List<Integer> list  = new ArrayList<>();
        //定义两个数组  第一个 花色   数字
        String [] nums={"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        String [] colors = {"♦","♣","♥","♠"};
        //定义一个变量来记录索引值
        int  index=0;
        for (String n : nums) {
            for (String c :colors) {
                map.put(index,c+n);
                list.add(index);
                //索引需要递增
                index++;
            }
        }
//        System.out.println(map);
//        System.out.println(index);
        //添加小王
        map.put(index,"小王");
        list.add(index);
        //添加大王
        index++;
        map.put(index,"大王");
        list.add(index);
        //System.out.println(map);
        //System.out.println(index);
        //洗牌 ==> 洗索引值
        Collections.shuffle(list);//集合工具类的方法随机交换位置
        //发牌  发索引值 用TreeSet有序存储手牌
        TreeSet<Integer> dipai  = new TreeSet<>();
        TreeSet<Integer> gaojin = new TreeSet<>();
        TreeSet<Integer> huazai = new TreeSet<>();
        TreeSet<Integer> xieshun = new TreeSet<>();
        //用取余等0，1，2来进行分牌，
        // 重点思想巧妙，分东西时都可用，取余还可用来获取个 十 百 位
        // 除法自动向下取整，除10根据结果有几个0用来判断位数，除8在加1来判断第几周
        for (int i=0;i<list.size();i++) {
            if(i>=list.size()-3) {
                dipai.add(list.get(i));
            }else if(i % 3 ==0) {
                gaojin.add(list.get(i));
            }else if(i % 3 ==1) {
                huazai.add(list.get(i));
            }else if(i %  3 ==2) {
                xieshun.add(list.get(i));
            }
        }
        /*System.out.println(dipai);
        System.out.println(gaojin);
        System.out.println(huazai);
        System.out.println(xieshun);*/

        //看牌  根据索引取map集合中获取元素
        lookTicket("高进",gaojin,map);
        lookTicket("华仔",huazai,map);
        lookTicket("顺哥",xieshun,map);
        lookTicket("底牌",dipai,map);

    }

    public  static void  lookTicket(String name,TreeSet<Integer> set,Map<Integer,String> map) {
        String str ="";
        //遍历 TreeSet 集合   从map 根据索引来获取数据
        for (Integer in: set) {
            str+= map.get(in) +" ";
        }
        System.out.println(name+":"+str);
    }
}