【Java基础】-- 第13、14章：集合、泛型

Java基础

十三、集合(重难点)

集合基本介绍

1）可以动态保存任意多个对象，使用比较方便

2）提供了一系列方便的操作对象的方法：add、remove、set、get等

3）使用集合添加，删除新元素的代码简洁明了

集合的框架体系

• 集合主要有两组（单列集合，双列集合）
• Collection接口有两个重要的子接口List Set，他们的实现子类都是单列集合
• Map接口的实现子类是双列集合，存放的K-V

Collection接口

Collection接口实现类的特点：

public interface Collection<E> extends Iterable<E>

1）collection实现子类可以存放多个元素，每个元素可以是Object

2）有些Collection的实现类，可以存放重复的元素，有些不可以

3）有些Collection的实现类，有些是有序的（List），有些不是有序的(Set)

4）Collection接口没有直接的实现子类，是通过它的子接口Set和List来实现的

Collection常见方法

Collection 接口常用方法,以实现子类ArrayList 来表示

package com.hspedu.collection_;
import java.util.ArrayList;
import java.util.List;

public class CollectionMethod {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        List list = new ArrayList();
        // add:添加单个元素
        list.add("jack");
        list.add(10);//list.add(new Integer(10))
        list.add(true);
        System.out.println("list=" + list);
        // remove:删除指定元素
        //list.remove(0);//删除第一个元素
        list.remove(true);//指定删除某个元素
        System.out.println("list=" + list);
        // contains:查找元素是否存在
        System.out.println(list.contains("jack"));//T
        // size:获取元素个数
        System.out.println(list.size());//2
        // isEmpty:判断是否为空
        System.out.println(list.isEmpty());//F
        // clear:清空
        list.clear();
        System.out.println("list=" + list);
        // addAll:添加多个元素
        ArrayList list2 = new ArrayList();
        list2.add("红楼梦");
        list2.add("三国演义");
        list.addAll(list2);
        System.out.println("list=" + list);
        // containsAll:查找多个元素是否都存在
        System.out.println(list.containsAll(list2));//T
        // removeAll：删除多个元素
        list.add("聊斋");
        list.removeAll(list2);
        System.out.println("list=" + list);//[聊斋]
        // 说明：以ArrayList 实现类来演示.
    }
}

Collection接口遍历元素

方式一：使用Iterator（迭代器）

基本介绍：

1）Iterator对象称为迭代器，主要用于遍历Collection集合中的对象

2）所有实现了Collection接口的集合类都有一个iterator()方法，用于返回一个实现Iterator接口的对象，即可以返回一个迭代器

3）Iterator的结构

4）Iterator仅用于遍历集合，Iterator本身并不存放对象

package com.Chapter07.Collection_;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Collection01 {
    public static void main(String[] args) {
        Collection col = new ArrayList();

        col.add(new Book("三国演义", "罗贯中", 10.1));
        col.add(new Book("小李飞刀", "古龙", 5.1));
        col.add(new Book("红楼梦", "曹雪芹", 34.6));

        //System.out.println(col);
        //希望能够遍历col集合
        //1.先得到col对应的迭代器
        Iterator iterator = col.iterator();
        //2.使用while循环遍历
        while(iterator.hasNext()){ //判断是否还有元素
            //返回下一个元素，类型是object
            Object obj = iterator.next();
            System.out.println("obj=" + obj);
        }
        //3.当退出while循环后，这时Iterator迭代器，指向最后的元素
        //4.如果希望再次遍历，需要重置我们的迭代器

    }
}
class Book {
    private String name;
    private String author;
    private double price;
    public Book(String name, String author, double price) {
        this.name = name;
        this.author = author;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                '}';
    }
}

方式二：for循环中增强

增强for循环，可以代替iterator迭代器，特点：增强for就是简化版的iterator，本质一样，只能用于遍历集合或数组

基本语法：

for(元素类型 元素名:集合名或数组名){
    访问元素
}

package com.Chapter07.Collection_;

import java.util.ArrayList;
import java.util.Collection;

public class Collection02 {
    public static void main(String[] args) {
        Collection col = new ArrayList();

        col.add(new Book("三国演义", "罗贯中", 10.1));
        col.add(new Book("小李飞刀", "古龙", 5.1));
        col.add(new Book("红楼梦", "曹雪芹", 34.6));


        //1.使用增强for,在Collection集合
        //2.增强for底层依然是迭代器
        //3.增强for可以理解为简化版本的迭代器遍历
        for(Object book:col){
            System.out.println(book);
        }

    }
}

List接口

基本介绍

List接口是Collection接口的子接口

1）List集合类中元素有序（即添加顺序和取出顺序一致）、且可重复

2）List集合中的每个元素都有其对应的顺序索引，即支持索引

3）List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存放容器中的元素

4）JDK API中List接口的实现类有：

常用的有ArrayList，LinkedList和Vector

//1. List 集合类中元素有序(即添加顺序和取出顺序一致)、且可重复[案例]
List list = new ArrayList();
list.add("jack");
list.add("tom");
list.add("mary");
list.add("hsp");
list.add("tom");
System.out.println("list=" + list);
//2. List 集合中的每个元素都有其对应的顺序索引，即支持索引
// 索引是从0 开始的
System.out.println(list.get(3));//hsp

常见方法

List的三种遍历方式

ArrayList、LinkedList、Vector

方式一：使用iterator

Iterator it = col.iterator();
while(it.hasNext()){
    Object o = it.next();
}

方式二：使用增强for

for(Object o:col){
    
}

方式三：使用普通for

for(int i = 0;i<list.size();i++){
    Object object = list.get(i);
    System.out.println(object);
}

ArrayList底层结构和源码分析

ArrayList注意事项

1）permits all elements，including null，ArrayList可以加入null，并且多个

2）ArrayList是由数组来实现数据存储的

3）ArrayList基本等同于Vector，除了ArrayList是线程不安全（执行效率高），在多线程情况下，不建议使用ArrayList

ArrayList的底层操作机制源码分析

1）ArrayList中维护了一个Object类型的数组elementData

• transient Object[] elementData; //transient表示瞬间，短暂的，表示该属性不会被序列化

