JavaSE进阶 | Map集合、HashMap集合、TreeMap集合

这篇具有很好参考价值的文章主要介绍了JavaSE进阶 | Map集合、HashMap集合、TreeMap集合。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录

🏀Map集合概述 

🥅Map接口常用的方法

🥅哈希表(散列表)数据结构

🥅同时重写HashCode和equals

🥅HashMap和Hashtable的区别

🥅Properties类

🥅TreeSet(TreeMap)集合

🥅自平衡二叉树数据结构

🥅实现比较器接口

🥅集合工具类Collections


🏀Map集合概述 

(1)Map和Collection没有继承关系,是一个平级的关系。

(2)Map集合以key和value的方式存储数据:

键值对key和value都是引用数据类型。

key和value都是存储对象的内存地址。

key起到主导的地位,value是key的一个附属品。

④HashMap中的所有的key彼此之间是不可重复的、无序的。所有的key构成一个Set集合。key所在的类重写hashCode()方法和equals()方法。

⑤HashMap中的value彼此之间是可重复的、无序的。所有的value就构成一个Collection集合。value所在的类要重写equals()方法。

⑥HashMap中的一个key-value,就构成一个entry,所有的entry之间是不可重复的、无序的。所有的entry就构成一个Set集合。

(3)HashMap: 底层是哈希表,非线程安全的

(4)Hashtable: 底层也是哈希表,只不过线程是安全的,效率较低使用较少。

(5)Prorerties:线程是安全的,并且key和value只能储存字符串String类型

(6)TreeMap:底层是二叉树,TreeMap集合的key可以自动按照大小顺序排序

(7)HashMap底层使用的是:数组+单向链表+红黑树结构进行存储(JDK8之后)!

 ⭐️Map集合继承结构图

JavaSE进阶 | Map集合、HashMap集合、TreeMap集合

🥅Map接口常用的方法

Map接口中常用方法:

V put(K key, V value)  向Map集合中添加键值对      
V get(Object key)  通过key获取value

void clear()    清空Map集合
boolean containsKey(Object key)  判断Map中是否包含某个key
boolean containsValue(Object value)  判断Map中是否包含某个value
boolean isEmpty()   判断Map集合中元素个数是否为0
V remove(Object key)  通过key删除键值对
int size()  获取Map集合中键值对的个数
Set<K> keySet()  获取Map集合所有的key(所有的键(Key)是一个Set集合)

Collection<V> values()  获取Map集合中所有的value(所有的values是一个Collection集合)
Set<Map.Entry<K,V>> entrySet()  将Map集合转换成Set集合;对于Map结合转换成Set集合怎么理解?假设现在有一个Map集合,如下所示:       

Map集合对象    

            key             value
            ----------------------------
            1               zhangsan
            2               lisi
            3               wangwu
            4               zhaoliu

通过Set set = map1.entrySet();set集合对象的形式,把Map集合的两个值通过=的方式撮合成一个了  

1=zhangsan 
2=lisi  
3=wangwu
4=zhaoliu 

注意:Map集合通过entrySet()方法转换成的这个Set集合,Set集合中元素的类型是 Map.Entry<K,V>Map.Entry和String一样,都是一种类型的名字,只不过:Map.Entry是静态内部类,是Map中的静态内部类 。

 ⭐️回顾静态内部类

package com.bjpowernode.javase.map;

public class Myclass {
    //声明一个静态内部类
    public static class InnerClass{

        // 静态内部类的静态方法
        public static void m1(){
            System.out.println("静态内部类的静态方法执行!");
        }
        
        // 静态内部类的实例方法
        public void m2(){
            System.out.println("静态内部类的实例方法执行!");
        }
    }

    public static void main(String[] args) {
        // 静态方法执行,类名:Myclass.InnerClass
        Myclass.InnerClass.m1();
        // 创建静态内部类对象
        Myclass.InnerClass mi = new Myclass.InnerClass();
        mi.m2(); //执行
        
        //给一个Set集合;改Set集合中存储的对象是:MyClass.InnerClass类型
        Set<Myclass.InnerClass> set = new HashSet<>();

    }
}

⭐️例1:

package com.bjpowernode.javase.map;

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

public class MapTest02 {
    public static void main(String[] args) {
        // 创建Map集合对象
        Map<Integer,String> map = new HashMap<>();
        // 1、向Map集合中添加键值对;put方法
        map.put(1,"张三"); // 1是自动装箱
        map.put(2,"李四");
        map.put(3,"王五");

        // 2、通过key获取value;get方法
        String str = map.get(1);
        System.out.println(str); //张三

        // 3、获取Map集合中键值对的个数;size方法
        System.out.println(map.size()); //3

        // 4、 通过key删除键值对;remove方法
        map.remove(1);
        System.out.println(map.size()); //2

        // contains方法底层调用的都是equals进行比对的,所以自定义的类型需要重写equals方法。
        // 5、判断Map中是否包含某个key;containsKey方法
        boolean b1 = map.containsKey(2);
        System.out.println(b1); // true

        // 6、判断Map中是否包含某个value;containsValue方法
        boolean b2 = map.containsValue("李四");
        System.out.println(b2); // true

        // 7、获取所有的value;values方法,返回的是一个Collection集合
        Collection<String> c = map.values();
        // 遍历打印这个集合
        for(String s:c){ //增加for循环进行打印
            System.out.println(s);
        }

        // 8、清空集合;clear方法
        map.clear();
        System.out.println(map.size()); //0

        // 9、判断Map集合是否为空;isEmpty方法
        System.out.println(map.isEmpty()); // true
    }
}

⭐️例2:遍历Map结合(重点)

对于Map集合的打印方式主要有两种:

(1)第一种方式:先获取所有的key,通过key获取value

Map集合的所有key是一个Set集合,可以用keySet()方法进行获得;

