数据结构之Set和Map

1、HashSet:

java 复制代码
package com.datastructure.set;

import java.util.HashSet;
//不允许重复元素
public class HashSetDemo {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();

        // 添加元素
        set.add("apple");
        set.add("banana");
        set.add("orange");
        set.add("mango");
        set.add("mango");
        System.out.println("HashSet: " + set); // 输出: HashSet: [apple, banana, orange, mango]

        // 检查元素是否存在
        boolean containsApple = set.contains("apple");
        System.out.println("Contains 'apple': " + containsApple); // 输出: Contains 'apple': true

        // 删除元素
        set.remove("banana");
        System.out.println("HashSet: " + set); // 输出: HashSet: [apple, orange, mango]

        // 获取元素数量
        int size = set.size();
        System.out.println("Size of HashSet: " + size); // 输出: Size of HashSet: 3

        // 清空集合
        set.clear();
        System.out.println("HashSet: " + set); // 输出: HashSet: []
    }
}

2、TreeSet:

java 复制代码
package com.datastructure.set;
import java.util.TreeSet;
//TreeSet是有序的,输出结果会按照升序排列。
//TreeSet还提供了一些便捷的方法来获取小于等于、严格小于、大于等于、严格大于给定元素的最值元素,
//分别是floor(), lower(), ceiling()和higher()方法。
//使用TreeSet,可以方便地存储一组有序的不重复元素,并且可以高效地执行判断、添加、删除等操作。
public class TreeSetDemo {
    public static void main(String[] args) {
        TreeSet<Integer> set = new TreeSet<>();

        // 添加元素
        set.add(5);
        set.add(2);
        set.add(8);
        set.add(3);
        System.out.println("TreeSet: " + set); // 输出: TreeSet: [2, 3, 5, 8]

        // 检查元素是否存在
        boolean contains5 = set.contains(5);
        System.out.println("Contains 5: " + contains5); // 输出: Contains 5: true

        // 删除元素
        set.remove(8);
        System.out.println("TreeSet: " + set); // 输出: TreeSet: [2, 3, 5]

        // 获取第一个和最后一个元素
        int first = set.first();
        int last = set.last();
        System.out.println("First element: " + first); // 输出: First element: 2
        System.out.println("Last element: " + last); // 输出: Last element: 5

        // 获取小于等于给定元素的最大元素
        int floor = set.floor(4);
        System.out.println("Floor of 4: " + floor); // 输出: Floor of 4: 3

        // 获取严格小于给定元素的最大元素
        int lower = set.lower(4);
        System.out.println("Lower of 4: " + lower); // 输出: Lower of 4: 3

        // 获取大于等于给定元素的最小元素
        int ceiling = set.ceiling(4);
        System.out.println("Ceiling of 4: " + ceiling); // 输出: Ceiling of 4: 5

        // 获取严格大于给定元素的最小元素
        int higher = set.higher(4);
        System.out.println("Higher of 4: " + higher); // 输出: Higher of 4: 5

        // 清空集合
        set.clear();
        System.out.println("TreeSet: " + set); // 输出: TreeSet: []
    }
}

3、HashMap:

java 复制代码
package com.datastructure.map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
//HashMap可以存储不重复的键和对应的值,并且可以根据键来获取对应的值。
//首先创建一个HashMap对象,并使用put()方法来添加键值对。键的类型通常是String,值可以是任意类型。
//使用get()方法根据键来获取对应的值,使用containsKey()方法来检查键是否存在,使用remove()方法来删除键值对。
//还可以使用entrySet()方法来获取键值对的Set视图,然后通过遍历Set视图的方式来遍历HashMap。
//在遍历过程中,可以使用getKey()和getValue()方法分别获取键和值。
//HashMap并不保证键值对的顺序,如果需要有序的存储和访问,可以考虑使用LinkedHashMap。
public class HashMapDemo {
    public static void main(String[] args) {
        // 创建HashMap对象
        HashMap<String, Integer> map = new HashMap<>();

        // 添加键值对
        map.put("apple", 5);
        map.put("banana", 2);
        map.put("orange", 3);

        // 获取值
        int appleCount = map.get("apple");
        System.out.println("Apple count: " + appleCount); // 输出: Apple count: 5
        
        // 检查键是否存在
        boolean containsBanana = map.containsKey("banana");
        System.out.println("Contains banana: " + containsBanana); // 输出: Contains banana: true
        
        // 删除键值对
        map.remove("orange");
        System.out.println("HashMap: " + map); // 输出: HashMap: {apple=5, banana=2}
        
        // 遍历HashMap
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            String key = entry.getKey();
            int value = entry.getValue();
            System.out.println(key + ": " + value);
        }
        /*
        输出:
        apple: 5
        banana: 2
        */
        // 使用迭代器,遍历linkedHashMap,并打印键值对
        Iterator<Entry<String, Integer>> iterator = map.entrySet().iterator();
        while (iterator.hasNext()) {
            Entry<String, Integer> entry = iterator.next();
            System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
        } 
        // 清空HashMap
        map.clear();
        System.out.println("HashMap: " + map); // 输出: HashMap: {}
    }
}