2）当创建对象时，如果使用的是无参构造器，则初始elementData容量为0，第一次添加，则扩容elementData为10，如需要再次扩容，则扩容elementData为1.5倍

3）如果使用的是指定大小的构造器，则初始elementData容量为指定大小，如果需要扩容，则直接扩容elementData为1.5倍

Vector底层结构和源码剖析

基本介绍

1）Vector类的定义说明

2）Vector底层也是一个对象数组，protected Object[] elementData;

3）Vector是线程同步的，即线程安全，Vector类的操作方法带有synchronized

4）在开发中，需要线程同步安全时，考虑使用vector

package com.hspedu.list_;
import java.util.Vector;

@SuppressWarnings({"all"})
public class Vector_ {
    public static void main(String[] args) {
        //无参构造器
        //有参数的构造
        Vector vector = new Vector(8);
        for (int i = 0; i < 10; i++) {
            vector.add(i);
        }
        vector.add(100);
        System.out.println("vector=" + vector);
        //老韩解读源码
        //1. new Vector() 底层
        /*
        public Vector() {
        	this(10);
        }
        补充：如果是Vector vector = new Vector(8);
        走的方法:
        public Vector(int initialCapacity) {
            this(initialCapacity, 0);
        }
        2. vector.add(i)
        2.1 //下面这个方法就添加数据到vector 集合
        public synchronized boolean add(E e) {
            modCount++;
            ensureCapacityHelper(elementCount + 1);
            elementData[elementCount++] = e;
            return true;
        }
        2.2 //确定是否需要扩容条件： minCapacity - elementData.length>0
        private void ensureCapacityHelper(int minCapacity) {
        // overflow-conscious code
            if (minCapacity - elementData.length > 0)
            grow(minCapacity);
        }
        2.3 //如果需要的数组大小不够用，就扩容, 扩容的算法
        //newCapacity = oldCapacity + ((capacityIncrement > 0) ?
        // capacityIncrement : oldCapacity);
        //就是扩容两倍.
        private void grow(int minCapacity) {
        // overflow-conscious code
            int oldCapacity = elementData.length;
            int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
            capacityIncrement : oldCapacity);
            if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
            if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
            elementData = Arrays.copyOf(elementData, newCapacity);
	}
*/
    }
}

LinkedList底层结构

基本介绍

1）LinkedList实现了双向链表和双端队列特点

2）可以添加任意元素（元素可以重复），包括null

3）线程不安全，没有实现同步

底层操作机制

package com.Chapter07.List_;

import java.util.logging.SocketHandler;

public class LinkList_ {
    public static void main(String[] args) {
        //模拟一个双向链表
        Node jack = new Node("jack");
        Node tom = new Node("tom");
        Node job = new Node("job");

        //连接三个结点
        jack.next = tom;
        tom.next = job;
        job.pre = tom;
        tom.pre = jack;

        Node first = jack; //双向链表的头结点
        Node last = job; //双向链表的为尾结点

        //1. 先创建一个Node 结点，name 就是smith
        Node smith = new Node("smith");
        //下面就把smith 加入到双向链表了
        smith.next = job;
        smith.pre = tom;
        job.pre = smith;
        tom.next = smith;

        //从头到尾遍历
        while(true){
            if(first == null){
                break;
            }
            //输出first信息
            System.out.println(first);
            first = first.next;
        }

        System.out.println("=========");
        //从尾到头遍历
        while(true){
            if(last == null){
                break;
            }
            //输出first信息
            System.out.println(last);
            last = last.pre;
        }
    }
}
class Node{
    public Object item; //真正存放数据
    public Node next; //指向后一个结点
    public Node pre; //指向前一个结点

    public Node(Object item) {
        this.item = item;
    }
    public String toString() {
        return "Node name= "+ item ;
    }
}

LinkedList增删改查

package com.Chapter07.List_;
import java.util.Iterator;
import java.util.LinkedList;

@SuppressWarnings("all")
public class LinkList02 {
    public static void main(String[] args) {
        LinkedList linkedList = new LinkedList();
        linkedList.add(1);
        linkedList.add(2);
        linkedList.add(3);
        System.out.println("linkedList=" + linkedList);
        //演示一个删除结点的
        linkedList.remove(); // 这里默认删除的是第一个结点
        //linkedList.remove(2);
        System.out.println("linkedList=" + linkedList);
        //修改某个结点对象
        linkedList.set(1, 999);
        System.out.println("linkedList=" + linkedList);
        //得到某个结点对象
        //get(1) 是得到双向链表的第二个对象
        Object o = linkedList.get(1);
        System.out.println(o);//999
        //因为LinkedList 是实现了List 接口, 遍历方式
        System.out.println("===LinkeList 遍历迭代器====");
        Iterator iterator = linkedList.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println("next=" + next);
        }
        System.out.println("===LinkeList 遍历增强for====");
        for (Object o1 : linkedList) {
            System.out.println("o1=" + o1);
        }
        System.out.println("===LinkeList 遍历普通for====");
        for (int i = 0; i < linkedList.size(); i++) {
            System.out.println(linkedList.get(i));
        }
        //源码阅读.
    /*
        1. LinkedList linkedList = new LinkedList();
            public LinkedList() {}
        2. 这时linkeList 的属性first = null last = null
        3. 执行添加
        public boolean add(E e) {
            linkLast(e);
            return true;
        }
        4.将新的结点，加入到双向链表的最后
        void linkLast(E e) {
            final Node<E> l = last;
            final Node<E> newNode = new Node<>(l, e, null);
            last = newNode;
            if (l == null)
                first = newNode;
            else
                l.next = newNode;
            size++;
            modCount++;
        }
    */
    /*
        读源码linkedList.remove(); // 这里默认删除的是第一个结点
        1. 执行removeFirst
        public E remove() {
            return removeFirst();
        }
        2. 执行
        public E removeFirst() {
            final Node<E> f = first;
            if (f == null)
                throw new NoSuchElementException();
            return unlinkFirst(f);
        }
        3. 执行unlinkFirst, 将f 指向的双向链表的第一个结点拿掉
        private E unlinkFirst(Node<E> f) {
        // assert f == first && f != null;
            final E element = f.item;
            final Node<E> next = f.next;
            f.item = null;
            f.next = null; // help GC
            first = next;
            if (next == null)
                last = null;
            else
                next.prev = null;
            size--;
            modCount++;
            return element;
        }
*/
    }
}