Map集合的所有value是一个Collection集合,可以用values()方法进行获得;

所以我们就可以分为两步:

第一步:先调用keySet()方法获取所有的key,并返回一个Set集合;

第二步:再对Set集合迭代打印时,取出key;然后调用get(key)方法,通过key获取到value

(2)第二种方式:调用entrySet()方法,将Map集合转换成Set集合

①调用Set<Map.Entry<K,V>> entrySet() 转换成Set集合;Map.Entry<K,V>是静态内部类;

②转换成Set集合后利用迭代器打印,在迭代器中获取每一个节点Node(或者说entry,因为Node实现了Map.Entry接口)Map.Entry<Integer,String> node = it2.next();

③然后利用这个节点获取key(node.getkey()方法) 和 value(value(node.getvalue()方法))

package com.bjpowernode.javase.map;

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

// Map集合遍历
public class MapTest03 {
    public static void main(String[] args) {

        //第一种方式:获取所有的key,通过遍历key,来遍历value
        Map<Integer, String> map = new HashMap<>();

        map.put(1, "zhangsan");
        map.put(2, "lisi");
        map.put(3, "wangwu");
        // 先获取所有的key,所有的key是一个Set集合
        Set<Integer> keys = map.keySet();
        // 在遍历key,通过key获取value
        //  方法1:利用迭代器
        Iterator<Integer> it = keys.iterator();
        while (it.hasNext()){
            Integer key = it.next(); //获取其中一个key
            String value = map.get(key); //通过key获取value
            System.out.println(key+"="+value);
        }

        //  方法2:foreach
        for(Integer key:keys){
            System.out.println(key+"="+map.get(key));
        }


        //第二种方式:   Set<Map.Entry<K,V>> entrySet()  将Map集合转换成Set集合
        Set<Map.Entry<Integer,String>> set = map.entrySet();
        // 方法1:使用迭代器进行打印
        Iterator<Map.Entry<Integer,String>>  it2 = set.iterator();
        while(it2.hasNext()){
            Map.Entry<Integer,String> node = it2.next(); //取出一个节点
            Integer key = node.getKey(); //取出节点的key
            String value = node.getValue(); //取出节点的value
            System.out.println(key+"="+value);
        }

        // 方法2:foreach方式
        // 这种方式效率比较高,因为获取key和value都是直接从node对象中获取的属性值。
        // 这种方式比较适合于大数据量。
        for( Map.Entry<Integer,String> node:set){
            System.out.println(node.getKey()+"="+node.getValue());
        }

    }
}

⭐️补充:LinkedHashMap是HashMap的子类,在HashMap使用的数据结构的基础上,增加了一对双向链表,用于记录添加的元素的先后顺序,进而我们在遍历元素时,就可以按照天机的顺序显示!开发中,对于频繁的遍历操作,建议使用此类!

🥅哈希表(散列表)数据结构

哈希表的存储形式:哈希表实际上是一个数组和单向链表的结合体;底层实际上就是一个数组,这个数组中每一个元素是一个单向链表
数组:在查询方面效率很高,随机增删方面效率很低。
单向链表:在随机增删方面效率较高,在查询方面效率很低。
哈希表将以上的两种数据结构融合在一起,充分发挥它们各自的优点。

JavaSE进阶 | Map集合、HashMap集合、TreeMap集合

(1)HashMap集合底层是哈希表/散列表的数据结构。
(2)对于存储数据map.put(k,v)的原理:

第一步:先将k和v封装到一个Node对象当中;

第二步:底层会调用k的hashCode()方法得到对应的hash值;然后通过哈希算法,将hash值转换成数组的下标,下标位置如果没有任何元素,就把Node添加到这个位置上;如果说下标对应的位置有链表存在,就把k和链表上的每一个节点中的k调用equals方法进行对比;如果所有的equals方法返回false,那么这个新节点就将添加到链表的末尾;如果其中一个equals方法返回true,那么这个节点的value将会被覆盖!

(3)对于存储数据map.get(k)的原理

第一步:先调用k的hashCode()方法得到对应的hash值;然后通过哈希算法,将hash值转换成数组的下标,通过下标可以快速定位到某个位置

第二步:如果这个位置什么也没有,返回null;如果这个位置上有链表,那么就会拿着k和链表上的每一个节点中的k调用equals方法进行对比;如果所有的equals方法都返回false,那么就反回null;如果其中有一个节点的equals返回true,那么此时这个节点的value就是我们get方法所需要的返回值

(4)HashMap集合底层的源代码:

    public class HashMap{
            // HashMap底层实际上就是一个数组。(一维数组)
            Node<K,V>[] table;
            // 静态的内部类HashMap.Node
            static class Node<K,V> {
                final int hash; // 哈希值(哈希值是key的hashCode()方法的执行结果。
                               // hash值通过哈希函数/算法,可以转换存储成数组的下标。)
                final K key; // 存储到Map集合中的那个key
                V value; // 存储到Map集合中的那个value
                Node<K,V> next; // 下一个节点的内存地址。
            }
        }

(5)结论
重点:通过上面的讲解可以得出HashMap集合的key,会先后调用两个方法, 一个方法是hashCode(),一个方法是equals(),这两个方法都需要重写!
注意:同一个单向链表上所有节点的hash值相同,因为他们的数组下标是一样的;但同一个链表上k和k的equals方法肯定返回的是false,都不相同(无序不可重复)
(6)HashMap集合的key部分特点无序,不可重复(重复会覆盖)
为什么无序? 因为不一定挂到哪个单向链表上。
不可重复是怎么保证的? equals方法来保证HashMap集合的key不可重复。
如果key重复了,value会覆盖。
放在HashMap集合key部分的元素其实就是放到HashSet集合中了;所以HashSet集合中的元素也需要同时重写hashCode()+equals()方法。

