菜鸡学习day15_01_Map集合（&HashMap集合&LinkedHashMap集合&HashTable集合）

菜鸡学习day15_01

package day15;

import java.util.*;

/*
Map集合
特点
1.双列集合，一个元素包含两个值K（key）和V（value）
2.K和V数据类型可以不一致
3.K不允许重复,V可以重复
4.K和V一一对应

HashMap集合
1.底层是哈希表，查询非常快
数组+单向链表/红黑树
2.无序集合
多线程，线程不安全，快

常用方法
1.public V put(key,value);//添加元素，返回被替换的值（若没有替换，返回null）
2.public V remove(key);//删除元素，返回被删除的值
3.public bollean containsKey(key));//判断是否存在key
4.public V get(key);//查找值

5.public Set keySet();获取Map集合中所有的key，放入Set集合中
6.public Set> entrySet();//获取Map集合中所有的键值对对象的集合，放入Set集合中
7.public K getKey();//获取entry中的key
8.public V getValue();//获取entry中的Value

两种遍历方式

自定义类型键值
须在自定义类中重写equals和hashCode，防止key重复

LinkedHashMap集合 extends HashMap
底层时哈希表+链表
有序

HashTable集合
底层是哈希表，单线程，线程安全，慢
不能存储null
已经被取代，其子类Properties是唯一一个和IO流相结合的集合

jdk9集合添加的优化
List，Set，Map接口添加了一个静态方法of，可给集合一次添加多个元素
static List of(E...ele)
注：当元素个数以确定，不再改变时使用
1.of不适用于这些接口的实现类
2.其返回值是一个不能改变的集合
3.Set和Map不能有重复元素

Debug追踪
Debug调试程序（使代码逐行执行）
 */
public class D1501 {
     
    public static void main(String[] args) {
     
        map01();//map集合的常用方法，两种遍历
        mapLianXi();//输入字符串，统计字符个数
        of01();//静态方法of，可给集合一次添加多个元素

    }

    private static void map01() {
     
        Map<String,Integer> map = new HashMap<>();//多态创建对象
        Integer i1 = map.put("小明",17);//添加元素
        System.out.println(i1);//null
        Integer i2 = map.put("小明",16);
        System.out.println(i2);//17，替换第一个value，并返回其值
        map.put("小红",16);
        map.put("小周",13);
        System.out.println(map);//{小周=13, 小明=17, 小红=16}

        System.out.println(map.get("小红"));//读取值，16

        map.remove("小红");//删除元素
        System.out.println(map);//{小周=13, 小明=16}

        System.out.println(map.containsKey("小红"));//判断是否存在k，false

        Set<String> set1 = map.keySet();//获取Map集合中所有的键值对对象的集合，放入Set集合中
        Iterator<String> iter1 = set1.iterator();
        while(iter1.hasNext()){
     //while遍历
            String str = iter1.next();
            System.out.println(map.get(str));
        }
        for(String key : set1){
     //增强for
            Integer i = map.get(key);
            System.out.println(i);
        }

        Set<Map.Entry<String,Integer>> set2 = map.entrySet();//第二种遍历
        Iterator<Map.Entry<String,Integer>> iter2 = set2.iterator();
        while(iter2.hasNext()){
     
            Map.Entry<String,Integer> entry = iter2.next();
            System.out.println(entry);
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        }
    }

    private static void ZiDingYi(){
     //自定义类型键值
        //
        Map<String,Person> map1 = new HashMap<>();
        map1.put("上海",new Person("小明",12));
        map1.put("北京",new Person("小红",13));
        map1.put("重庆",new Person("小周",17));

        //
        Map<Person,String> map2 = new HashMap<>();
        map2.put(new Person("小明",12),"上海");
        map2.put(new Person("小红",13),"北京");
        map2.put(new Person("小周",17),"重庆");

    }

    private static void mapLianXi(){
     //输入字符串，统计字符个数
        Map<Character, Integer> map = new HashMap<>();
        Scanner scan = new Scanner(System.in);
        String str = scan.next();//输入
        for(char c : str.toCharArray()){
     //遍历，放入map中
            if(map.containsKey(c)){
     //key出现多次
                Integer value = map.get(c);
                value++;//累加
                map.put(c,value);
            }
            else{
     
                map.put(c,1);//key只出现一次
            }
        }
        for(Character key : map.keySet()){
     //遍历输出
            Integer value = map.get(key);
            System.out.println(key + "," + value);
        }
    }

    private static void of01(){
     //静态方法of，可给集合一次添加多个元素
        List<String> list = List.of("aaa","bbb","ccc");
        System.out.println(list);
    }
}

package day15;

import java.util.Objects;

public class Person {
     
    private String name;
    private int age;

    public Person() {
     
    }

    public Person(String name, int age) {
     
        this.name = name;
        this.age = age;
    }

    public String getName() {
     
        return name;
    }

    @Override
    public boolean equals(Object o) {
     
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
     
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
     
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

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

    public int getAge() {
     
        return age;
    }

    public void setAge(int age) {
     
        this.age = age;
    }
}