增加结点：

删除结点：

ArrayList和LinkedList比较

Set接口

基本介绍

1）无序（添加和取出的顺序不一致）没有索引

2）不允许重复元素，所以最多包含一个null

3）JDK API中set接口的实现类有：

常用方法

和List接口一样，Set接口也是Collection的子接口，因此，常用方法和Collection接口一样

遍历方式

同Collection的遍历方式一样，因为Set接口是Collection接口的子接口

• 可以使用迭代器
• 增强for
• 不能使用索引的方式来获取

package com.hspedu.set_;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
@SuppressWarnings({"all"})
public class SetMethod {
    public static void main(String[] args) {
       
        //1. 以Set 接口的实现类HashSet 来讲解Set 接口的方法
        //2. set 接口的实现类的对象(Set 接口对象), 不能存放重复的元素, 可以添加一个null
        //3. set 接口对象存放数据是无序(即添加的顺序和取出的顺序不一致)
        //4. 注意：取出的顺序的顺序虽然不是添加的顺序，但是它是固定的.
        Set set = new HashSet();
        set.add("john");
        set.add("lucy");
        set.add("john");//重复
        set.add("jack");
        set.add("hsp");
        set.add("mary");
        set.add(null);//
        set.add(null);//再次添加null
        for(int i = 0; i <10;i ++) {
            System.out.println("set=" + set);
        }
        //遍历
        //方式1： 使用迭代器
        System.out.println("=====使用迭代器====");
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            System.out.println("obj=" + obj);
        }
        set.remove(null);
        //方式2: 增强for
        System.out.println("=====增强for====");
        for (Object o : set) {
            System.out.println("o=" + o);
        }
        //set 接口对象，不能通过索引来获取
    }
}

Set接口实现类 - HashSet

基本介绍

1）HashSet实现了Set接口

2）HashSet实际上是HashMap

public HashSet{
    map = new HashMap();
}

3）可以存放null值，但是只有一个null

4）HashSet不保证元素是有序的，取决于hash后，再确定索引的结果（即不保证存放的顺序和取出的顺序一致）

5）不能有重复元素/对象

//1. 构造器走的源码
/*
public HashSet() {
map = new HashMap<>();
}
2. HashSet 可以存放null ,但是只能有一个null,即元素不能重复
*/
Set hashSet = new HashSet();
hashSet.add(null);
hashSet.add(null);
System.out.println("hashSet=" + hashSet);

底层机制说明

分析HashSet底层是HashMap，HashMap底层是（数组+链表+红黑树）

模拟数组链表：

package com.Chapter07.HashSet_;

public class HashSet01 {
    public static void main(String[] args) {
        //模拟一个HashSet的底层
        //1.创建一个数组，数组的类型是Node[]
        //2.也有直接把Node[] 数组称为表
        Node[] table = new Node[16];
        //3.创建结点
        Node john = new Node("john",null);

        table[2] = john;
        Node jack = new Node("jack", null);
        john.next = jack;  //将jack挂在到john
        Node rose = new Node("Rose", null);
        jack.next = rose;

        Node lucy = new Node("lucy", null);
        table[3] = lucy;


    }
}
class Node{  //结点，存储数据，可以指向下一个结点，从而形成链表
    Object item;  //存储数据
    Node next; //指向下一个结点

    public Node(Object item, Node next) {
        this.item = item;
        this.next = next;
    }
}

源码分析：

package com.hspedu.set_;
import java.util.HashSet;

@SuppressWarnings({"all"})
public class HashSetSource {
    public static void main(String[] args) {
        HashSet hashSet = new HashSet();
        hashSet.add("java");//到此位置，第1 次add 分析完毕.
        hashSet.add("php");//到此位置，第2 次add 分析完毕
        hashSet.add("java");
        System.out.println("set=" + hashSet);
        /*
        对HashSet 的源码解读
        1. 执行HashSet()
        public HashSet() {
        	map = new HashMap<>();
        }
		2. 执行add()
        public boolean add(E e) {//e = "java"
        	return map.put(e, PRESENT)==null;//(static) PRESENT = new Object();
        }
        3.执行put() , 该方法会执行hash(key) 得到key 对应的hash 值算法h = key.hashCode()) ^ (h >>> 16)
        public V put(K key, V value) {//key = "java" value = PRESENT 共享
        	return putVal(hash(key), key, value, false, true);
        }
        4.执行putVal
        final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
        	Node<K,V>[] tab; Node<K,V> p; int n, i; //定义了辅助变量
        //table 就是HashMap 的一个数组，类型是Node[]
        //if 语句表示如果当前table 是null, 或者大小=0
        //就是第一次扩容，到16 个空间.
        if ((tab = table) == null || (n = tab.length) == 0)
        	n = (tab = resize()).length;
        //(1)根据key，得到hash 去计算该key 应该存放到table 表的哪个索引位置
        //并把这个位置的对象，赋给p
        //(2)判断p 是否为null
        //(2.1) 如果p 为null, 表示还没有存放元素, 就创建一个Node (key="java",value=PRESENT)
        //(2.2) 就放在该位置tab[i] = newNode(hash, key, value, null)
        if ((p = tab[i = (n - 1) & hash]) == null)
        	tab[i] = newNode(hash, key, value, null);
        else {
        //一个开发技巧提示： 在需要局部变量(辅助变量)时候，在创建
        	Node<K,V> e; K k; //
        	//如果当前索引位置对应的链表的第一个元素和准备添加的key 的hash 值一样
        	//并且满足下面两个条件之一:
        	//(1) 准备加入的key 和p 指向的Node 结点的key 是同一个对象
        	//(2) p 指向的Node 结点的key 的equals() 和准备加入的key 比较后相同
        	//就不能加入
        	if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))
        		e = p;
       		//再判断p 是不是一颗红黑树,
        	//如果是一颗红黑树，就调用putTreeVal , 来进行添加
        	else if (p instanceof TreeNode)
        		e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {//如果table 对应索引位置，已经是一个链表, 就使用for 循环比较
        //(1) 依次和该链表的每一个元素比较后，都不相同, 则加入到该链表的最后
        // 注意在把元素添加到链表后，立即判断该链表是否已经达到8 个结点
        // , 就调用treeifyBin() 对当前这个链表进行树化(转成红黑树)
        // 注意，在转成红黑树时，要进行判断, 判断条件
        // if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY(64))
        // resize();
        // 如果上面条件成立，先table 扩容.
        // 只有上面条件不成立时，才进行转成红黑树
        //(2) 依次和该链表的每一个元素比较过程中，如果有相同情况,就直接break
            for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            	}
            }
            ++modCount;
            //size 就是我们每加入一个结点Node(k,v,h,next), size++
            if (++size > threshold)
       	    	resize();//扩容
            afterNodeInsertion(evict);
            return null;
        }
*/
    }
}