(7)哈希表HashMap使用不当时无法发挥性能!(我们考虑两个极端情况)
第一种情况:假设将所有的hashCode()方法返回值固定为某个值,那么会导致底层哈希表变成了纯单向链表。这种情况我们成为:散列分布不均匀。
什么是散列分布均匀?
假设有100个元素,10个单向链表,那么每个单向链表上有10个节点,这是最好的,是散列分布均匀的。
第二种情况:假设将所有的hashCode()方法返回值都设定为不一样的值,可以吗?

不行,因为这样的话导致底层哈希表就成为一维数组了,没有链表的概念了,也是散列分布不均匀。所以要想散列分布均匀,需要重写hashCode()方法时有一定的技巧。

注意:hashCode()方法返回值都一样;实际上是一个单链表;

           hashCode()方法返回值都不一样;实际上就是一个数组
(8)重点放在HashMap集合key部分的元素,实际上就是放在HashSet集合中的元素,需要同时重写hashCode和equals方法。
(9)HashMap集合的默认初始化容量是16,默认加载因子是0.75;扩容:扩容后的容量是原容量的2倍;这个默认加载因子是当HashMap集合底层数组的容量达到75%的时候,数组开始扩容。
记住:HashMap集合初始化容量必须是2的倍数,这也是官方推荐的,这是因为达到散列均匀,为了提高HashMap集合的存取效率,所必须的。

package com.bjpowernode.javase.map;

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


public class HashMapTest01 {
    public static void main(String[] args) {
        // 测试HashMap 集合key部分的元素特点
        // Integer是key,它的hashCode和equals都重写了
        Map<Integer,String> map = new HashMap<>();
        map.put(111,"zhangsan");
        map.put(222,"lisi");
        map.put(333,"wangwu");
        map.put(333,"zhaoliu"); //key重复,value会覆盖上面的值
        // 元素个数
        System.out.println(map.size()); //3
        // 遍历
        Set<Map.Entry<Integer,String>> set = map.entrySet();
        for(Map.Entry<Integer,String> entry:set){
            System.out.println(entry.getKey()+"="+entry.getValue());
        }
        /*333=zhaoliu 
        222=lisi
        111=zhangsan
        验证结果:无序不可重复,key重复会覆盖掉原来的值!
        */
    }
}

🥅同时重写HashCode和equals

(1)向Map集合中存,以及从Map集合中取,都是先调用key的hashCode()方法然后再调用equals()方法equals方法有可能调用,也有可能不调用。 
①拿put(k,v)举例,什么时候equals不会调用?
k.hashCode()方法返回哈希值,哈希值经过哈希算法转换成数组下标;数组下标位置上如果是null,equals不需要执行。
拿get(k)举例,什么时候equals不会调用?
k.hashCode()方法返回哈希值,哈希值经过哈希算法转换成数组下标,数组下标位置上如果是null,equals不需要执行。

(2)重要结论:如果一个类的equals方法重写了,那么hashCode()方法必须重写;并且equals方法返回如果是true,hashCode()方法返回的值必须一样。
equals方法返回true表示两个对象相同,在同一个单向链表上比较;那么对于同一个单向链表上的节点来说,他们的哈希值都是相同的,所以hashCode()方法的返回值也应该相同。

(3)hashCode()方法和equals()方法可以直接使用IDEA工具生成,但是这两个方法需要同时生成。

(4)终极结论:放在HashMap集合key部分的,以及放在HashSet集合中的元素,需要同时重写hashCode方法和equals方法。

(5)对于哈希表数据结构来说:
如果o1和o2的hash值相同,一定是放到同一个单向链表上。
如果o1和o2的hash值不同,但由于哈希算法执行结束之后转换的数组下标可能相同,此时会发生“哈希碰撞”。

(6)JDK8对HashMap集合的改进:

如果哈希表单向链表中元素超过8个,单向链表这种数据结构会变成红黑树;当红黑树节点数量小于6时,会重新把红黑树变成单向链表;这种方式也是为了提高检索效率,二叉树的检索效率会再次缩小扫描范围,提高效率。

⭐学生类

package com.bjpowernode.javase.map;

import java.util.Objects;

public class Student {
    private String name;
    // 构造方法
    public Student() {
    }
    public Student(String name) {
        this.name = name;
    }

    // setter and getter
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    // 同时生成equals方法和hashCode方法
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return Objects.equals(name, student.name);
    }
    public int hashCode() {
        return Objects.hash(name);
    }
}

⭐测试 

package com.bjpowernode.javase.map;

import java.util.HashSet;
import java.util.Set;

public class HashMapTest02 {
    public static void main(String[] args) {
        Student s1 = new Student("张三");
        Student s2 = new Student("张三");

        // 重写equlas方法之前
        System.out.println(s1.equals(s2)); // false
        // 重写equals方法之后
        System.out.println(s1.equals(s2)); // true
        // 1163157884(重写hashCode之后:774920)
        System.out.println("s1的hashCode是:"+s1.hashCode());
        // 1956725890(重写hashCode之后:774920) 
        System.out.println("s2的hashCode是:"+s2.hashCode()); 
        System.out.println(s1.hashCode() == s2.hashCode()); // false

        // s1.equals(s2)结果已经是true了,表示s1和s2是一样的,相同的,
        // 那么往HashSet集合中放的话,按说只能放进去1个。
        // (HashSet集合特点:无序不可重复)
        Set<Student> students = new HashSet<>();
        students.add(s1);
        students.add(s2);
        // 按理说应该是1,无序不可重复!未重写hashCode方法
        System.out.println(students.size());  // 2
        // 重写hashCode以后结果就是1
        System.out.println(students.size()); // 1

    }
}

❤️HashMap的key可以为null(HashTable的key不能为null)

HashMap集合key部分允许null吗?
答:允许但是要注意HashMap集合的key null值只能有一个;多了会被后面的覆盖

package com.bjpowernode.javase.map;

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

