泛型、Set接口、内部比较器和外部比较器。

1. 泛型，泛型是jdk1.5中引入的新特性，本质是参数化类型。所以接口中的方法的参数(形参、返回值)不确定时，可以考虑使用泛型接口。

 命名规则：

public interface Fan<E> {

    public void showinfo(E t);

}

public class Test1 implements Fan<String>{
　　　　　　//实现类能确定泛型接口的类型

 @Override 
public void showinfo(String t) { 5 6  } 7 8 }

 1.2 泛型的上限和下限

 1) 泛型的上限 ArrayList(? extends 类1) list 声明了一个容器，容器中的元素类型一定要继承于 类1 ，我们称这种形式叫做泛型的上限。

public class Phone {
    private String model;
    private String name;
    private int signal;
    public String getName;

    
    public String getModel() {
        return model;
    }

    public void setModel(String model) {
        this.model = model;
    }

    public String getName() {
        return name;
    }

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

    public int getSignal() {
        return signal;
    }

    public void setSignal(int signal) {
        this.signal = signal;
    }

    public Phone(String model, String name, int signal) {
        super();
        this.model = model;
        this.name = name;
        this.signal = signal;
    }

    public Phone() {
        super();
        this.signal = 80;
    }
    
    public void showInfo(){
        System.out.println("这是一台："+this.getName());
        System.out.println("信号强度："+this.getSignal());
        System.out.println("型号是："+this.getModel());
    }
    

}

public class NewMachine extends Phone{
    private String inter;

    public String getInter() {
        return inter;
    }

    public void setInter(String inter) {
        this.inter = inter;
    }

    public NewMachine(String model, String name, int signal, String inter) {
        super(model, name, signal);
        this.inter = inter;
    }

    public NewMachine() {
        super();
    }

    @Override
    public void showInfo() {
        super.showInfo();
        System.out.println("新功能："+this.getInter());
    }
}

import java.util.ArrayList;

public class Test1 {
    
    public static void print(ArrayList<? extends Phone> list) {//容器中的元素类型一定要继承于Phone类。（泛型的上限）
        for (Phone phone : list) {
            phone.showInfo();
        }
    }


    public static void main(String[] args) {
        NewMachine phone1 = new NewMachine("MI", "智能手机", 90, "手游优化");
        NewMachine phone2 = new NewMachine("HUAWEI", "智能手机", 90, "手游优化");
        NewMachine phone3 = new NewMachine("MEIZU", "智能手机", 90, "手游优化");
        
        ArrayList<NewMachine> phones = new ArrayList<NewMachine>();
        phones.add(phone1);
        phones.add(phone2);
        phones.add(phone3);
        
        print(phones);//需要声明泛型的上限ArrayList(? extends Pet) list 才能正常使用，不然会出现报错。
            
    }
    
}

 2) 同样，泛型的下限 ArrayList(? super 类2) list 声明了一个容器，容器中的元素类型一定是这个 类2 的父类，我们称这种形式叫做泛型的下限。

 2. Set接口 和 Set的集合实现类HashSet

1) Set是无序的，用于存储不重复的对象集合。在Set集合中存储的对象中，不存在两个对象equals比较为true的情况。

2) HashSet和TreeSet是Set集合的两个常见的实现类，分别用hash表 和 排序二叉树的方式实现了Set集合。HashSet是使用散列算法实现Set的。

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class Test1 {
    public static void main(String[] args) {
        Set<Integer> set = new HashSet<Integer>();
        
        set.add(10);
        set.add(13);
        set.add(55);
        set.add(10);//与第0位添加的10重复
        System.out.println(set); //输出[55, 10, 13]， Set是无序的，存不重复元素，所以不能添加重复元素。
        
        Set<String> set2 = new HashSet<String>();
        set2.add("lemon");
        set2.add("apple");
        set2.add("banana");
        //Set支持Iterator迭代器遍历和快速遍历
        for (String item : set2) {
            System.out.println(item);//输出banana apple  lemon
        }
        
        //迭代器遍历
        Iterator<String> it = set2.iterator();
        while (it.hasNext()) {
            String item1 = it.next();
            System.out.println(item1);//输出banana apple  lemon
        }
        
        //优化写法
        for (Iterator<String> it2 = set2.iterator(); it2.hasNext();) {
            String item3 = it2.next();
            System.out.println(item3);//输出banana apple  lemon
        }
    }
}

 3) TreeSet，底层数据结构是 二叉树 。如果添加的元素本身具备了自然顺序的特征，按自然序输出。

import java.util.Iterator;

import java.util.TreeSet;