package com.hspedu.set_;
import java.util.HashSet;
import java.util.Objects;
@SuppressWarnings({"all"})
public class HashSetIncrement {
    public static void main(String[] args) {
        /*
    HashSet 底层是HashMap, 第一次添加时，table 数组扩容到16，临界值(threshold)是16*加载因子(loadFactor)是0.75 = 12
    如果table 数组使用到了临界值12,就会扩容到16 * 2 = 32,新的临界值就是32*0.75 = 24, 依次类推
*/
        HashSet hashSet = new HashSet();
        // for(int i = 1; i <= 100; i++) {
        // hashSet.add(i);//1,2,3,4,5...100
        // }
        /*
    在Java8 中, 如果一条链表的元素个数到达TREEIFY_THRESHOLD(默认是8 )，并且table 的大小>= MIN_TREEIFY_CAPACITY(默认64),就会进行树化(红黑树),否则仍然采用数组扩容机制
*/
        // for(int i = 1; i <= 12; i++) {
        // hashSet.add(new A(i));//
        // }
        /*
	当我们向hashset 增加一个元素，-> Node -> 加入table , 就算是增加了一个size++
*/
        for(int i = 1; i <= 7; i++) {//在table 的某一条链表上添加了7 个A 对象
            hashSet.add(new A(i));//
        }
        for(int i = 1; i <= 7; i++) {//在table 的另外一条链表上添加了7 个B 对象
            hashSet.add(new B(i));//
        }
    }
}
class B {
    private int n;
    public B(int n) {
        this.n = n;
    }
    @Override
    public int hashCode() {
        return 200;
    }
}
class A {
    private int n;
    public A(int n) {
        this.n = n;
    }
    @Override
    public int hashCode() {
        return 100;
    }
}

Set接口实现类 - LinkedHashSet

基本介绍

1）LinkedHashSet是HashSet的子类

2）LinkedHashSet底层是一个LinkedHashMap，底层维护了一个数组+双向链表

3）LinkedHashSet根据元素的hashCode值来决定元素的存储位置，同时使用链表维护元素的次序（图），这使得元素看起来是以插入顺序保存的

4）LinkedHashSet不允许添加重复元素

Set接口实现类 - TreeSet

源码分析

package com.hspedu.set_;
import java.util.Comparator;
import java.util.TreeSet;

@SuppressWarnings({"all"})
public class TreeSet_ {
    public static void main(String[] args) {
    
        //1. 当我们使用无参构造器，创建TreeSet 时，仍然是无序的
        //2. 老师希望添加的元素，按照字符串大小来排序
        //3. 使用TreeSet 提供的一个构造器，可以传入一个比较器(匿名内部类)
        // 并指定排序规则
        //4. 简单看看源码
      
        /*
        1. 构造器把传入的比较器对象，赋给了TreeSet 的底层的TreeMap 的属性this.comparator
        public TreeMap(Comparator<? super K> comparator) {
            this.comparator = comparator;
        }
        2. 在调用treeSet.add("tom"), 在底层会执行到
        if (cpr != null) {//cpr 就是我们的匿名内部类(对象)
            do {
                parent = t;
                //动态绑定到我们的匿名内部类(对象)compare
                cmp = cpr.compare(key, t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else //如果相等，即返回0,这个Key 就没有加入
                    return t.setValue(value);
            } while (t != null);
        }
*/
        // TreeSet treeSet = new TreeSet();
        TreeSet treeSet = new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                //下面调用String 的compareTo 方法进行字符串大小比较
                //如果老韩要求加入的元素，按照长度大小排序
                //return ((String) o2).compareTo((String) o1);
                return ((String) o1).length() - ((String) o2).length();
            }
        });
        //添加数据.
        treeSet.add("jack")
        treeSet.add("tom");//3
        treeSet.add("sp");
        treeSet.add("a");
        treeSet.add("abc");//3
        System.out.println("treeSet=" + treeSet);
    }
}

Map接口

Map接口实现类的特点

1）Map与Collection并列存在，用于保存具有映射关系的数据：key-value

2）Map中的key和value可以是任何引用类型的数据，会封装到HashMap$Node对象中

3）Map中的key不允许重复，原因和HashSet一样

4）Map中的value可以重复

5）Map的key可以为null，value也可以为null，注意key为null，只能有一个，value为null，可以多个

6）常用String类作为Map的key

7）key和value之间存在单向一对一关系，即通过指定的key总能找到对应的value

//解读Map 接口实现类的特点, 使用实现类HashMap
//1. Map 与Collection 并列存在。用于保存具有映射关系的数据:Key-Value(双列元素)
//2. Map 中的key 和value 可以是任何引用类型的数据，会封装到HashMap$Node 对象中
//3. Map 中的key 不允许重复，原因和HashSet 一样，前面分析过源码.
//4. Map 中的value 可以重复
//5. Map 的key 可以为null, value 也可以为null ，注意key 为null,
// 只能有一个，value 为null ,可以多个
//6. 常用String 类作为Map 的key
//7. key 和value 之间存在单向一对一关系，即通过指定的key 总能找到对应的value
Map map = new HashMap();
map.put("no1", "韩顺平");//k-v
map.put("no2", "张无忌");//k-v
map.put("no1", "张三丰");//当有相同的k , 就等价于替换
map.put("no3", "张三丰");//k-v
map.put(null, null); //k-v
map.put(null, "abc"); //等价替换
map.put("no4", null); //k-v
map.put("no5", null); //k-v
map.put(1, "赵敏");//k-v
map.put(new Object(), "金毛狮王");//k-v
// 通过get 方法，传入key ,会返回对应的value
System.out.println(map.get("no2"));//张无忌
System.out.println("map=" + map);