public class HashMapTest03 {
    public static void main(String[] args) {
        Map map = new HashMap();
        // HashMap集合允许key为null
        map.put(null,null);
        System.out.println(map.size()); // 1

        // key重复的话value会被覆盖
        map.put(null,100);
        System.out.println(map.size()); // 还是1

        // 通过key获取value
        System.out.println(map.get(null)); // 100
    }
}

🥅HashMap和Hashtable的区别

(1)Hashtable的key可以为null吗?

HashMap集合的key和value都是可以为null的
Hashtable的key和value都是不能为null的。  

(2)Hashtable方法都带有synchronized:线程安全的。线程安全有其它的方案,Hashtable对线程的处理导致效率较低,使用较少了。Hashtable和HashMap一样,底层都是哈希表数据结构。

(3)容量

①HashMap集合的默认初始化容量是16,默认加载因子是0.75;扩容后的容量是原容量的2倍
②Hashtable集合的默认初始化容量是11,默认加载因子是:0.75,扩容后:原容量 * 2 + 1

(4)底层数据结构

①HashMap底层使用的是:数组+单向链表+红黑树结构进行存储(JDK8之后)!

②Hashtable底层使用的是:数组+单向链表!

package com.bjpowernode.javase.table;

import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;


public class HashtableTest01 {
    public static void main(String[] args) {
        //1、 HashMap集合的key和value都是可以为null的
        Map map1 = new HashMap();
        map1.put(null,null); // 编译和运行都没问题

        //2、 Hashtable的key和value都是不能为null的。
        Map map2 = new Hashtable();
        map2.put(null,"zhangsan"); // java.lang.NullPointerException
        map2.put(10,null); // java.lang.NullPointerException
    }
}

关于容量,扩容小总结:

Collection集合:

(1)ArrayList集合初始化容量是10;扩容到原容量的1.5倍
(2)Vector集合初始化容量是10;扩容到原容量的2倍
(3)HashSet集合初始化容量16,初始化容量建议是2的倍数;扩容:扩容之后是原容量2倍

Map集合:

(1)HashMap初始化容量16,默认加载因子0.75,扩容之后的容量是量的2倍
(2)Hashtable集合初始化容量11,默认加载因子0.75,扩容之后的容量是原容量*2 + 1

🥅Properties类

(1)Properties是一个Map集合,继承Hashtable,Properties的key和value都是String类型。
(2)Properties被称为属性类对象,因为Hashtable是线程安全的,所以Properties是线程安全的。

(3)两个重要方法

调用setProperties(key,value)方法存取数据。

调用getProperties(key)方法:通过key获取value。

package com.bjpowernode.javase;

import java.util.Properties;

public class PropertiesTest01 {
    public static void main(String[] args) {
        // 创建一个Properties对象
        Properties pro = new Properties();
        //  存setProperyies
        pro.setProperty("username","root");
        pro.setProperty("password","1234");
        pro.setProperty("driver","com.mysql.jdbc.Driver");
        // 通过key取value
        System.out.println(pro.getProperty("username")); //root
        System.out.println(pro.getProperty("password")); //1234
        System.out.println(pro.getProperty("driver")); //com.mysql.jdbc.Driver
    }
}

注:Properties常用来处理属性文件!

package com.zl.TreeSetTest;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;

public class PropertiesTest {
    public static void main(String[] args) throws IOException {
        File file = new File("info.properties");
        // 查看这个属性配置文件默认的位置(在工程的根目录下)
        System.out.println(file.getAbsoluteFile()); // C:\Users\86177\IdeaProjects\spring-data-redis\info.properties
        // 需要一个输入流
        FileInputStream fis = new FileInputStream(file);
        // 创建Properties集合
        Properties pro = new Properties();
        // 加载
        pro.load(fis);
        // 读取数据(根据key)
        System.out.println(pro.getProperty("name")); // zhangsan
        System.out.println(pro.getProperty("password")); // 123

    }
}

🥅TreeSet(TreeMap)集合

(1)TreeSet集合底层实际上是一个TreeMap;放到TreeSet集合中的元素,等同于放到TreeMap集合key部分了。
(2)TreeMap集合底层是一个红黑树(自平衡的排序二叉树)。
(3)TreeSet集合中的元素:无序不可重复,但是可以按照元素的大小顺序自动排序(可排序集合),所以也叫作可排序集合(自然排序和定制排序)

(4)TreeSet集合有什么用呢?我们拿一个很常见的需求来作为例子;数据库中有很多数据:

    userid  name         birth
    -------------------------------------
    1       zs          1980-11-11
    2       ls          1980-10-11
    3       ww          1981-11-11
    4       zl          1979-11-11

编写程序从数据库当中取出数据,在页面展示用户信息的时候按照生日升序或者降序。
这个时候可以使用TreeSet集合,因为TreeSet集合放进去,拿出来就是有顺序的。

package com.bjpowernode.javase.map;

import java.util.TreeSet;

public class TreeSetTest01 {
    public static void main(String[] args) {
        // 演示TreeSet对String是可排序的
        TreeSet<String> ts = new TreeSet<>();
        // 添加元素
        ts.add("zhangsan");
        ts.add("lisi");
        ts.add("wangwu");
        ts.add("wangliu");
        // 遍历---升序排
        for(String s :ts){
            System.out.println(s); //  lisi、wangliu、wangwu、zhangsan
        }

        TreeSet<Integer> ts2 = new TreeSet<>();
        ts2.add(300);
        ts2.add(600);
        ts2.add(100);
        ts2.add(10);
        ts2.add(200);
        for(Integer i :ts2){
            System.out.println(i); // 10、100、200、300、600
        }
    }
}

❤️TreeSet无法对自定义类型排序

(1)对自定义的类型来说(例如Person类),TreeSet不可以排序。
以下程序中对于Person类型来说,无法排序;因为没有指定Person对象之间的比较规则,谁大谁小并没有说明。

