Java初学者日志_集合_Map

package com.jihe.java1.Map;

import javax.swing.*;
import java.util.*;

/*-----Map接口:双列集合，用来存储一对(key-value)，一对的数据(高中函数：y=f(x),一个key只能对应一个value，一个value可以对应多个一个key)
        /-----HashMap:作为Map的主要实现类线程不安全，效率高，存储null和value
             -------LinkedHashMap:保证在遍历map元素是，可以按照添加的顺序遍历
                         原因：在原有的HashMap基础结构上添加了一对指针，直向前一个和后一个元素
                         对于频繁的遍历操作，此类执行效率高于HashMap
        /-----TreeMap保证按照添加的key-value进行排序，实现排序遍历，按照key的自然排序

        /-----Hashtable：古老的实现类，就像Vector一样，不能存储null和value
             -----Properties 常用来处理配置文件  key和value都是String类型

HashMap的底层：数组+链表 （JDK7之前）
               数组+链表+红黑树 （JDK8）

   面试题：
   1.HashMap的底层结构和实现原理：
   数组+链表 （JDK7之前）
   数组+链表+红黑树 （JDK8）

   2.HashMap和Hashtable的异同
    HashMap:作为Map的主要实现类线程不安全，效率高，存储null和value
    Hashtable：古老的实现类，就像Vector一样，不能存储null和value

   HashMap的底层实现原理：
   HashMap map=new HashMap();
   在实例化以后，底层创建了长度是16的一维数组Entry[] table
   可能已经执行过多次put
   map.put(key1,value1);
    首先，调用key1所在类的hashCode方法，计算key1的Hash值，次hash值经过某种方法计算后，得到在Entry数组中的存放位置

        如果此位置上的数据为空，则key1-value1添加成功  ---情况1

        如果此位置上的数据不为空(意味着此位置存在一个或多个数据(多个数据是指链表形式))，比较key1和已经存在的一个或多个数据的hash值
            如果key1的hash值与已经存在的数据的hash值都不同，此时key1-value1添加成功   ---情况2
            如果key1的hash值与已经存在的数据的hash值相同，继续比较，调用key1所在类的equals方法比较
                    如果equals返回false，此时key1-value1添加成功   ---情况3
                    如果返回true，使用value1替换相同key的value值(修改了原本的value)
    补充：关于情况2和3  此时key1-value1和原数据以链表形式存储
    在不断添加过程中，会涉及到扩容问题，超出临界值(且要存放位置非空时)默认为原容量的2倍
    JDK8 相较于JDK7在底层实现方面不同
        1.new HashMap()：底层没有创建一个长度为16的s数组
        2.jdk8底层数组为：Node[]
        3.首次调用put()方法时，底层创建长度为16的数组
        4.原来jdk7的底层结构只有  数组+链表；jdk8的底层结构有  数组+链表+红黑树
        5.当数组的某一个索引位置上的元素以链表形式存在的数据个数>8,且当前数组长度>64时
        此时索引位置上的所有数据改为使用红黑树存储

        DEFAULT_INITIAL_CAPACITY:HashMap的默认容量：16
        DEFAULT_LOAD_FACTOR:HashMap的默认加载因子：0.75
        threshold：扩容的临界值=容量*填充因子 ：16*0.75=12
        TREEIFY_THRESHOLD: Bucket中链表长度大于默认值（8），转化为红黑树
        MIN_TREEIFY_CAPACITY: Node[]数组被树化时最小的hash表容量为64



        Map中定义的方法

*/
public class map_1 {
    public void test3(){
        /*
        * 添加，删除，修改：
        * Object put(Object key,Object value):将指定key-value添加到当前map对象中
        * void putAll(Map m)；将m中的所有key-value存放到当前的map中
        * Object remove(Object key):移除指定key的key-value对，并返回value
        * void clear():清空当前map中的所有数据
        * */
        Map map=new HashMap();

        //添加
        map.put(1,"aa");
        map.put(2,"bb");
        map.put(3,"cc");
        map.put("four","dd");
        map.put(1,"bb");
        System.out.println(map);
        System.out.println("*********************");
        Map map1=new HashMap();
        map1.put(5,"ss");
        map1.putAll(map);
        System.out.println(map1);
        System.out.println("*********************");
        //移除
        //Object value=map.remove(3);
        System.out.println(map.remove(3));
        System.out.println(map);
        System.out.println("*********************");
        //清空,不是map1=null; map1还存在，只是清除了数据
        map1.clear();
        System.out.println(map1.size());

    }