8）Map存放数据的key-value示意图，一对k-v是放在一个Node中的，有因为Node实现了Entry接口

Map接口常用方法

• put：添加
• remove：根据键删除映射关系
• get：根据键获取值
• size：获取元素个数
• isEmpty：判断个数是否为0
• clear：清除
• containsKey：查找键是否存在

Map接口遍历方法

• containKey：查找键是否存在
• keySet：获取所有的键
• entrySet：获取所有关系k-v
• values：获取所有的值

package com.Chapter07.Map_;
import java.util.*;
@SuppressWarnings("all")
public class Map02 {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("邓超", "孙俪");
        map.put("王宝强", "马蓉");
        map.put("宋喆", "马蓉");
        map.put("刘令博", null);
        map.put(null, "刘亦菲");
        map.put("鹿晗", "关晓彤");

        //第一种：先取出所有的key，通过ke取出对应的value
        Set keyset = map.keySet();
        //(1)增强for
        System.out.println("-----第一种方式-------");
        for (Object key : keyset) {
            System.out.println(key + "-" + map.get(key));
        }
        //(2) 迭代器
        System.out.println("----第二种方式--------");
        Iterator iterator = keyset.iterator();
        while (iterator.hasNext()) {
            Object key = iterator.next();
            System.out.println(key + "-" + map.get(key));
        }

        //第二种：把所有的values取出
        Collection values = map.values();
        //这里可以使用所有的Collections 使用的遍历方法
        //(1) 增强for
        System.out.println("---取出所有的value 增强for----");
        for (Object value : values) {
            System.out.println(value);
        }
        //(2) 迭代器
        System.out.println("---取出所有的value 迭代器----");
        Iterator iterator2 = values.iterator();
        while (iterator2.hasNext()) {
            Object value = iterator2.next();
            System.out.println(value);
        }

        //第三种：通过EntrySet来获取k-v
        Set entrySet = map.entrySet();// EntrySet<Map.Entry<K,V>>
        //(1) 增强for
        System.out.println("----使用EntrySet 的for 增强(第3 种)----");
        for (Object entry : entrySet) {
        //将entry 转成Map.Entry
            Map.Entry m = (Map.Entry) entry;
            System.out.println(m.getKey() + "-" + m.getValue());
        }
        //(2) 迭代器
        System.out.println("----使用EntrySet 的迭代器(第4 种)----");
        Iterator iterator3 = entrySet.iterator();
        while (iterator3.hasNext()) {
            Object entry = iterator3.next();
        //System.out.println(next.getClass());//HashMap$Node -实现-> Map.Entry (getKey,getValue)
        //向下转型Map.Entry
            Map.Entry m = (Map.Entry) entry;
            System.out.println(m.getKey() + "-" + m.getValue());
        }


    }
}

Map接口实现类 - HashMap

HashMap小结

HashMap底层机制及源码剖析

package com.Chapter07.HashMap_;
import java.util.HashMap;
@SuppressWarnings("all")
public class HashMap01 {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        map.put("java", 10);//ok
        map.put("php", 10);//ok
        map.put("java", 20);//替换value

        /*
        解读源码
        1.执行构造器new HashMap()
          初始化加载因子loadfactor = 0.75
          HashMap$Node[] table = null
        2. 执行put 调用hash 方法，计算key 的hash 值(h = key.hashCode()) ^ (h >>> 16)
         public V put(K key, V value) {//K = "java" value = 10
            return putVal(hash(key), key, value, false, true);
          }
         3.执行putVal
         final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
            Node<K,V>[] tab; Node<K,V> p; int n, i;//辅助变量
            //如果底层的table 数组为null, 或者length =0 , 就扩容到16
            if ((tab = table) == null || (n = tab.length) == 0)
                n = (tab = resize()).length;
            //取出hash 值对应的table 的索引位置的Node, 如果为null, 就直接把加入的k-v
            //, 创建成一个Node ,加入该位置即可
            if ((p = tab[i = (n - 1) & hash]) == null)
                tab[i] = newNode(hash, key, value, null);
            else {
                Node<K,V> e; K k;//辅助变量
            // 如果table 的索引位置的key 的hash 相同和新的key 的hash 值相同，
            // 并满足(table 现有的结点的key 和准备添加的key 是同一个对象|| equals 返回真)
            // 就认为不能加入新的k-v
                if (p.hash == hash &&
                    ((k = p.key) == key || (key != null && key.equals(k))))
                    e = p;
                else if (p instanceof TreeNode)//如果当前的table 的已有的Node 是红黑树，就按照红黑树的方式处理
                    e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
                else {
                //如果找到的结点，后面是链表，就循环比较
                    for (int binCount = 0; ; ++binCount) {//死循环
                        if ((e = p.next) == null) {//如果整个链表，没有和他相同,就加到该链表的最后
                            p.next = newNode(hash, key, value, null);
                            //加入后，判断当前链表的个数，是否已经到8 个，到8 个，后
                            //就调用treeifyBin 方法进行红黑树的转换
                            if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                                treeifyBin(tab, hash);
                            break;
                        }
                        if (e.hash == hash && //如果在循环比较过程中，发现有相同,就break,就只是替换value
                            ((k = e.key) == key || (key != null && key.equals(k))))
                            break;
                        p = e;
                    }
                }
                if (e != null) { // existing mapping for key
                    V oldValue = e.value;
                    if (!onlyIfAbsent || oldValue == null)
                        e.value = value; //替换，key 对应value
                    afterNodeAccess(e);
                    return oldValue;
                }
            }
            ++modCount;//每增加一个Node ,就size++
            if (++size > threshold[12-24-48])//如size > 临界值，就扩容
                resize();
            afterNodeInsertion(evict);
            return null;
        }

        5. 关于树化(转成红黑树)
        //如果table 为null ,或者大小还没有到64，暂时不树化，而是进行扩容.
        //否则才会真正的树化-> 剪枝
        final void treeifyBin(Node<K,V>[] tab, int hash) {
            int n, index; Node<K,V> e;
            if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
                resize();
        }

         */

    }
}