(2)以下程序运行的时候出现了这个异常: java.lang.ClassCastException
(3)出现这个异常的原因是:Person类没有实现java.lang.Comparable接口。

(4)所以对于自定义的类型,使用TreeSet集合,因为没有比较规则,所以是无法排序的;所以我们需要实现java.lang.Comparable接口并且重写compareTo方法,在compareTo方法里面进行比较规则的编写,才可以!

⭐没有实现Comparable接口,无法进行比较 

package com.bjpowernode.javase.map;

import java.util.TreeSet;

public class TreeSetTest02 {
    public static void main(String[] args) {
        // 创建对象
        Person p1 = new Person(32);
        Person p2 = new Person(20);
        Person p3 = new Person(30);
        // 创建集合
        TreeSet<Person> ts = new TreeSet<>();
        // 添加元素
        ts.add(p1);
        ts.add(p2);
        ts.add(p3);
        // 遍历打印
        for(Person p:ts){
            System.out.println(p);
        }

    }
}

//自定义Person类
class Person{
    int age;
    public Person(int age){
        this.age = age;
    }

    // 重写toString()方法
    public String toString(){
        return "Person[age="+age+"]";
    }

}

⭐实现Comparable接口,重写compareTo方法,编写比较的逻辑

package com.bjpowernode.javase.map;

import java.util.TreeSet;

public class TreeSetTest03 {
    public static void main(String[] args) {
        Customer c1 = new Customer(32);
        Customer c2 = new Customer(20);
        Customer c3 = new Customer(30);
        Customer c4 = new Customer(25);

        // 创建TreeSet集合
        TreeSet<Customer> customers = new TreeSet<>();
        // 添加元素
        customers.add(c1);
        customers.add(c2);
        customers.add(c3);
        customers.add(c4);

        // 遍历
        for (Customer c : customers){
            System.out.println(c);
        }
    }
}

// 放在TreeSet集合中的元素需要实现java.lang.Comparable接口。
// 并且实现compareTo方法。equals可以不写。
class Customer implements Comparable<Customer>{

    int age;
    public Customer(int age){
        this.age = age;
    }

    // 需要在这个方法中编写比较的逻辑,或者说比较的规则,按照什么进行比较!
    // k.compareTo(t.key)
    // 拿着参数k和集合中的每一个k进行比较,返回值可能是>0 <0 =0
    // 比较规则最终还是由程序员指定的:例如按照年龄升序。或者按照年龄降序。
    public int compareTo(Customer c) { // c1.compareTo(c2);
        // this是c1
        // c是c2
        // c1和c2比较的时候,就是this和c比较。
        /*int age1 = this.age;
        int age2 = c.age;
        if(age1 == age2){
            return 0;
        } else if(age1 > age2) {
            return 1;
        } else {
            return -1;
        }*/
        //return this.age - c.age; //升序
        return c.age - this.age; //降序
    }

    public String toString(){
        return "Customer[age="+age+"]";
    }
}

⭐比较规则怎么写

我们不妨编写一个:先按照年龄升序,如果年龄一样的再按照姓名升序。
compareTo方法的返回值很重要:
①返回0表示相同,value会覆盖。
②返回>0,会继续在右子树上找。
③返回<0,会继续在左子树上找。

我们也可以定义两个比较规则,当一种比较规则失效时,在使用另外一种规则;

这里需要注意的是对于字符串的比较equals只能说明相等不相等;compareTof方法才能比较到底谁大谁小。

package com.bjpowernode.javase.map;

import java.util.TreeSet;

//先按照年龄升序,如果年龄一样的再按照姓名升序。
public class TreeSetTest04 {
    public static void main(String[] args) {
        Vip v1 = new Vip("zhangsan",18);
        Vip v2 = new Vip("zhangzl",18);
        Vip v3 = new Vip("lisi",32);
        Vip v4 = new Vip("wangwu",20);
        Vip v5 = new Vip("zhaoliu",22);

        // 创建集合
        TreeSet<Vip> ts = new TreeSet<>();
        // 增加元素
        ts.add(v1);
        ts.add(v2);
        ts.add(v3);
        ts.add(v4);
        ts.add(v5);
        // 遍历打印
        for(Vip v :ts){
            System.out.println(v);
        }


    }
}


class Vip implements Comparable<Vip>{
    String name;
    int age;