    public void test4(){

        Map map = new HashMap();
        Map map1 = new HashMap();
        map.put(11,"aa");
        map.put(22,"bb");
        map.put(33,"cc");
        map.put(45,"dd");
        map1.putAll(map);
        //获取key对应的value
        System.out.println(map.get(22));
        System.out.println("*********************");
        //判断当前map中是否包含指定的key
        System.out.println(map.containsKey(22));
        System.out.println("*********************");
        //判断当前map中是否包含指定的value
        System.out.println(map.containsValue("aa"));
        System.out.println("*********************");
        //返回map中key-value的对数
        System.out.println(map.size());
        System.out.println("*********************");
        //判断当前map是否为空
        System.out.println(map.isEmpty());
        System.out.println("*********************");
        //判断当前map和参数对象是否相等
        System.out.println(map.equals(map1));
    }
    public void test5() {
        Map map = new HashMap();
        map.put(11,"aa");
        map.put(22,"bb");
        map.put(33,"cc");
        map.put(45,"dd");
        //遍历所有的key集
        Set set=map.keySet();
        //System.out.println(set);
        Iterator iterator=set.iterator();
            while (iterator.hasNext()){
                System.out.println(iterator.next());
            }
        System.out.println("*********************");
        //遍历所有的value
        Collection set1=map.values();
        for(Object obj:set1){
            System.out.println(obj);
        }
        System.out.println("*********************");
        //遍历所有的 key-value
        Set set2=map.entrySet();
        Iterator iterator1=set2.iterator();
        while (iterator1.hasNext()){
            System.out.println(iterator1.next());
        }
        System.out.println("*********************");
        //遍历，方式二
        Set Keyset=map.keySet();
        Iterator iterator2= Keyset.iterator();
        while (iterator2.hasNext()){
            Object key=iterator2.next();
            System.out.println(key+"------>"+map.get(key));
        }
    }

    public void test2(){
        Map map=new HashMap();

        map = new LinkedHashMap();
        map.put(11,"aa");
        map.put(22,"bb");
        map.put(33,"cc");
        System.out.println(map);

    }
    public void test1(){
        Map map=new HashMap();
        //map.put("null",123);
        map=new Hashtable();
        map.put(null,null);

    }

    public static void main(String[] args) {
        map_1 m=new map_1();
        m.test2();
        System.out.println("+++++++++++++++++++++++++++++++");
        m.test3();
        System.out.println("+++++++++++++++++++++++++++++++");
        m.test4();
        System.out.println("+++++++++++++++++++++++++++++++");
        m.test5();
        System.out.println("+++++++++++++++++++++++++++++++");

    }

}

package com.jihe.java1.Map;

import java.util.Comparator;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeMap;

/*
向TreeMap中添加 key——value，要求key必须是由同一个类创建的对象
排序方式：自然，定制
* */
public class Treemap {
    public void test(){
        //自然排序
        TreeMap treemap=new TreeMap();
        User u1=new User(16,"Tom");
        User u2=new User(26,"feer");
        User u3=new User(15,"jack");
        User u4=new User(128,"rose");
        User u5=new User(3,"alisy");

        treemap.put(u1,98);
        treemap.put(u2,88);
        treemap.put(u3,79);
        treemap.put(u4,80);
        treemap.put(u5,96);
        Set set=treemap.entrySet();
        Iterator iterator=set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
    public void test1(){
        //定制排序
        TreeMap treemap=new TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof User && o2 instanceof User){
                    User u1=(User)o1;
                    User u2=(User)o2;
                    return Integer.compare(u1.getAge(),u2.getAge());
                }
                throw new RuntimeException("输入类型不匹配");
            }
        });
        User u1=new User(16,"Tom");
        User u2=new User(26,"feer");
        User u3=new User(15,"jack");
        User u4=new User(128,"rose");
        User u5=new User(3,"alisy");

        treemap.put(u1,98);
        treemap.put(u2,88);
        treemap.put(u3,79);
        treemap.put(u4,80);
        treemap.put(u5,96);
        Set set=treemap.entrySet();
        Iterator iterator=set.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

    public static void main(String[] args) {
        Treemap t=new Treemap();
        t.test();
        System.out.println("**************");
        t.test1();
    }

}

package com.jihe.java1.Map;

import java.util.Objects;

public class User implements Comparable {
    private int age;
    private String name;

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

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

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

    @Override
    public boolean equals(Object o) {
        System.out.println("User equals");
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return age == user.age &&
                Objects.equals(name, user.name);
    }

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


    //按照姓名从小到大排列,年龄从小到大排列

    @Override
    public int compareTo(Object o) {
        if(o instanceof User){
            User user=(User)o;
            //return this.name.compareTo(user.name);
            //从大到小
            //return -this.name.compareTo(user.name);
            int  compare = this.name.compareTo(user.name);
            if(compare!=0){
                return compare;

            }else {
                return Integer.compare(this.age,user.age);
            }
        }else{
            throw new RuntimeException("输入的类型不匹配");
        }
    }
}

package com.jihe.java1.exer;
//Collections是操作Collection和Map的工具类
//


import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

//面试题：Collection和Collections的区别
//Collection是存储单列数据的集合接口，Collections是个工具类
public class coolections {
    public void test1(){
        List list=new ArrayList();
        list.add(123);
        list.add(456);
        list.add(1);
        list.add(13);
        list.add(23);
        list.add(139);
        list.add(23);
        System.out.println(list);
        //反转(顺序颠倒)
        //Collections.reverse(list);

        //随机化处理
        //Collections.shuffle(list);

        //自然排序
        //Collections.sort(list);

        //定制排序
        //Collections.sort(list,);

        //交换位置
        //Collections.swap(list,1,3);
        //System.out.println(list);
        //获取最大值
        Object obj= Collections.max(list);
        System.out.println(obj);

        //返回集合中指定元素出现的频率
        System.out.println(Collections.frequency(list,23));

        //拷贝
        List list1=new ArrayList();
        for (int i = 0; i < list.size(); i++) {
            list1.add(i);
        }
        Collections.copy(list1,list);
        System.out.println(list1);

    }

    public static void main(String[] args) {
        coolections c=new coolections();
        c.test1();
    }

}