Map接口实现类 - Hashtable

基本介绍

1）存放的元素是键值对：即k-v

2）hashTable的键和值都不能为null

3）hashTable使用方法基本上和HashMap一样

4）HashTable是线程安全的（synchronized），HashMap是线程不安全的

HashTable的扩容机制

Hashtable和HashMap对比

	版本	线程安全（同步）	效率	允许null键和值
HashMap	1.2	不安全	高	可以
HashTable	1.0	安全	较低	不可以

Map 接口实现类 - Properties

基本介绍

1）Properties类基础自HashTable类并且实现了Map接口，也是使用一种键值对的形式来保存数据

2）他的使用特点和Hashtable类似

3）Properties还可以用于从xxx.properties文件种，加载数据到Properties类对象，并进行读取和修改

4）说明：xxx.properties文件通常作为配置文件

基本使用

Map接口实现类 - TreeMap

源码分析

package com.hspedu.map_;
import java.util.Comparator;
import java.util.TreeMap;
@SuppressWarnings({"all"})
public class TreeMap_ {
    public static void main(String[] args) {
        //使用默认的构造器，创建TreeMap, 是无序的(也没有排序)
        /*
要求：按照传入的k(String) 的大小进行排序
*/
        // TreeMap treeMap = new TreeMap();
        TreeMap treeMap = new TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                //按照传入的k(String) 的大小进行排序
                //按照K(String) 的长度大小排序
                //return ((String) o2).compareTo((String) o1);
                return ((String) o2).length() - ((String) o1).length();
            }
        });
        treeMap.put("jack", "杰克");
        treeMap.put("tom", "汤姆");
        treeMap.put("kristina", "克瑞斯提诺");
        treeMap.put("smith", "斯密斯");
        treeMap.put("hsp", "韩顺平");//加入不了
        System.out.println("treemap=" + treeMap);
        
        /*
        解读源码：
        1. 构造器. 把传入的实现了Comparator 接口的匿名内部类(对象)，传给TreeMap 的comparator
    	public TreeMap(Comparator<? super K> comparator) {
    		this.comparator = comparator;
    	}
    	2. 调用put 方法
        2.1 第一次添加, 把k-v 封装到Entry 对象，放入root
        Entry<K,V> t = root;
        if (t == null) {
            compare(key, key); // type (and possibly null) check
            root = new Entry<>(key, value, null);
            size = 1;
            modCount++;
            return null;
        }
        2.2 以后添加
        Comparator<? super K> cpr = comparator;
        if (cpr != null) {
            do { //遍历所有的key , 给当前key 找到适当位置
                parent = t;
                cmp = cpr.compare(key, t.key);//动态绑定到我们的匿名内部类的compare
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else //如果遍历过程中，发现准备添加Key 和当前已有的Key 相等，就不添加
                return t.setValue(value);
            } while (t != null);
        }
    
        */
        }
}

选择集合实现类

Collections工具类

基本介绍

1）Collections是一个操作Set、List和Map等集合的工具类

2）Collections中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作

排序操作

1）reverse(List)：反转List中元素的顺序

2）shuffle(List)：对List集合元素进行随机排序

3）sort(List)：根据元素的自然顺序对指定List集合元素按升序排序

4）sort(List,Comparator)：根据指定的Comparator产生的顺序对List集合元素进行排序

5）swap(List,int ,int)：将指定list集合中的i元素和j元素进行交换

查找、替换

1）Object max(Collection)：根据元素的自然顺序，返回给集合中的最大元素

2）Object max(Collection，Comparator)：根据Comparator指定的顺序，返回给定集合中的最大元素

3）Object min(Colllection)

4）Object min(Collection,Comparator)

5）int frequency(Collection,Object)：返回指定集合中指定元素的出现次数

6）void copy(List dest,List src)：将src中的内容复制到dest中

7）boolean replaceAll(List list,Object oldVal,Object newVal)：使用新值替换List对象的所有旧值

练习题

这里 由于p1的name属性发生改变，导致hash值会发生更改，remove方法再次调用hashCode方法，由于name值发生改变，导致remove没有找到需要删除的值，所以没有删除成功

如果只有id重写了hashCode和equals方法，则remove可以删除成功

十四、泛型

泛型

使用传统方法的问题分析

1）不能对加入到集合ArrayList中的数据类型进行约束（不安全）

2）遍历的时候，需要进行类型转换，如果集合中的数据量较大，对效率有影响

泛型的好处

1）编译时，检查添加元素的类型，提高了安全性

2）减少了类型转换的次数，提高效率

• 不使用泛型

  Dog-加入->Object-取出->Dog //放入到ArrayList会先转换为Object，在取出时，还需要转换成Dog

• 使用泛型

  Dog ->Dog ->Dog //放入时和取出时，不需要类型转换，提高效率

3）不再提示编译警告

package com.Chapter08.Generic_;
import java.util.ArrayList;
@SuppressWarnings("all")
public class Generic01 {
    public static void main(String[] args) {
        //使用泛型
        //1.当我们ArrayList<Dog>表示存放在ArrayList集合中的元素是Dog类型
        //2.如果编译器发现添加的类型，不满足要求，就会报错
        //3.在遍历的时候，可以直接取出Dog类型而不是Object
        ArrayList<Dog> arrayList = new ArrayList<Dog>();
        arrayList.add(new Dog("旺财", 10));
        arrayList.add(new Dog("发财", 1));
        arrayList.add(new Dog("小黄", 5));

        //不小心加入了猫
        //arrayList.add(new Cat("小红",9));
        //遍历
        for (Dog dog : arrayList) {
            System.out.println(dog.getName() + "-" + dog.getAge());
        }
    }
}
class Dog{
    private String name;
    private int age;

    public Dog(String name, int age) {
        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;
    }
}
class Cat{
    private String name;
    private int age;

    public Cat(String name, int age) {
        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;
    }
}

泛型介绍

1）泛型又称为参数化类型，是JDK5出现的新特性，解决数据类型的安全性问题