4、TreeMap:

java 复制代码
package com.datastructure.map;
import java.util.TreeMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
//TreeMap是实现了SortedMap接口的集合,它基于红黑树的数据结构来存储数据.
//并且可以根据键的自然顺序或自定义顺序进行排序。
//首先创建一个TreeMap对象,并使用put()方法来添加键值对。
//与HashMap不同的是,TreeMap会根据键的自然顺序进行排序,如果键是自定义类型,则需要实现Comparable接口或提供Comparator对象来指定排序规则。
//然后,使用get()方法根据键来获取对应的值,使用containsKey()方法来检查键是否存在,使用remove()方法来删除键值对。
//还可以使用entrySet()方法来获取键值对的Set视图,然后通过遍历Set视图的方式来遍历TreeMap。最后,使用clear()方法来清空TreeMap。
//TreeMap是一种有序的集合,它通过红黑树结构来存储数据,可以快速地插入、删除和查找元素,同时还可以根据键的顺序进行排序。
//由于红黑树结构的存在,TreeMap的插入、删除和查找操作的时间复杂度是O(logN),相对于HashMap的O(1)会稍微慢一些。
public class TreeMapDemo {
    public static void main(String[] args) {
        // 创建TreeMap对象
        TreeMap<String, Integer> map = new TreeMap<>();

        // 添加键值对
        map.put("apple", 5);
        map.put("banana", 2);
        map.put("orange", 3);

        // 获取值
        int appleCount = map.get("apple");
        System.out.println("Apple count: " + appleCount); // 输出: Apple count: 5
        
        // 检查键是否存在
        boolean containsBanana = map.containsKey("banana");
        System.out.println("Contains banana: " + containsBanana); // 输出: Contains banana: true
        
        // 删除键值对
        map.remove("orange");
        System.out.println("TreeMap: " + map); // 输出: TreeMap: {apple=5, banana=2}
        
        // 遍历TreeMap
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            String key = entry.getKey();
            int value = entry.getValue();
            System.out.println(key + ": " + value);
        }
        /*
        输出:
        apple: 5
        banana: 2
        */
     // 使用迭代器,遍历TreeMap,并打印键值对
        Iterator<Entry<String, Integer>> iterator = map.entrySet().iterator();
        while (iterator.hasNext()) {
            Entry<String, Integer> entry = iterator.next();
            System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
        } 
        // 清空TreeMap
        map.clear();
        System.out.println("TreeMap: " + map); // 输出: TreeMap: {}
    }
}

5、LinkedHashMap:

java 复制代码
package com.datastructure.map;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
//LinkedHashMap会保持插入顺序,因此输出结果的顺序与添加键值对的顺序一致。
public class LinkedHashMapExample {
    public static void main(String[] args) {
        // 创建一个LinkedHashMap实例
        LinkedHashMap<Integer, String> linkedHashMap = new LinkedHashMap<>();

        // 向linkedHashMap中添加键值对
  
        linkedHashMap.put(1, "One");
        linkedHashMap.put(2, "Two");
        linkedHashMap.put(3, "Three");
        linkedHashMap.put(4, "Four");
        linkedHashMap.put(5, "Five");

        // 遍历linkedHashMap,并打印键值对
        for (Map.Entry<Integer, String> entry : linkedHashMap.entrySet()) {
            System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
        }
        // 使用迭代器,遍历linkedHashMap,并打印键值对
        Iterator<Map.Entry<Integer, String>> iterator = linkedHashMap.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<Integer, String> entry = iterator.next();
            System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
        } 
    }
}
相关推荐
又是忙碌的一天4 小时前
前端学习 JavaScript
前端·javascript·学习
_给我学起来4 小时前
数据结构:树
数据结构
一條狗5 小时前
学习日报 20251007|深度解析:基于 Guava LoadingCache 的优惠券模板缓存设计与实现
java·oracle·loadingcache
Jagger_5 小时前
Cursor + Apifox MCP:告别手动复制接口,AI 助你高效完成接口文档开发
前端
Miraitowa_cheems5 小时前
LeetCode算法日记 - Day 64: 岛屿的最大面积、被围绕的区域
java·算法·leetcode·决策树·职场和发展·深度优先·推荐算法
IT_陈寒5 小时前
Redis性能优化:5个被低估的配置项让你的QPS提升50%
前端·人工智能·后端
Hilaku5 小时前
重新思考CSS Reset:normalize.css vs reset.css vs remedy.css,在2025年该如何选?
前端·css·代码规范
Lisonseekpan5 小时前
Spring Boot 中使用 Caffeine 缓存详解与案例
java·spring boot·后端·spring·缓存
为java加瓦5 小时前
Rust 的类型自动解引用:隐藏在人体工学设计中的魔法
java·服务器·rust
SimonKing5 小时前
分布式日志排查太头疼?TLog 让你一眼看穿请求链路!
java·后端·程序员