Java学习 DAY17 无序集合，泛型，映射

Set（散列）

无序
不能存储重复元素
实现类：HasSet、LinkedHashSet、TreeSet

HashSet
底层基于HashMap（基于数组+链表）实现数组存储，不能存储重复元素，不能保证元素存储的顺序恒久不变。默认的初始容量为16，默认加载因子为0.75，每次扩容是在原来的基础上增加一倍。线程不安全的集合。
加载因子越大，某个桶中的节点数越多导致查询效率降低
加载因子越小，进行频繁的扩容与rehash操作，导致大量的内存在浪费。

当某个链表的长度大于8个时，在jdk1.8时会把链表扭转成二叉树进行存储

LinkedHashSet
记录下存储元素对象的位置（LinkedHashMap）

package cn.tedu.collection.set;

import java.util.LinkedHashSet;
public class LinkedHashSetDemo {
    public static void main(String[] args) {
        //创建对象
        LinkedHashSet set=new LinkedHashSet<>();
        //添加元素
        set.add("bc");
        set.add("ac");
        set.add("bc");
        set.add("1abc");
        set.add("a2bc");
        set.add("abc3");
        //
        System.out.println(set);
    }
}

TreeSet
默认给存储元素对象进行排序
类实现Comparable接口产生对象才能存储到TreeSet中，需要指定排序规则（重写compareTo方法），才能进行排序

package cn.tedu.collection.set;

import java.io.Serializable;
import java.util.Iterator;
import java.util.TreeSet;

public class TreeSetDemo {
    public static void main(String[] args) {
        /*//创建集合对象
        TreeSet t=new TreeSet<>();
        //添加元素
        t.add("abc");
        t.add("bc");
        t.add("ac");
        t.add("ab");
        t.add("1abc");
        t.add("a2bc");
        //默认给存储元素对象进行排序---升序排序
        System.out.println(t);*/


        //创建对象
        TreeSet t=new TreeSet<>();
        //添加元素
        t.add(new Hero("鲁班",'男',18888));
        t.add(new Hero("后羿",'男',28888));
        t.add(new Hero("妲己",'女',19888));
        t.add(new Hero("明世隐",'男',18000));
        t.add(new Hero("瑶",'女',38000));

        //ClassCastException---类型转换异常
        //System.out.println(t);
        //遍历输出---集合对象
        for (Hero s:t) {
            System.out.println(s);
        }
        /*Iterator s=t.iterator();
        while (s.hasNext()){
            String
        }*/
    }
}

//代表英雄的类
//只有类实现了Comparable接口产生对象才能存储到TreeSet集合中
class Hero implements Serializable,Comparable {
    //属性
    String name;
    char gender;
    //英雄熟练度---分数
    int score;

    //有参构造
    public Hero(String name,char gender,int score){
        this.name=name;
        this.gender=gender;
        this.score=score;
    }

    //重写toString方法
    @Override
    public String toString() {
        return "Hero{" +
                "name='" + name + '\'' +
                ", gender=" + gender +
                ", score=" + score +
                '}';
    }

    //指定排序规则
    //如果返回值是整数表面前面对象大于后面对象
    //如果返回值是整数表面前面对象小于后面对象
    //如果返回值是0表面前面对象等于后面对象
    @Override
    public int compareTo(Hero o) {//重写的方法
        //根据英雄的分数来给对象进行排序---降序
        return o.score-this.score;
    }
}

Queue（队列）
遵循先进先出的原则
队头元素—第一个存放元素
队尾元素—最后一个存放元素

package cn.tedu.collection.queue;
import java.util.LinkedList;
import java.util.Queue;

public class QueueDemo {
    public static void main(String[] args) {
        //创建队列对象
        Queue q=new LinkedList<>();
        //
        //获取队头元素但是并不删除
        //没有元素（报错）---NoSuchElementException
        //System.out.println(q.element());
        //获取队头元素但是并不删除
        //没有元素---返回null
        System.out.println(q.peek());
    }
}

泛型

参数化类型，jdk1.5新特性
当泛型指定成确切类型时后续只能操作对应类型数据—泛型擦除（编译时期）
泛型的上下限
上限—可以接收类以及子类/接口以及子接口
下限—可以接收类以及父类/接口以及父接口

package cn.tedu.type;

import com.sun.org.apache.xerces.internal.xs.StringList;

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

public class TypeDemo1 {
    public static void main(String[] args) {
        //创建集合对象
        //当不使用泛型时存储数据很方便但是获取数据进行操作时就很复杂
        List list=new ArrayList();
        //三种效果一样，推荐使用方式---jdk1.7
        List list1=new ArrayList<>();
        List list2=new ArrayList();
        List list3=new ArrayList();


        //泛型指定元素类型（默认可以指定成所有的引用类型）
        //当泛型类型指定之后后续操作时都是使用指定类型---泛型擦除（编译时期）

        list1.add("abc");
        list1.add("");
        list1.add("");
        list1.add("");
        list1.add("");
        list1.add("");




        //添加元素
        //没有泛型的指定---可以存储任意类型的数据
        //存储数据很灵活
        list.add(123);
        list.add(true);
        list.add("abc");
        list.add('a');

        //获取集合元素对象
        //Object所有数据类型
        //取出数据时需要确定具体类型---操作复杂
        for (Object s:list) {
            //判断元素对象具体是哪个类型
            if (s instanceof Integer) {
                Integer in= (Integer) s;
            }else if(s instanceof Boolean){
                Boolean b= (Boolean) s;
            }else if(s instanceof String){
                String b= (String) s;
            }else {
                Character c= (Character) s;
            }
            System.out.println(s);
        }
    }
}