2）在类声明或实例化时只要指定好需要的具体的类型即可

3）Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常，同时代码更加简洁、健壮

4）泛型的作用：可以在类声明时通过一个标识类中某个属性的类型，或者是某个方法的返回值的类型，或者是参数类型

package com.Chapter08.Generic_;

public class Generic02 {
    public static void main(String[] args) {
        Person<String> person = new Person<String>("Java");
        Person<Integer> person1 = new Person<Integer>(100);
    }
}
//泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，
// 或者是某个方法的返回值的类型，或者是参数类型
class Person<E>{
    E s;  //E表示s的数据类型，该数据类型在定义Person对象的时候指定，即在编译期间，就确定E是什么类型

    public Person(E s) { //E也可以是参数类型
        this.s = s;
    }
    public E f(){ //返回类型使用E
        return s;
    }
    public void show() {
		System.out.println(s.getClass());//显示s 的运行类型
	}
}

泛型的语法

使用实例：

package com.hspedu.generic;
import java.util.*;
@SuppressWarnings({"all"})
public class GenericExercise {
    public static void main(String[] args) {
        //使用泛型方式给HashSet 放入3 个学生对象
        HashSet<Student> students = new HashSet<Student>();
        students.add(new Student("jack", 18));
        students.add(new Student("tom", 28));
        students.add(new Student("mary", 19));
        //遍历
        for (Student student : students) {
            System.out.println(student);
        }
        //使用泛型方式给HashMap 放入3 个学生对象
        //K -> String V->Student
        HashMap<String, Student> hm = new HashMap<String, Student>();
        /*
		public class HashMap<K,V> {}
		*/
        hm.put("milan", new Student("milan", 38));
        hm.put("smith", new Student("smith", 48));
        hm.put("hsp", new Student("hsp", 28));
        //迭代器EntrySet
        /*
		public Set<Map.Entry<K,V>> entrySet() {
			Set<Map.Entry<K,V>> es;
			return (es = entrySet) == null ? (entrySet = new EntrySet()) : es;
		}
	*/
        Set<Map.Entry<String, Student>> entries = hm.entrySet();
        /*
		public final Iterator<Map.Entry<K,V>> iterator() {
			return new EntryIterator();
}
*/
        Iterator<Map.Entry<String, Student>> iterator = entries.iterator();
        System.out.println("==============================");
        while (iterator.hasNext()) {
            Map.Entry<String, Student> next = iterator.next();
            System.out.println(next.getKey() + "-" + next.getValue());
        }
    }
}
/**
* 创建3 个学生对象
* 放入到HashSet 中学生对象, 使用.
* 放入到HashMap 中，要求Key 是String name, Value 就是学生对象
* 使用两种方式遍历
*/
class Student {
    private String name;
    private int age;
    public Student(String name, int age) {
        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 String toString() {
        return "Student{" +
            "name='" + name + '\'' +
            ", age=" + age +
            '}';
    }
}

使用细节

package com.hspedu.generic;
import java.util.ArrayList;
@SuppressWarnings({"all"})
public class GenericDetail {
    public static void main(String[] args) {
        //1.给泛型指向数据类型是，要求是引用类型，不能是基本数据类型
        List<Integer> list = new ArrayList<Integer>(); //OK
        //List<int> list2 = new ArrayList<int>();//错误
        //2. 说明
        //因为E 指定了A 类型, 构造器传入了new A()
        //在给泛型指定具体类型后，可以传入该类型或者其子类类型
        Pig<A> aPig = new Pig<A>(new A());
        aPig.f();
        Pig<A> aPig2 = new Pig<A>(new B());
        aPig2.f();
        //3. 泛型的使用形式
        ArrayList<Integer> list1 = new ArrayList<Integer>();
        List<Integer> list2 = new ArrayList<Integer>();
        //在实际开发中，我们往往简写
        //编译器会进行类型推断, 老师推荐使用下面写法
        ArrayList<Integer> list3 = new ArrayList<>();
        List<Integer> list4 = new ArrayList<>();
        ArrayList<Pig> pigs = new ArrayList<>();
        //4. 如果是这样写泛型默认是Object
        ArrayList arrayList = new ArrayList();//等价ArrayList<Object> arrayList = new ArrayList<Object>();
        /*
        public boolean add(Object e) {
        	ensureCapacityInternal(size + 1); // Increments modCount!!
        	elementData[size++] = e;
        	return true;
	}
*/
        Tiger tiger = new Tiger();
        /*
        class Tiger {//类
            Object e;
            public Tiger() {}
            public Tiger(Object e) {
            	this.e = e;
        	}
        }
*/
    }
}
class Tiger<E> {//类
    E e;
    public Tiger() {}
    public Tiger(E e) {
        this.e = e;
    }
}
class A {}
class B extends A {}
class Pig<E> {//
    E e;
    public Pig(E e) {
        this.e = e;
    }
    public void f() {
        System.out.println(e.getClass()); //运行类型
    }
}

自定义泛型

基本语法

class 类名<T,R...>{//可以表示有多个泛型
    
}

注意细节：

1）普通成员可以使用泛型（属性、方法）

2）使用泛型的数组，不能初始化

3）静态方法中不能使用类的泛型

4）泛型类的类型，是在创建对象时确定的（因为创建对象时，需要指定确定类型）

5）如果在创建对象时，没有指定类型，默认为Object

package com.Chapter08.CustomGeneric_;

public class CustomGeneric01 {
    public static void main(String[] args) {

    }
}
//注意：
//1. Tiger 后面泛型，所以我们把Tiger 就称为自定义泛型类
//2, T, R, M 泛型的标识符, 一般是单个大写字母
//3. 泛型标识符可以有多个.
//4. 普通成员可以使用泛型(属性、方法)
//5. 使用泛型的数组，不能初始化
//6. 静态方法中不能使用类的泛型
class Tiger<T,R,M>{
    String name;
    R r;
    M m;
    T t;
    //因为数组在new 不能确定T 的类型，就无法在内存开空间
    //T[] ts = new T[10];

    public Tiger(String name, R r, M m, T t) { //构造器使用泛型
        this.name = name;
        this.r = r;
        this.m = m;
        this.t = t;
    }

