java学习第七天（待补充）

泛型：广泛的数据类型
确保类型安全的一种途径
定义，在类或方法上都可以使用泛型public class

返回的类型和传入的类型是同一种

    EasyGenericity<J,M,N,Y,Easy> {
    private M m;
    public void test(M m,N n){
    }
    public static <J extends List> J testA(J j){
        return j;
    }
    public <E> E test(E e){
        return e;
    }

类型转换时没有明确对象的数据类型进行强制数据类型转换会抛出ClassCaseException（类型转换异常）

    public static void main(String[] args) {
        testA(new ArrayList());
        //类型安全
        List list=new ArrayList();
        list.add("123");
        for(Object object:list){
            //类型不安全
            String str=(String)object;
            System.out.println(str);
        }
        List<String> listA=new ArrayList<>();
        listA.add("123");

        Map<String,Object> map=new HashMap<>();
        //只要是泛型就是对象
    }
}

数组扩容 syste.marraycopy
set集合
List是有序集合，set是无序集合
有序：取出的顺序和添加的顺序是一样的
无序：不一定是一样的

set数组不能存储重复数据

        //实例化set集合
        HashSet set = new HashSet();
        set.add("23");
        set.remove("123");
        set.size();//看存储了多少数据
        set.add("23");
        int size=set.size();
        System.out.println(size);//1
        //set中不能存储相同的数据

set数组不能存储重复数据的另一种体现（equals）

set.add(new String("456"));
//set.add(456)   456存储的是Integer类型
set.add(new String("456"));
//用equals方法比较两者是否相同，相同则只存储一个
size=set.size();
System.out.println(size);//2

set数组可以存储null值，将set数组内元素打印，可以看到，set数组按照从小到大的顺序有序排列

set.add(null);
size=set.size();
System.out.println(size);//3  可以存储null值
for(Object item:set){
     System.out.print(item+",");
}//null,23,456

TreeSet中不能存储null值，
TreeSet遍历方式是中序遍历（先遍历左子树，再根节点，再右子树）
先序遍历(根左右)，中序遍历（左根右），后序遍历（左右根）

//TreeSet   红黑树
TreeSet tSet = new TreeSet();
//存入数据
tSet.add(2);tSet.add(200);
tSet.add(3);tSet.add(88);
tSet.add(45);tSet.add(72);
tSet.add(1);tSet.add(99);
for(Object item:tSet){
     System.out.print(item+",");
}//1,2,3,45,72,88,99,200,

tSet.add(null);//不能存null值，本代码报错

TreeSet 内部使用二叉树，内部节点是可以比较大小
同一个TreeSet对象中存储的内容都应该是可比较的
默认情况下不能存储不同类型的数据

TreeSet的底层实现是TreeMap

Comparator<Student> com = (a,b)->{
    if(a.score==b.score){
         return 0;
}
    return a.score>b.score?1:-1;
};
TreeSet<Student> ttset = new TreeSet<>(com);
Student stua=new Student();stua.score=89;
Student stub=new Student();stub.score=80;
Student stuc=new Student();stuc.score=99;
Student stud=new Student();stud.score=100;
ttset.add(stua);ttset.add(stub);
ttset.add(stuc);ttset.add(stud);
for(Student stu:ttset){
     System.out.println(stu.score);//80,89,99,100,
}
TreeSet<Student> tttset = new TreeSet(com);
Student stuaa=new Student();stuaa.score=89;
tttset.add(stuaa);
stuaa=new Student();stuaa.score=90;
tttset.add(stuaa);
stuaa=new Student();stuaa.score=8;
tttset.add(stuaa);
stuaa=new Student();stuaa.score=4;
tttset.add(stuaa);
for(Student stu:tttset){
     System.out.println(stu.score);//4,8,89,90,
}
        //LinkedHashSet 是有序的集合Set
    }
}
class Student implements Comparable{
    int score;
    public int compareTo(Student o) {
        return 0;
    }
    public int compareTo(Object o) {
        if(o instanceof Student){
            Student item=(Student)o;
            if(this.score==item.score){
                return 0;
            }
            return this.score>item.score?1:-1;
        }else{
            //o对象不是Student就无法比较   这是程序运行时出现的特殊情况
            //异常情况  我们的方法处理不了这种情况，就要抛出一个异常对象
            //告知调用此方法的代码
            throw new RuntimeException("传入对象不可比较");
        }
    }
}

HashMap 的数组默认容量 16
每次扩容 2倍
扩容阈值 0.75
一个链达到8就对该链进行树化
一支树上的元素低于6个，这个树就会退化成链
最小树化容量阈值 64
如果数组的长度没有达到64，优先扩容
线程安全的Map Hashtable ConcurrentHashMap（性能优异，锁颗粒度比较小）

Map 存储键值对 键：就是名字 值：存储的对象
存入Map数据

Map map= new HashMap();
//存放数据
map.put("A1", "张三");
//可以通过存入的key获取存入的对象
Object obj=map.get("A1");
System.out.println(obj);//张三

删除Map数据，通过key删除键值对,返回value

Object rem_obj=map.remove("A1");
System.out.println("删除的value值："+rem_obj);
//删除的value值：张三

查找Map中是否包含key值和value值

//是否包含key
map.containsKey("A1");
//是否包含value值
map.containsValue("张三");

获取Map中的所有key或value值

//获取所有的key
Set set=map.keySet();
//获取所有的value
Collection con=map.values();

Map的key值是可以比较的，所以在key相同时，尽管他们后面的value不同，最新的key值所对应的value会覆盖上一个值

map.put(null,null);//可以存储null，
key为value只能存一个（待定）
map.put("A1",null);//{null=null, A1=null}
map.put("A1","张三");//{null=null, A1=张三}
System.out.println(map);

TreeMap key应该是可比较的 key不能是null值

Hashtable key和value都不能是null值
Hashtable 是线程安全的集合

Hashtable ht=new Hashtable();
ht.put("t1","张三");
LinkedHashMap lMap=new LinkedHashMap();
lMap.put("","");

ConcurrentHashMap 线程安全 效率较高

ConcurrentHashMap chm=new ConcurrentHashMap();

HashMap 底层实现是数组加链表

HashMap hmap=new HashMap();
hmap.put("","");