    // 构造方法
    public Vip(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 重写toString方法
    public String toString() {
        return "Vip{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}'; //Vip{name='zhangsan', age=18}
    }

    // 重写Comparable接口中中的方法
    public int compareTo(Vip o) {
        if(this.age != o.age){
            return this.age - o.age;
        }else{
            // 年龄相同,按照名字排序
            // 名字是String类型,可以直接比,调用compareTo来比较
            return this.name.compareTo(o.name);
        }

    }
}
/*
运行结果:
    Vip{name='zhangsan', age=18}
    Vip{name='zhangzl', age=18}
    Vip{name='wangwu', age=20}
    Vip{name='zhaoliu', age=22}
    Vip{name='lisi', age=32}
*/

🥅自平衡二叉树数据结构

(1)TreeSet/TreeMap是自平衡二叉树遵循左小右大原则存放。

(2)遍历二叉树的时候有三种方式:
①前序遍历∶根左右
②中序遍历∶左根右

③后序遍历∶左右根
注意:前中后说的是“根”的位置,根在前面是前序、根在中间是中序、根在后面是后序

(3)TreeSet/TreeMap集合采用的是中序遍历方式即Iterator迭代器采用的是中序遍历方式

(4)我们就拿一组数据,写出它的二叉树结构,来体验一下中序遍历的方式,例如:100 200 50 60 80 120 140 130 135 180 666 40 55

JavaSE进阶 | Map集合、HashMap集合、TreeMap集合

(5)中序遍历方式取出:40 50 55 60 80 100 120 130 135 140 180 200 666,按照中序遍历的方式取出来的刚好是有序的。

🥅实现比较器接口

TreeSet集合中元素可排序的第二种方式:使用比较器的方式

(1)这种实现方式是根据源码码来定义的
如果我们使用无参的:调用的是Comparable接口里的compareTo方法;注意是自己定义的类型实现Comparable接口;这种方式不需要在构造方法new这个对象。

如果我们使用有参的:调用的是Comparator接口里的compare方法;注意是再另写一个比较类去实现Comparator接口;这种方式需要在构造方法中去new实现的比较类。
Comparable是java.lang包下的,Comparator是java.util包下的
(2)结论:放到TreeSet或者TreeMap集合key部分的元素要想做到排序,包括两种方式:
第一种:放在集合中的元素实现java.lang.Comparable接口。
第二种:在构造TreeSet或者TreeMap集合的时候给它传一个比较器Comparator对象。
(3)Comparable和Comparator怎么选择呢?
①当比较规则不会发生改变的时候,或者说当比较规则只有1个的时候,建议实现Comparable接口,重写compareTo方法
②如果比较规则有多个并且需要多个比较规则之间频繁切换,建议使用Comparator接口;重写compare方法,Comparator接口的设计符合OCP原则,。

package com.bjpowernode.javase.map;

import java.util.Comparator;
import java.util.TreeSet;

public class TreeSetTest05 {
    public static void main(String[] args) {
        Animals animals = new Animals(15);
        // 创建TreeSet集合的时候,需要使用这个比较器
        // TreeSet<Animals> animal = new TreeSet<>(); //原来这种方式就不行,没有使用比较器
        // TreeSet<Animals> animal = new TreeSet<>(new AnimalComparator()); //new一个比较器对象传过去

        // 这里也可以不写Comparator接口的实现,使用匿名内部类
        TreeSet<Animals> animal = new TreeSet<>(new Comparator<Animals>() {
            public int compare(Animals o1, Animals o2) {
                return o1.age - o2.age;
            }
        });

        animal.add(new Animals(100));
        animal.add(new Animals(80));
        animal.add(new Animals(81));

        // 循遍历
        for(Animals a:animal){
            System.out.println(a);
        }
    }
}

class Animals{
    int age;
    // 构造方法
    public Animals(int age) {
        this.age = age;
    }
    // 重写toString方法
    public String toString() {
        return "Animals{" +
                "age=" + age +
                '}'; // Animals{age=15}
    }
}

/*
// 单独在这里编写一个比较器
// 比较器实现java.util.Comparator接口。
class AnimalComparator implements Comparator<Animals> {

    public int compare(Animals o1, Animals o2) {
        // 指定比较规则;按照年龄排序
        return o1.age - o2.age;
    }
}*/

🥅集合工具类Collections

参考操作数组的工具类:Arrays,Collections 是一个操作 Set、List 和 Map 等集合的工具类。

(1)区分两个类:

java.util.Collection 集合接口
java.util.Collections 集合工具类,方便集合的操作。

(2)通过Collections集合里的方法变成线程安全的;Collections.synchronizedList(集合)

(3)对于SortedSet集合是可排序集合,但是对于HashSet集合排序,可以先把HashSet集合通过new ArrayList<>(set);转换成List集合,然后就可以使用Collections.sort(); 进行排序,因为使用这个sort方法排序只能是List集合才可以!

(4)对于自定义的类型如何排序呢?

可以把比较器作为参数传进去,例如:Collections.sort(list集合,new Comparator比较器)

package com.bjpowernode.javase;

import java.util.*;

public class CollectionsTest {
    public static void main(String[] args) {
        // 1、 ArrayList集合不线程安全的
        List<String> list = new ArrayList<>();
        // 通过Collections集合里的方法变成线程安全的
        Collections.synchronizedList(list);

        //排序
        list.add("abf");
        list.add("abx");
        list.add("abc");
        list.add("abe");
        Collections.sort(list); //排序
        // 打印
        for(String s:list){
            System.out.println(s); // abc abe abf abx
        }

        // 2、如果排序自己写的类,需要自己实现compareTo接口
        List<WuGui2> wuGui2s = new ArrayList<>();
        wuGui2s.add(new WuGui2(1000));
        wuGui2s.add(new WuGui2(800));
        // 注意:对List集合中元素排序,需要保证List集合中的元素实现了:Comparable接口。
        Collections.sort(wuGui2s);
        for(WuGui2 w : wuGui2s){
            System.out.println(w);
        }

        // 3、对Set集合怎么排序呢?
        Set<String> set = new HashSet<>();
        set.add("king");
        set.add("kingsoft");
        set.add("king2");
        set.add("king1");
        //Collections.sort(); //里面只能是List集合
        // 所以需要把Set集合转换成List集合
        List<String> mylist = new ArrayList<>(set);// 把set集合转过来
        Collections.sort(mylist); //这样就能排序了
        for(String s:mylist){
            System.out.println(s); // king king1 king2 kingsoft
        }

        // 自定义类型也可以排序,多传一个我们上面讲过的比较器参数。
        //Collections.sort(list集合, 比较器对象);

    }
}

class WuGui2 implements Comparable<WuGui2>{
    int age;
    public WuGui2(int age){
        this.age = age;
    }

    public int compareTo(WuGui2 o) {
        return this.age - o.age;
    }

    public String toString() {
        return "WuGui2{" +
                "age=" + age +
                '}';
    }
}

​常用方法

Collections 中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作,还提供了对集合对象设置不可变、对集合对象实现同步控制等方法(均为static方法)!

排序操作

- reverse(List):反转 List 中元素的顺序
- shuffle(List):对 List 集合元素进行随机排序
- sort(List):根据元素的自然顺序对指定 List 集合元素按升序排序
- sort(List,Comparator):根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
- swap(List,int, int):将指定 list 集合中的 i 处元素和 j 处元素进行交换
package com.zl.TreeSetTest;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class CollectionsTest {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 3, 7, 5, 4, 2, 15, 12);