    //因为静态是和类相关的，在类加载时，对象还没有创建
    //所以，如果静态方法和静态属性使用了泛型，JVM 就无法完成初始化
    // static R r2;
    // public static void m1(M m) {
    //
    // }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public R getR() {
        return r;
    }

    public void setR(R r) {
        this.r = r;
    }

    public M getM() {
        return m;
    }

    public void setM(M m) {
        this.m = m;
    }

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

自定义泛型接口

基本语法：

interface 接口名<T,R...>{
    
}

注意事项：

1）接口中，静态成员也不能使用泛型（这个和泛型类规定一样）

2）泛型接口的类型，在继承接口或者实现接口时确定

3）没有指定类型，默认为Object

package com.hspedu.customgeneric;
public class CustomInterfaceGeneric {
    public static void main(String[] args) {
    }
}
/**
* 泛型接口使用的说明
* 1. 接口中，静态成员也不能使用泛型
* 2. 泛型接口的类型, 在继承接口或者实现接口时确定
* 3. 没有指定类型，默认为Object
*/
//在继承接口指定泛型接口的类型
interface IA extends IUsb<String, Double> {
}
//当我们去实现IA 接口时，因为IA 在继承IUsu 接口时，指定了U 为String R 为Double
//，在实现IUsu 接口的方法时，使用String 替换U, 是Double 替换R
class AA implements IA {
    @Override
    public Double get(String s) {
        return null;
    }
    @Override
    public void hi(Double aDouble) {
    }
    @Override
    public void run(Double r1, Double r2, String u1, String u2) {
    }
}
//实现接口时，直接指定泛型接口的类型
//给U 指定Integer 给R 指定了Float
//所以，当我们实现IUsb 方法时，会使用Integer 替换U, 使用Float 替换R
class BB implements IUsb<Integer, Float> {
    @Override
    public Float get(Integer integer) {
        return null;
    }
    @Override
    public void hi(Float aFloat) {
    }
    @Override
    public void run(Float r1, Float r2, Integer u1, Integer u2) {
    }
}
//没有指定类型，默认为Object
//建议直接写成IUsb<Object,Object>
class CC implements IUsb { //等价class CC implements IUsb<Object,Object> {
    @Override
    public Object get(Object o) {
        return null;
    }
    @Override
    public void hi(Object o) {
    }
    @Override
    public void run(Object r1, Object r2, Object u1, Object u2) {
    }
}
interface IUsb<U, R> {
    int n = 10;
    //U name; 不能这样使用，在接口中都为静态成员
    //普通方法中，可以使用接口泛型
    R get(U u);
    void hi(R r);
    void run(R r1, R r2, U u1, U u2);
    //在jdk8 中，可以在接口中，使用默认方法, 也是可以使用泛型
    default R method(U u) {
        return null;
    }
}

自定义泛型方法

package com.hspedu.customgeneric;
import java.util.ArrayList;
@SuppressWarnings({"all"})
public class CustomMethodGeneric {
    public static void main(String[] args) {
        Car car = new Car();
        car.fly("宝马", 100);//当调用方法时，传入参数，编译器，就会确定类型
        System.out.println("=======");
        car.fly(300, 100.1);//当调用方法时，传入参数，编译器，就会确定类型
        //测试
        //T->String, R-> ArrayList
        Fish<String, ArrayList> fish = new Fish<>();
        fish.hello(new ArrayList(), 11.3f);
    }
}
//泛型方法，可以定义在普通类中, 也可以定义在泛型类中
class Car {//普通类
    public void run() {//普通方法
    }
    //说明泛型方法
    //1. <T,R> 就是泛型
    //2. 是提供给fly 使用的
    public <T, R> void fly(T t, R r) {//泛型方法
        System.out.println(t.getClass());//String
        System.out.println(r.getClass());//Integer
    }
}
class Fish<T, R> {//泛型类
    public void run() {//普通方法
    }
    public<U,M> void eat(U u, M m) {//泛型方法
    }
    //说明
    //1. 下面hi 方法不是泛型方法
    //2. 是hi 方法使用了类声明的泛型
    public void hi(T t) {
    }
    //泛型方法，可以使用类声明的泛型，也可以使用自己声明泛型
    public<K> void hello(R r, K k) {
        System.out.println(r.getClass());//ArrayList
        System.out.println(k.getClass());//Float
    }
}

泛型的继承和通配符

import java.util.ArrayList;
import java.util.List;

public class GenericExtends {
    public static void main(String[] args) {
        Object o = new String("xx");
        //泛型没有继承性
        //List<Object> list = new ArrayList<String>();
        //举例说明下面三个方法的使用
        List<Object> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        List<AA> list3 = new ArrayList<>();
        List<BB> list4 = new ArrayList<>();
        List<CC> list5 = new ArrayList<>();
        //如果是List<?> c ，可以接受任意的泛型类型
        printCollection1(list1);
        printCollection1(list2);
        printCollection1(list3);
        printCollection1(list4);
        printCollection1(list5);
        //List<? extends AA> c： 表示上限，可以接受AA 或者AA 子类
        // printCollection2(list1);//×
        // printCollection2(list2);//×
        printCollection2(list3);//√
        printCollection2(list4);//√
        printCollection2(list5);//√
        //List<? super AA> c: 支持AA 类以及AA 类的父类，不限于直接父类
        printCollection3(list1);//√
        //printCollection3(list2);//×
        printCollection3(list3);//√
        //printCollection3(list4);//×
        //printCollection3(list5);//×
        // ? extends AA 表示上限，可以接受AA 或者AA 子类
        public static void printCollection2(List<? extends AA> c) {
            for (Object object : c) {
                System.out.println(object);
            }
        }
        //说明: List<?> 表示任意的泛型类型都可以接受
        public static void printCollection1(List<?> c) {
            for (Object object : c) { // 通配符，取出时，就是Object
                System.out.println(object);
            }
        }
        // ? super 子类类名AA:支持AA 类以及AA 类的父类，不限于直接父类，
        //规定了泛型的下限
        public static void printCollection3(List<? super AA> c) {
            for (Object object : c) {
                System.out.println(object);
            }
        }
    }
}
class AA {
}
class BB extends AA {
}
class CC extends BB {
}