package cn.tedu.type;

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

public class TypeDemo2 {
    public static void main(String[] args) {
        //List list=new ArrayList();
        //泛型没有向上造型
        List list1=new ArrayList<>();

        list1.add(123);
        list1.add(23);
        list1.add(13);
        list1.add(12);
        list1.add(1233);
        List list2=new ArrayList<>();
        list2.add(12.45);
        list2.add(1.245);
        list2.add(2.415);
        list2.add(2.4);
        list2.add(2.451);
        List list3=new ArrayList<>();
        list3.add("abc");
        list3.add("bc");
        list3.add("ac");
        list3.add("ab");

        //调用方法
        m(list1);
        m(list2);
        //m(list3);
    }
    //定义方法来遍历所有元素类型时数值类型集合对象
    //?代表泛型可以指定的类
    //---可以接受Number类以及子类
    //---可以接收类以及子类/接口以及子接口
    //泛型的上限
    public static void m(List list){//=new ArrayList()
        for (Object i:list) {
            System.out.println(i);

        }
    }

    //List---可以接受String类以及父类
    //List---可以接收类以及父类/接口以及父接口
    //泛型的下限
    public static void n(List list){
        for (Object i:list) {
            System.out.println(i);

        }
    }
}

映射（Map）

存储有关系（映射关系）的数据的容器
K代表键，V代表值，键不能重复，值可以重复，由键得到对应值，映射是由多个键和多个值来组成
可以把键和值看成键值对，就可以把每个键值对看做成对象，可以把键值对抽取成类（Entry）来表示，Entry产生的每个对象就是一个具体键值对，映射由多个键值对来组成

package cn.tedu.map;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapDemo1 {
    public static void main(String[] args) {
        //创建映射对象
        Map map=new HashMap<>();
        //添加元素
        map.put("abc",123);
        map.put("bc",23);
        map.put("ac",13);
        map.put("ab",12);
        map.put("1abc",1123);
        map.put("a2bc",1223);
        map.put("ab3c",1233);
        //键不能重复，会舍弃掉新的键更新为新的值
        map.put("ab3c",1333);

        //清空映射
        //map.clear();

        //判断是否包含键/值
        //System.out.println(map.containsKey("abc"));
        //System.out.println(map.containsValue(456));

        //把映射中所有键值对放到Set集合中
        //Map.Entry---代表键值对类型
        //Set> S=map.entrySet();

        //由键来获取值
        //System.out.println(map.get("abc"));

        //判断映射是否为空
        //System.out.println(map.isEmpty());

        //把映射中所有的键放到Set集合中
        //Set set=map.keySet();

        //删除元素
        //根据键来删除值对
        //map.remove("abc");
        //保证键和值存在才能删除键值对
        //map.remove("abc",1223);

        //返回键值对的个数
        //System.out.println(map.size());

        //把映射中所有的值放到集合中
        //Collection c=map.values();

        //无序
        //底层由键来确定存储位置，键无序的导致键值也是无序的
        System.out.println(map);
    }
}

映射遍历
1.获取所有的键再获取对应的值
2.获取所有的键值对再获取键和值

package cn.tedu.map;

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

public class MapDemo2 {
    public static void main(String[] args) {
        //创建映射对象
        Map map=new HashMap<>();
        //添加元素
        map.put("abc",123);
        map.put("bc",23);
        map.put("ac",13);
        map.put("ab",12);
        map.put("1abc",1123);
        map.put("a2bc",1223);
        map.put("ab3c",1233);

        //获取所有的键
        Set set=map.keySet();
        //遍历Set集合
        for (String s:set) {
            //由键获取值
            System.out.println(s+"="+map.get(s));
        }
    }
}

package cn.tedu.map;

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

public class MapDemo3 {
    public static void main(String[] args) {
        //创建映射对象
        Map map=new HashMap<>();
        //添加元素
        map.put("abc",123);
        map.put("bc",23);
        map.put("ac",13);
        map.put("ab",12);
        map.put("1abc",1123);
        map.put("a2bc",1223);
        map.put("ab3c",1233);

       /* //获取所有的键值对
        Set> set=map.entrySet();
        //遍历Set集合
        for (Map.Entry m:set) {
            //获取键和值
            //System.out.println(m);
            System.out.println(m.getKey()+"="+m.getValue());
        }*/

        //常用
        for (Map.Entry m: map.entrySet()) {
            //获取键和值
            //System.out.println(m);
            System.out.println(m.getKey()+"="+m.getValue());

        }
    }
}