        // reverse翻转
        Collections.reverse(list);
        System.out.println(list); // [12, 15, 2, 4, 5, 7, 3, 1]

        // 随机排序(相当于洗牌,每次都是随机排序)
        Collections.shuffle(list);
        System.out.println(list); // [1, 15, 12, 5, 3, 2, 7, 4]

        // 进行排序(自然排序)
        Collections.sort(list);
        System.out.println(list); // [1, 2, 3, 4, 5, 7, 12, 15]

        // 指定排序(逆序)
        Collections.sort(list,(o1,o2)->{
            if (o1 instanceof Integer && o2 instanceof Integer){
                return -(o1.intValue() - o2.intValue()); // 逆序排加一个负号-
            }
            throw new RuntimeException("类型不匹配");
        });
        System.out.println(list); // [15, 12, 7, 5, 4, 3, 2, 1]

        // 交换(指定下标位置进行交换)
        Collections.swap(list,0,list.size()-1);
        System.out.println(list); // [1, 12, 7, 5, 4, 3, 2, 15]
    }
}

查找

- Object max(Collection):根据元素的自然顺序,返回给定集合中的最大元素(最右边的数)
- Object max(Collection,Comparator):根据 Comparator 指定的顺序,返回给定集合中的最大元素(还是最右边的数,如果此时是按照降序排列的,实际上最右边取的就是最小的数了)
- Object min(Collection):根据元素的自然顺序,返回给定集合中的最小元素(最左边的数)
- Object min(Collection,Comparator):根据 Comparator 指定的顺序,返回给定集合中的最小元素
- int binarySearch(List list,T key)在List集合中查找某个元素的下标,但是List的元素必须是T或T的子类对象,而且必须是可比较大小的,即支持自然排序的。而且集合也事先必须是有序的,否则结果不确定。
- int binarySearch(List list,T key,Comparator c)在List集合中查找某个元素的下标,但是List的元素必须是T或T的子类对象,而且集合也事先必须是按照c比较器规则进行排序过的,否则结果不确定。
- int frequency(Collection c,Object o):返回指定集合中指定元素的出现次数
package com.zl.TreeSetTest;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class CollectionsTest {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 3, 7, 5, 4, 2, 15, 12);
        // 获取最大值
        Integer max = Collections.max(list);
        System.out.println(max); // 15
        // 获取最小值
        Integer min = Collections.min(list);
        System.out.println(min); // 1
        // 二分查找(必须提前有序)
        Collections.sort(list); // 排序
        System.out.println(list); // [1, 2, 3, 4, 5, 7, 12, 15]
        int flag = Collections.binarySearch(list, 5);// 二分查找
        System.out.println(flag); // 4
        // 某个元素在集合中出现的次数
        int frequency = Collections.frequency(list, 1);
        System.out.println(frequency); // 1

    }
}

复制、替换

- void copy(List dest,List src):将src中的内容复制到dest中
- boolean replaceAll(List list,Object oldVal,Object newVal):使用新值替换 List 对象的所有旧值
- 提供了多个unmodifiableXxx()方法,该方法返回指定 Xxx的不可修改的视图。
package com.zl.TreeSetTest;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class CollectionsTest {
    public static void main(String[] args) {
        List<Integer> src = Arrays.asList(1, 3, 7, 5, 4, 2, 15, 12);
        // 直接拷贝会出现问题
        // 此时拷贝会出现异常,通过底层源码发现,会srcSize > dest.size()进行比较
        // 而dest.size()目前没有元素肯定就是0,所以会抛出 Source does not fit in dest异常
        /*ArrayList<Integer> dest = new ArrayList<>();
        Collections.copy(dest,src);*/
        // 正确的做法
        List dest = Arrays.asList(new Object[src.size()]); // 相当于里面放了很多null
        Collections.copy(dest,src); // 拷贝的时候会覆盖原来的值
        System.out.println(dest); // [1, 3, 7, 5, 4, 2, 15, 12]

        // 替换(也相当于修改)
        Collections.replaceAll(src,3,6);
        System.out.println(src); // [1, 6, 7, 5, 4, 2, 15, 12]

        // 把src变成只读
        List<Integer> unmodifiableList = Collections.unmodifiableList(src);
        unmodifiableList.set(1,666); // UnsupportedOperationException不支持的操作异常,不能在修改

    }
}

添加

boolean addAll(Collection  c,T... elements)将所有指定元素添加到指定 collection 中。
package com.zl.TreeSetTest;

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

public class CollectionsTest {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        Collections.addAll(list,666,888,999); // 是一个可变长度的参数
        System.out.println(list); // [666, 888, 999]
    }
}

同步

Collections 类中提供了多个 synchronizedXxx() 方法,该方法可使将指定集合包装成线程同步的集合,从而可以解决多线程并发访问集合时的线程安全问题:

JavaSE进阶 | Map集合、HashMap集合、TreeMap集合

 文章来源地址https://www.toymoban.com/news/detail-405561.html

例题实战:模拟斗地主洗牌和发牌,牌没有排序

package com.zl.TreeSetTest;

import java.util.ArrayList;
import java.util.Collections;

/**
 * Author:朗朗乾坤
 * Package:com.zl.TreeSetTest
 * Project:spring-data-redis
 *
 * @Date:2023/4/15 16:51
 */
