day15

1.泛型
(1).泛型:就是所说的类型参数化,即可以象参数一样控制某种数据类型,有了泛型我们就可以指定集合中所能存储的数据类型.
注意: 泛型只在编译时期有效, 对于正确检验泛型结果后，会将泛型的相关信息擦出，也就是说，成功编译过后的class文件中是不包含任何泛型信息的。泛型信息不会进入到运行时阶段。
(2)自定义泛型类
格式:class 类名<泛型符号>{} 符号为任意字母,常用的有T,E,K,V
(3).自定义泛型接口
泛型接口与泛型类的定义及使用基本相同。
interface InterA{
public void show(B b);
}
注意事项:
a.未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中, 如果不声明泛型，如：class FruitGenerator implements Generator，编译器会报错：“Unknown class”
b.当实现泛型接口的类，传入泛型实参时, 则所有使用泛型的地方都要替换成传入的实参类型,即：InterA ，public void show (T t);中的的T都要替换成传入的String类型。
(4).泛型方法
用于放置泛型的类型参数的尖括号应出现在方法的其他所有修饰符之后和在方法的返回类型之前，也就是紧邻返回值之前，下面的
说明：
​ 1）public 与 返回值中间非常重要，可以理解为声明此方法为泛型方法。
​ 2）只有声明了的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
​ 3）表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
​ 4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示型。
(5).泛型通配符
泛型的通配符:
​ 泛型通配符<?>
​ 任意类型，如果没有明确，那么就是Object以及任意的Java类了
​ ? extends E
​ 向下限定，E及其子类
​ ? super E
​ 向上限定，E及其父类
​ 注意: 泛型的通配值只能用在=的左边或者是参数列表上

2.Collections工具类(重点)
集合的工具类
public static void sort(List list) 排序,升序
public static int binarySearch(List<?> list,T key) 二分查找,不存在返回负数,只能针对升序集合
public static T max(Collection<?> coll) 最大值
public static void reverse(List<?> list) 反转
public static void shuffle(List<?> list) 随机打乱
public static void sort(List list, Comparator<? super T> c) 排序,和比较器配合使用

3.比较器
(1).Comparable用法
要想让一个List可以使用Collections.sort进行排序,需要要求集合中的元素所在的类实现Comparable(java.lang) 接口,实现了该接口就具备了排序的能力,才能进行排序,实现该接口我们需要重写里面的compareTo方法,该方法的主要目的就是定义排序的规则(即告诉接口按照什么规则比较大小),重写该方法时要注意,该方法的返回值是int类型,
​ 返回值为正数，表明this中的数据大于参数中的数据, 排序时将大的数移至后面
​ 返回值为0，表明this中的数据等于参数中的数据
​ 返回值为负数，表明this中的数据小于参数中的数据
其实就是用this对象和参数对象做一个比较,this对象在前,就是升序,参数对象在前就是降序.
(2).Comparator用法
降序只需要将Integer中的compareTo方法中的两个参数调换一下位置就可以了,但是由于是class文件我们是不能修改的.所以java为我们提供了一个外部比较器Comparator(java.util)
(3).Comparable和Comparator比较
Comparable: 内部比较器,java.lang; 如果一个List想要使用Collections.sort() 做排序,需要集合中的元素所在的类实现Comparable接口,重写compareTo:
​ this在前,升序; 参数在前 : 降序
Comparator: 外部比较器,java.util; 如果一个类中不能实现Comparable,或者是对应Comparable中的排序方式不满意,可以通过Comparator重新定义排序的规则,而不需要修改原有类的结构, Collections.sort(list,Comparator)//匿名内部类;

4.TreeSet,TreeMap用法(重点)
(1).TreeSet
​ 可以对集合中的元素做排序,必须要求集合中的元素所在的类实现Comparable,元素不能为空
TreeSet: 元素是不可重复的:
HashSet: hashCode/equals
TreeSet: compare/compareTo
(2).TreeMap
可以对map中key这一列做排序,key是不能为null的,因为需要调用compare/compareTo,
如果为空,会出现空指针异常
不可重复性是由compare/compareTo

//节点类
class Node {
    Node next;
    int text;

    public Node() {
    }

    public Node(int text) {
        this.text = text;
    }
}

//新创建链表
class MyLinkedList {
    Node head = null;

    //头部添加
    public void addNode(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
            return;
        }

        Node temp = head;

        while (temp.next != null) {
            temp = temp.next;
        }

        temp.next = newNode;
    }

    //查询指定元素在链表中的位置
    public int getIndex(int data){
        if (length() < 1){
            return -1;
        }

        Node tmp = head;

        int i = 1;
        while(tmp != null){
            if (tmp.text != data){
                tmp = tmp.next;
                i++;
                continue;
            }
            return i;
        }
        return -1;
    }

    //计算链表的长度
    public int length() {
        int length = 0;
        Node temp = head;
        while (temp.next != null) {
            temp = temp.next;
            length++;
        }

        return length;
    }

    //向链表的指定位置插入元素
    public boolean addNode(int index, int data) {

        if (index < 1 || index > length()) {
            return false;
        }

        Node newNode = new Node(data);

        if (index == 1) {
            newNode.next = head;

            head = newNode;

            return true;
        }

        Node tmp = head;

        int i = 1;

        while (tmp.next != null) {
            if (i == index - 1) {
                break;
            }
            tmp = tmp.next;
            i++;
        }

        Node oldNext = tmp.next;
        tmp.next = newNode;
        newNode.next = oldNext;

        return true;
    }

    //删除元素
    public boolean deleteNode(int index) {
        if (index < 1 || index > length()) {
            return false;
        }

        if (index == 1) {
            head = head.next;
            return true;
        }

        //删除第index个节点
        Node tmp = head;
        int i = 1;

        while (tmp.next != null) {
            if (i == index - 1) {
                break;
            }
            tmp = tmp.next;
            i++;
        }

        tmp.next = tmp.next.next;
        return true;
    }

    //从头到尾链表
    public void print() {
        Node tmp = head;
        while(tmp != null){
            System.out.print(" " + tmp.text);
            tmp = tmp.next;
        }

        System.out.println();
    }

}