public class Test01 {
    public static void main(String[] args) {
        TreeSet<Integer> set = new TreeSet<Integer>();

        set.add(10);
        set.add(13);
        set.add(55);
        set.add(10);// 与第0位添加的10重复
        System.out.println(set); // 输出[10, 13, 55]， Set是无序的，TreeSet的底层数据结构是二叉树，如果元素本身具备了自然顺序的特征，按自然序输出

        TreeSet<String> set2 = new TreeSet<String>();
        set2.add("lemon");
        set2.add("apple");
        set2.add("banana");
        // Set支持Iterator迭代器遍历和快速遍历
        for (String item : set2) {
            System.out.println(item);// 输出 apple banana lemon ，元素本身具备了自然顺序的特征，按自然序输出
        }

        // 迭代器遍历
        Iterator<String> it = set2.iterator();
        while (it.hasNext()) {
            String item1 = it.next();
            System.out.println(item1);// 输出 apple banana lemon，元素本身具备了自然顺序的特征，按自然序输出
        }

        // 优化写法
        for (Iterator<String> it2 = set2.iterator(); it2.hasNext();) {
            String item3 = it2.next();
            System.out.println(item3);// 输出 apple banana lemon，元素本身具备了自然顺序的特征，按自然序输出
        }
    }

}

 4）添加自定义元素，这些元素没有一个自然顺序，就要提供一个当前类的一种比较策略(规则)，比较策略(规则)分两种：内部比较策略 和 外部比较策略。

 ①内部比较策略：要使用 Comparable接口，实现compareTo(T  o)方法。

public class Phone implements Comparable<Phone> {
    private String model;
    private String name;
    private int signal;

    public String getModel() {
        return model;
    }

    public void setModel(String model) {
        this.model = model;
    }

    public String getName() {
        return name;
    }

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

    public int getSignal() {
        return signal;
    }

    public void setSignal(int signal) {
        this.signal = signal;
    }

    public Phone(String model, String name, int signal) {
        super();
        this.model = model;
        this.name = name;
        this.signal = signal;
    }

    public Phone() {
        super();

    }
    
    

    @Override
    public String toString() {
        return "Phone [model=" + model + ", name=" + name + ", signal="
                + signal + "]";
    }

    @Override
    public int compareTo(Phone o) {//多种比较因素
        if (this.getSignal() < o.getSignal()) {
            return -1;
        } else if (this.getSignal() == o.getSignal()) {
            return this.getName().compareTo(o.getName());
        } else {
            return 1;
        }

    }

}

对象实现Comparable并实现compareTo方法时：

import java.util.TreeSet;

public class Test2 {
    public static void main(String[] args) {
        TreeSet<Phone> set = new TreeSet<Phone>();
        
        Phone p1 = new Phone("9P", "MI", 90);
        Phone p2 = new Phone("XS MAX", "APPLE", 80);
        Phone p3 = new Phone("P30", "HUAWEI", 95);
        Phone p4 = new Phone("N10", "NOTE", 99);

        set.add(p1);
        set.add(p2);
        set.add(p3);
        set.add(p4);
        
        System.out.println(set);
        //输出[Phone [model=XS MAX, name=APPLE, signal=80], Phone [model=9P, name=MI, signal=90], Phone [model=P30, name=HUAWEI, signal=95], Phone [model=N10, name=NOTE, signal=99]]

    }

}

 ②外部比较策略:Comparator 位于java.util包中，定义了compare(o1,o2) 用于提供外部比较策略。TreeSet接受一个指定比较策略的构造方法，这些比较策略的实现类必须实现Comparator接口。

import java.util.Comparator;
import java.util.TreeSet;

public class Test {
    public static void main(String[] args) {
        LenComparator lenComparator = new LenComparator();
        
        TreeSet<String> set = new TreeSet<String>(lenComparator);
        
        set.add("lemon");
        set.add("orange");
        set.add("apple");
        set.add("banana");
        System.out.println(set);//输出[lemon, orange]   ，apple的字符长度和lemon一样所以不能添加

    }

}


class LenComparator implements Comparator<String> {//外部比较器，定义字符串长度作为比较

    @Override
    public int compare(String o1, String o2) {
        return o1.length() - o2.length();
    }
}

3. Mapj接口

1）键值对集合或者映射集合，其中的元素(entry)是以键值对(key-value)的形式存在。

2）Map 容器接口中同样提供了增、删、改、查的方式对集合进行操作。

3）Map接口中都是通过key来操作键值对，一般key是已知。通过key获取value。

import java.util.HashMap;
import java.util.Map;

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

        Map<String, String> map = new HashMap<String, String>();

        map.put("A", "apple");
        map.put("L", "lemon");
        map.put("B", "banana");

        String val = map.get("A");

        System.out.println(val.toString());

        System.out.println(map.containsKey("L"));// 查看集合中是否存在 该元素，存在返回true

        System.out.println(map);// 输出{A=apple, B=banana, L=lemon} 键值对集合用大括号括起

    }

}