public class CollectionsTest {
    public static void main(String[] args) {
        // 准备两个字符数组
        String[] num = {"A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"};
        String[] color = {"方片", "梅花", "红桃", "黑桃"};
        ArrayList<String> poker = new ArrayList<>();
        // 嵌套遍历,生成24张排放入poker集合当中
        for (int i = 0; i < color.length; i++) {
            for (int j = 0; j < num.length; j++) {
                poker.add(color[i] + num[j]);
            }
        }
        // 添加大小王
        poker.add("大王");
        poker.add("小王");
        // 洗牌
        Collections.shuffle(poker);
        //发牌
        ArrayList tomCards = new ArrayList();
        ArrayList jerryCards = new ArrayList();
        ArrayList meCards = new ArrayList();
        ArrayList lastCards = new ArrayList();
        for (int i = 0; i < poker.size(); i++) {
            if (i >= poker.size() - 3) {
                lastCards.add(poker.get(i));
            } else if (i % 3 == 0) {
                tomCards.add(poker.get(i));
            } else if (i % 3 == 1) {
                jerryCards.add(poker.get(i));
            } else {
                meCards.add(poker.get(i));
            }
        }
        //看牌
        System.out.println("Tom:\n" + tomCards);
        System.out.println("Jerry:\n" + jerryCards);
        System.out.println("me:\n" + meCards);
        System.out.println("底牌:\n" + lastCards);

    }
}

执行结果:

JavaSE进阶 | Map集合、HashMap集合、TreeMap集合

 

到了这里,关于JavaSE进阶 | Map集合、HashMap集合、TreeMap集合的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Java----Hashmap,LinkedMap和TreeMap三者的区别

            其中map表示的意思为“映射”,HashMap,LinkedMap和TreeMap这三中类都是对Map接口的实现类,在数据插入方面,HashMap是无序插入,LinkedMap是有序插入,而TreeMap会根据键的值进行排序后再进行插入。在运行方面,前两个的运行速度较快,针对Map对象的存储会选择前两者,

    2024年02月13日
    浏览(43)
  • 进阶JAVA篇- Map 系列集合的遍历方法与常用API

    目录         1.0 Map 集合的说明         1.1 Map 集合的常用方法         1.2 Map 系列集合的特点         2.0 Map 系列集合的遍历方法(三种方法)          2.1 使用 keySet() 方法遍历         2.2 使用 entrySet() 方法遍历         2.3 使用 forEach() 方法遍历(Java 8+)  

    2024年02月08日
    浏览(48)
  • 从零开始学习 Java:简单易懂的入门指南之HashMap及TreeMap源码解读(二十四)

    Tip: 1.TreeMap添加元素的时候,键是否需要重写hashCode和equals方法? 此时是不需要重写的。 2.HashMap是哈希表结构的,JDK8开始由数组,链表,红黑树组成的。既然有红黑树,HashMap的键是否需要实现Compareable接口或者传递比较器对象呢? 不需要的。 因为在HashMap的底层,默认是利用

    2024年02月07日
    浏览(45)
  • 如何遍历HashMap集合?

    在Java中,HashMap是一种常用的数据结构,它提供了快速的查找、插入和删除操作。当我们需要遍历HashMap中的所有元素时,可以利用三种不同的方法实现。 HashMap中存储的是键值对的形式,因此最简单的方法就是直接遍历键值对。我们可以通过以下代码实现: 上述代码中,我们

    2023年04月23日
    浏览(40)
  • Java集合之一——HashMap(辨析)

    看到一篇讲hashmap的文章,讲的很不错,但是有一点我觉得作者没有讲清楚,这里我说一下自己的理解。 原文,先看原文: https://blog.csdn.net/woshimaxiao1/article/details/83661464 前文概述,该博客的主要内容如下: 1. 什么是哈希表(主干为数组)、什么是哈希冲突、如何解决哈希冲突

    2024年02月15日
    浏览(44)
  • HashMap集合万字源码详解(面试常考)

    散列,又称哈希(Hash),是一种数据处理方式。它通过特定的算法,将输入(比如字符串、文件等)转换成固定长度的一串(通常是数字),并且这个过程是不可逆的。这个过程中的算法就称为哈希函数,得到的结果就称为哈希值。 散列的主要作用是为了检索数据。通过散

    2024年02月02日
    浏览(40)
  • JavaSE(集合框架)

    Java 集合框架 Java Collection Framework ,又被称为容器 container ,是定义在 java.util 包下的一组接口 interfaces 和其实现类 classes 。其主要表现为将多个元素 element 置于一个单元中,用于对这些元素进行快速、便捷的存储、检索 、管理 。 Collection:是一个接口,包含了大部分容器常用

    2024年04月25日
    浏览(30)
  • 【Java-14】3万字深入理解HashMap集合(高级)

    ​ HashMap基于哈希表的Map接口实现,是以key-value存储形式存在,即主要用来存放键值对。HashMap 的实现不是同步的,这意味着它不是线程安全的。它的key、value都可以为null。此外,HashMap中的映射不是有序的。 ​ JDK1.8 之前 HashMap 由 数组+链表 组成的,数组是 HashMap 的主体,链

    2024年02月11日
    浏览(40)
  • Java 大厂面试 —— 常见集合篇 List HashMap 红黑树

    23Java面试专题 八股文面试全套真题(含大厂高频面试真题)多线程_软工菜鸡的博客-CSDN博客 02-算法复杂度分析 2.1 数组 2.1.1 数组概述 数组(Array)是一种用 连续的内存空间 存储 相同数据类型 数据的线性数据结构。 我们定义了这么一个数组之后,在内存的表示是这样的:

    2024年02月11日
    浏览(55)
  • 【数据类型】Collections.synchronizedMap 多线程Map,与HashMap的不同

    Collections.synchronizedMap 是 Java 中提供的工具方法,用于创建一个同步(线程安全)的 Map。 它接受一个现有的 Map 对象,并返回一个通过同步包装后的 Map 。 下面是一个简单的示例: 1、基础原理 Collections.synchronizedMap 是通过返回一个线程安全的 Map 包装器来实现的,它在对 Map

    2024年01月18日
    浏览(32)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包