Java学习（第七日）

Set集合

List是有序的集合，Set是无序的集合

此处的有序和无序指的是取出的顺序和添加的顺序是否一致，一致即为有序，不一致则为无序

HashSet

//实例化set集合
HashSet hset = new HashSet();

添加元素  .add

查询集合元素数量  .size

注意Set不能存储相同的数据；例：

set.add("23");
set.add("23");
int size=set.size();
System.out.println(size);//输出为1

搜索并删除元素  .remove

set.remove("123");

TreeSet

       TreeSet  内部使用二叉树（红黑树）进行实现。其内部节点是可以比较大小的，
同一个TreeSet对象中存储的内容都应该是可比较的，默认情况下不能存储不同类型

//实例化set集合
TreeSet tset = new TreeSet();

添加元素  .add

hset.add(2); 
hset.add(200);
hset.add(1);
hset.add(78);
hset.add(188);
for(Object item : hset){//遍历
        System.out.print(item+",");
    }//输出1,2,78,188,200,

注意：TreeSet不能存null，null无法比较

类（class）存入TreeSet需要实现Comparator接口

class Student implements Comparable {
    
    int score;
}

方法一：

public class EasySet {

    public static void main(String[] args) {
        Comparator<Student> com = (a, b) -> {
            if (a.score == b.score) {
                return 0;
            }
            return a.score > b.score ? 1 : -1;
        };
        TreeSet<Student> tss=new TreeSet<>(com);
        Student stua=new Student(); stua.score=67;
        Student stub=new Student(); stub.score=89;
        Student stuc=new Student(); stuc.score=60;
        Student stud=new Student(); stud.score=98;
        tss.add(stua);
        tss.add(stub);
        tss.add(stuc);
        tss.add(stud);
        for (Student item : tss) {
            System.out.println(item.score);
        }
    }
}

方法二：

public class EasySet {

    public static void main(String[] args) {
        TreeSet<Student> ttss=new TreeSet();
        Student stue=new Student(); stue.score=74;
        ttss.add(stue);
        Student stuf =new Student(); stuf.score=83;
        ttss.add(stuf);
        Student stug =new Student(); stug.score=61;
        ttss.add(stug);
        Student stuh =new Student(); stuh.score=90;
        ttss.add(stuh);
        for (Student item : ttss) {
            System.out.println(item.score);
        }
    }
}

class Student implements Comparable {

    int score;

    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 ClassCastException("传入对象不可比较");
        }
    }
}

Map

Set 和 List 都是实现了Collection接口的，Map是单独一个接口。

Map 储存键值对，键（key）就是名字，值（value）存储对象

HashMap

public class EasyMap {
    //Map  存储键值对  键 就是名字  值 存储对象
    public static void main(String[] args) {
        Map map = new HashMap();
        //存放数据
        map.put("A1", "张三");
        //可以通过存入的key获取存入的对象
        Object obj=map.get("A1");//获取A1对应的value值
        System.out.println(obj);//"张三"
        //通过key删除键值对
        Object rem_obj=map.remove("A1");
        System.out.println("删除的value值:"+rem_obj);//删除的value值:张三
        //是否包含key
        map.containsKey("A1");
        //是否包含value值
        map.containsValue("张三");
        //获取所有的key
        Set setkey=map.keySet();
        //获取所有的value
        Collection con=map.values();
    }
}

HashMap 的底层实现是数组加链表

HashMap 的数组默认容量为16，容量每次扩容成两倍 ；HashMap扩容阈值为0.75，存入12个内容就扩容 ；一个链上的元素如果达到8就对该链进行树化，一支树上的元素如果低于6这个树就会退化成链；最小树化容量阈值为64，如果数组的长度没有达到64,优先扩容

TreeMap

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

Hashtable

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

ConcurrentHashMap

线程安全，效率较高

泛型

泛型，广泛的数据类型 ；是确保类型安全的一种途径

定义：类或方法上定义泛型

import javax.xml.crypto.dsig.spec.XSLTTransformParameterSpec;
import java.util.*;

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 static <A>void testAA(List<? super A> a){//定义下限

    }

    public <E> E test(E e){
        //返回的类型和传入的类型是同一种
        return e;
    }

    public static void main(String[] args) {
        testA(new ArrayList());
        //testA(new HashSet());

        //类型安全
        List list = new ArrayList();
        list.add("123");
        list.add(new Object());
        for (Object o : list) {
            //类型转换时没有明确对象的数据类型进行强制数据类型转换
            //会抛出ClassCaseException(类型转换异常)
            //类型不安全
            String str = (String)o;//此语句是不正确的
            System.out.println(str);
        }

        //泛型使用
        List<String> listA=new ArrayList<>();

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

    }
}

遍历方式

访问根节点的顺序

先序遍历

先序遍历：A->B->D->E->C->F->G

中序遍历

中序遍历：D->B->E->A->F->C->G

后序遍历

后序遍历：D->E->B->F->G->C->A