Java基础-集合框架-Map-TreeMap API及常用方法

最新推荐文章于 2024-10-26 17:20:19 发布
最新推荐文章于 2024-10-26 17:20:19 发布
阅读量1.2k 收藏 2
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jikui0581/article/details/102943478
版权

TreeMap

TreeMap API

Modifier and TypeMethod and Description
Map.Entry<K,V>ceilingEntry(K key)
返回大于等于key的最小值的元素，如果没有，则返回null
KceilingKey(K key)
返回大于等于key的最小值的元素的key，如果没有，则返回null
voidclear()
清除treeMapp中的所有元素。
Objectclone()
返回此TreeMap实例的浅拷贝。
Comparator<? super K>comparator()
返回此treeMap的比较器
booleancontainsKey(Object key)
如果此treeMap包含指定key，则返回 true 。
booleancontainsValue(Object value)
如果此treeMap包含指定value，则返回 true 。
NavigableSetdescendingKeySet()
返回此treeMap中包含的键的相反顺序NavigableSet 。
NavigableMap<K,V>descendingMap()
返回此treeMap中的反向排序视图。
Set<Map.Entry<K,V>>entrySet()
返回此treeMap的Set视图。
Map.Entry<K,V>firstEntry()
返回treeMap中的第一个元素，如果treeMap为空，则返回 null 。
KfirstKey()
返回treeMap中的第一个元素的key。
Map.Entry<K,V>floorEntry(K key)
返回key小于等于参数key的元素,不存在时返回null。
KfloorKey(K key)
返回key小于等于参数key的元素的key,不存在时返回null 。
voidforEach(BiConsumer<? super K,? super V> action)
遍历treeMap。
Vget(Object key)
返根据key返回value。
SortedMap<K,V>headMap(K toKey)
返回key小于toKey的所有元素。
NavigableMap<K,V>headMap(K toKey, boolean inclusive)
返回key小于toKey的所有元素,inclusive = true时包含等于的元素,inclusive=true时包含等于。
Map.Entry<K,V>higherEntry(K key)
返回最近接近参数key的元素(大于参数key)。
KhigherKey(K key)
返返回最近接近参数key的元素的key(大于参数key)。
SetkeySet()
遍历此treeMap的key。
Map.Entry<K,V>lastEntry()
返回treeMap中的最后一个元素
KlastKey()
返回treeMap中的最后一个元素的key。
Map.Entry<K,V>lowerEntry(K key)
返回小于指定key的最大的元素
KlowerKey(K key)
返回小于指定key的最大的元素的key。
NavigableSetnavigableKeySet()
返回此地图中包含的键的NavigableSet视图。
Map.Entry<K,V>pollFirstEntry()
删除并返回与该treeMap的第一个元素，如果treeMap为空，则返回 null 。
Map.Entry<K,V>pollLastEntry()
删除并返回与该treeMap的最后一个元素，如果treeMap为空，则返回 null 。
Vput(K key, V value)
新增一个元素。
voidputAll(Map<? extends K,? extends V> map)
将指定treeMap中的所有元素添加到此treeMap中。
Vremove(Object key)
从此TreeMap中删除此键的映射（如果存在）。
Vreplace(K key, V value)
只有当目标映射到某个值时，才能替换指定键的条目。
booleanreplace(K key, V oldValue, V newValue)
仅当当前映射到指定的值时，才能替换指定键的条目。
voidreplaceAll(BiFunction<? super K,? super V,? extends V> function)
将每个条目的值替换为对该条目调用给定函数的结果，直到所有条目都被处理或该函数抛出异常。
intsize()
返回此TreeMap中键值映射的数量。
NavigableMap<K,V>subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive)
返回此TreeMap部分的视图，其关键范围为 fromKey至 toKey 。
SortedMap<K,V>subMap(K fromKey, K toKey)
返回此TreeMap部分的视图，其关键字范围从 fromKey （含）到 toKey ，独占。
SortedMap<K,V>tailMap(K fromKey)
返回此TreeMap部分的视图，其键大于等于 fromKey 。
NavigableMap<K,V>tailMap(K fromKey, boolean inclusive)
返回此TreeMap部分的视图，其键大于（或等于，如果 inclusive为真） fromKey 。
Collectionvalues()
返回此TreeMap中所有value的Collection视图。

Sample Code

import java.util.Map.Entry;
import java.util.NavigableMap;
import java.util.TreeMap;

public class TreeMapDemo {

	private static TreeMap<String, String> treeMap = new TreeMap<String, String>();

	static {
		treeMap.put("1", "one");
		treeMap.put("2", "two");
		treeMap.put("3", "three");
		treeMap.put("4", "four");
		treeMap.put("5", "five");
	}

	public static void main(String[] args) {
		values();
	}

	/**
	 * @Function: ceilingEntry
	 * @Description: 返回大于等于key的最小值的元素，如果没有，则返回null.
	 *	
	 * @param treeMap
	 * @param key
	 * @return
	 */
	public static void ceilingEntry() {
		Entry<String, String> result = treeMap.ceilingEntry("3.9");
		// 4=four
		System.out.println(result);
	}

	/**
	 * @Function: ceilingKey
	 * @Description: 返回大于等于key的最小值的元素的key，如果没有，则返回null
	 *
	 * @param treeMap
	 */
	public static void ceilingKey() {
		// 4
		System.out.println(treeMap.ceilingKey("3.9"));
	}

	/**
	 * @Function: clone
	 * @Description: 浅克隆参数对象
	 * 
	 * 	浅克隆:会拷贝基本类型的值,若对象内含有引用类型,不会复制一个引用类型,而是复制其句柄.
	 *
	 * @param treeMap
	 */
	public Object clone() {
		return treeMap.clone();
	}

	/**
	 * @Function: comparator
	 * @Description: 用于其内元素排序,慎用
	 *
	 * @param treeMap
	 */
	public static void comparator() {
		treeMap.comparator();
	}


	/**
	 * @Function: compute
	 * @Description: 根据key和函数表达式设置新的value,并返回新的value.当新的value为null时,删除对应的key
	 *
	 */
	public static void compute() {
		String newValue = treeMap.compute("1", (key, value) -> "new 1");
		// new 1
		System.out.println(newValue);
		// 为null删除key为5的映射
		treeMap.compute("5", (key, value) -> null);
		/*
		 * 1:new 1
		 * 2:two
		 * 3:three
		 * 4:four
		 */
		treeMap.forEach(
				(key,value) -> {
					System.out.println(key +":"+ value);
				}
				);
	}

	/**
	 * @Function: computeIfAbsent
	 * @Description: 根据key和函数表达式设置新的value,并返回新的value.当新的value为null时,不进行任何操作
	 *
	 * @param treeMap
	 */
	public static void computeIfAbsent() {
		// key = 1 的映射存在,不操作
		String newValue = treeMap.computeIfAbsent("1", key -> "new 1");
		// one
		System.out.println(newValue);
		// value 为 null 不进行操作
		treeMap.computeIfAbsent("2", key -> null);
		/*
		 * 1:one
		 * 2:two
		 * 3:three
		 * 4:four
		 * 5:five
		 */
		treeMap.forEach(
				(key,value) -> {
					System.out.println(key +":"+ value);
				}
				);
	}

	/**
	 * @Function: computeIfPresent
	 * @Description: key存在且相关联的 value不为 null时,函数根据 key对应的value计算出newValue,使用newValue替换旧值.
	 *
	 * @param treeMap
	 */
	public static void computeIfPresent() {
		treeMap.computeIfPresent(
				"1", (key, value) -> "new" + value
				);
		// value = null 删除映射
		treeMap.computeIfPresent(
				"2", (key, value) -> null
				);
		// key不存在时,不进行操作
		treeMap.computeIfPresent(
				"6", (key, value) -> "new" + value
				);
		/*
		 * 1:newone
		 * 3:three
		 * 4:four
		 * 5:five
		 */
		treeMap.forEach(
				(key,value) -> {
					System.out.println(key +":"+ value);
				}
				);
	}

	/**
	 * @Function: descendingKeySet
	 * @Description: 倒序遍历所有key
	 *
	 * @param treeMap
	 */
	public static void descendingKeySet() {
		/*
		 * 5
		 * 4
		 * 3
		 * 2
		 * 1
		 */
		for(String key : treeMap.descendingKeySet()) {
			System.out.println(key);
		}
	}

	/**
	 * @Function: descendingMap
	 * @Description: 倒序返回TreeMap的所有元素
	 *
	 * @param treeMap
	 */
	@SuppressWarnings("rawtypes")
	public static void descendingMap() {
		NavigableMap nmap = treeMap.descendingMap();
		// Navigable map values: {5=five, 4=four, 3=three, 2=two, 1=one}
		System.out.println("Navigable map values: "+nmap);
	}

	/**
	 * @Function: entrySet
	 * @Description: 遍历TreeMap
	 *
	 * @param treeMap
	 */
	public static void entrySet() {
		/*
		 * 1=one
		 * 2=two
		 * 3=three
		 * 4=four
		 * 5=five
		 */
		for(Entry<String, String> map : treeMap.entrySet()) {
			System.out.println(map);
		}
	}

	/**
	 * @Function: firstEntry
	 * @Description: 返回第一个元素
	 *
	 * @param treeMap
	 * @return
	 */
	public static void firstEntry() {
		// 1=one
		System.out.println(treeMap.firstEntry());
	}

	/**
	 * @Function: firstKey
	 * @Description: 返回第一个key
	 *
	 * @param treeMap
	 * @return
	 */
	public static void firstKey() {
		// 1
		System.out.println(treeMap.firstKey());
	}

	/**
	 * @Function: floorEntry
	 * @Description: 返回key小于等于参数key的元素,不存在时返回null
	 *
	 * @param treeMap
	 * @param key
	 * @return
	 */
	public static void floorEntry() {
		// 1=one
		System.out.println(treeMap.floorEntry("1.9"));
		// null
		System.out.println(treeMap.floorEntry("0.9"));
	}

	/**
	 * @Function: floorKey
	 * @Description: 返回key小于等于参数key的元素的key,不存在时返回null
	 *
	 * @param treeMap
	 * @param key
	 */
	public static void floorKey() {
		// 1
		System.out.println(treeMap.floorKey("1.9"));
		// null
		System.out.println(treeMap.floorKey("0.9"));
	}

	/**
	 * @Function: forEach
	 * @Description: 遍历treeMap中的所有的元素
	 *
	 * @param treeMap
	 */
	public static void forEach() {
		/*
		 * 1one
		 * 2two
		 * 3three
		 * 4four
		 * 5five
		 */
		treeMap.forEach(
				(key, value) -> {
					System.out.println(key + value);
				}
				);
	}

	/**
	 * @Function: headMap
	 * @Description:  返回key小于toKey的所有元素,inclusive = true时包含等于的元素
	 *
	 * @param treeMap
	 * @param toKey
	 * @param inclusive
	 */
	public static void headMap() {
		// {1=one, 2=two, 3=three, 4=four}
		System.out.println(treeMap.headMap("5"));
		// {1=one, 2=two, 3=three, 4=four, 5=five}
		System.out.println(treeMap.headMap("5",true));
	}

	/**
	 * @Function: higherEntry
	 * @Description: 返回最近接近参数key的元素(大于参数key)
	 *
	 * @param treeMap
	 */
	public static void higherEntry() {
		// 5=five
		System.out.println(treeMap.higherEntry("4.9"));
		// 2=two
		System.out.println(treeMap.higherEntry("1.3"));
	}

	/**
	 * @Function: higherKey
	 * @Description: 返回最近接近参数key的元素的key(大于参数key)
	 *
	 * @param treeMap
	 */
	public static void higherKey() {
		// 5
		System.out.println(treeMap.higherKey("4.9"));
		// 2
		System.out.println(treeMap.higherKey("1.3"));
	}

	/**
	 * @Function: keySet
	 * @Description: 遍历所有key
	 *
	 * @param treeMap
	 */
	public static void keySet() {
		/*
		 * 1
		 * 2
		 * 3
		 * 4
		 * 5
		 */
		for(String key : treeMap.keySet()) {
			System.out.println(key);
		}
	}

	/**
	 * @Function: lastEntry
	 * @Description: 返回最后一个元素
	 *
	 * @param treeMap
	 */
	public static void lastEntry() {
		// 5=five
		System.out.println(treeMap.lastEntry());
	}

	/**
	 * @Function: lastKey
	 * @Description: 返回最后一个元素的key
	 *
	 * @param treeMap
	 */
	public static void lastKey() {
		// 5
		System.out.println(treeMap.lastKey());
	}

	/**
	 * @Function: lowerEntry
	 * @Description: 返回小于指定key的最大的元素
	 *
	 * @param treeMap
	 */
	public static void lowerEntry() {
		// 3=three
		System.out.println(treeMap.lowerEntry("3.9"));
		// 3=three
		System.out.println(treeMap.lowerEntry("4"));
	}

	/**
	 * @Function: lowerKey
	 * @Description: 返回小于指定key的最大的元素的key
	 *
	 * @param treeMap
	 */
	public static void lowerKey() {
		// 3
		System.out.println(treeMap.lowerKey("3.9"));
		// 3
		System.out.println(treeMap.lowerKey("4"));
	}
	/**
	 * @param key 需要操作的map的key
	 * @param value 需要合并的值
	 * @param remappingFunction 算法  : oldVal 为根据key获取的value , newValue 为 newVal , put(key,oldVal + newVal)
	 */
	public static void merge() {
		// 替换value
		treeMap.merge("1", "newVal", (oldVal, newVal) -> oldVal + newVal);
		// value为null,删除映射
		treeMap.merge("5", "newVal", (oldVal, newVal) -> null);
		// key不存在时,新增
		treeMap.merge("6", "newVal", (oldVal, newVal) -> oldVal + newVal);
		/*
		 * 1:onenewVal
		 * 2:two
		 * 3:three
		 * 4:four
		 * 6:newVal
		 */
		treeMap.forEach(
				 (key,value) -> {
					 System.out.println(key +":"+ value);
				 }
				);
	}

	/**
	 * @Function: 顺序遍历所有key
	 * @Description:
	 *
	 * @param treeMap
	 */
	public static void navigableKeySet() {
		// [1, 2, 3, 4, 5]
		System.out.println(treeMap.navigableKeySet());
	}

	/**
	 * @Function: pollFirstEntry
	 * @Description: 弹出第一个元素
	 *
	 * @param treeMap
	 */
	public static void  pollFirstEntry() {
		Entry<String, String> entry = treeMap.pollFirstEntry();
		// 1=one
		System.out.println(entry);
		/*
		 * 2:two
		 * 3:three
		 * 4:four
		 * 5:five
		 */
		treeMap.forEach(
				 (key,value) -> {
					 System.out.println(key +":"+ value);
				 }
				);
	}

	/**
	 * @Function: pollLastEntry
	 * @Description: 弹出最后一个元素
	 *
	 * @param treeMap
	 */
	public static void pollLastEntry() {
		Entry<String, String> entry = treeMap.pollLastEntry();
		// 5=five
		System.out.println(entry);
		/*
		 * 1:one
		 * 2:two
		 * 3:three
		 * 4:four
		 */
		treeMap.forEach(
				 (key,value) -> {
					 System.out.println(key +":"+ value);
				 }
				);
	}


	/**
	 * @Function: replaceAll
	 * @Description: 根据函数对TreeMap中所有元素value进行替换
	 *
	 * @param treeMap
	 */
	public static void replaceAll() {
		treeMap.replaceAll(
				(key,value) -> {
					if(key.equals("1")) {
						return "a";
					}else {
						return "B";
					}
				});
		/*
		 * 1:a
		 * 2:B
		 * 3:B
		 * 4:B
		 * 5:B
		 */
		treeMap.forEach(
				 (key,value) -> {
					 System.out.println(key +":"+ value);
				 }
				);
	}

	/**
	 * 
	 * @Function: subMap
	 * @Description: 返回此TreeMap中的部分元素,范围[fromKey至,toKey) 
	 *
	 * @param treeMap
	 * @param fromKey
	 * @param fromInclusive 为true时包含
	 * @param toKey
	 * @param toInclusive 为true时包含
	 */
	public static void subMap() {
		// {1=one, 2=two}
		System.out.println(treeMap.subMap("1", "3"));
		// {1=one, 2=two, 3=three}
		System.out.println(treeMap.subMap("1", true, "3", true));
		// {2=two}
		System.out.println(treeMap.subMap("1", false, "3", false));
	}

	/**
	 * 
	 * @Function: tailMap
	 * @Description: 返回此TreeMap中的部分元素,key大于等于fromKey
	 *
	 * @param treeMap 
	 * @param fromKey 
	 * @param inclusive true:返回元素中包含等于fromKey
	 */
	public static void tailMap() {
		// {2=two, 3=three, 4=four, 5=five}
		System.out.println(treeMap.tailMap("1.1"));
		// {2=two, 3=three, 4=four, 5=five}
		System.out.println(treeMap.tailMap("2"));
		// {3=three, 4=four, 5=five}
		System.out.println(treeMap.tailMap("2",false));
	}


	/**
	 * @Function: values
	 * @Description: 遍历TreeMap中所有元素的value
	 *
	 * @param treeMap TreeMap实例
	 */
	public static void values() {
		/*
		 * one
		 * two
		 * three
		 * four
		 * five
		 */
		for(String value : treeMap.values()) {
			System.out.println(value);
		}
	}

}
李思净
关注
专栏目录
Java类TreeMap常用API详解
WanAkiko.
08-02 1053
TreeMap - 测试类 package TreeMap_UtilityClass; import sun.reflect.generics.tree.Tree; import java.util.*; /** * TreeMap测试类 */ public class TreeMapTest { public static void main(String[] args) { // 向映射中添加元素(键不可以重复，值可以重复) TreeMap<I
Java类TreeMap常用API补充
WanAkiko.
08-02 341
TreeMap常用API补充 TreeMap常用API详解 package TreeMap_UtilityClass; import java.util.*; /** * TreeMap常用API补充 */ public class TreeMapReplenish { public static void main(String[] args) { TreeMap<Integer,String> planetMap = new TreeMap<Inte
JAVA基础学习day16--集合三-Map、HashMap,TreeMap与常用API
weixin_33895695的博客
09-26 134
一、Map简述 1.1、简述 public interface Map&lt;K,V&gt; 类型参数：K - 此映射所维护的键的类型 keyV - 映射值的类型 value该集合提供键--值的映射。key不能重复，一对对的存储方式 将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。 1.2、方法 嵌套类摘要 static interface ...
TreeMap源码详解
程序猿进阶
09-26 1788
背景：昨天有人问我，他想将Map中的Key按照顺序进行遍历，我说直接使用keySet方法获取到Set集合，因为它是集成Collection接口，所以包含了sort方法后遍历取value值即可。但当看到TreeMap的那一刻，我发现自己错了。【1】TreeMap的key不能为nullvalue可以为null;【2】HashMap的key可以为nullvalue可以为null;【3】和HashTable的key和value都不可以为null;
TreeMap 官方API
motongxue的博客
11-09 369
大家觉得写还可以，可以点赞、收藏、关注一下吧！ 也可以到我的个人博客参观一下，估计近几年都会一直更新！和我做个朋友吧！https://motongxue.cn TreeMapAPI： 定义和类型 方法和描述 Map.Entry<K,V> ceilingEntry(K key) 返回与大于或等于给定键的最小键相关联的键值映射，如果没有此键，则 null 。 K ceilingKey(K key) 返回大于或等于给定键的 null键，如果没有此键，则返回 null 。 vo
TreeMap的API使用
晴空一鹤排云上，便引诗情到碧霄。
07-20 1636
TreeMap的好博客 Java 集合系列12之 TreeMap详细介绍(源码解析)和使用示例 TreeMap类关系 public class TreeMap<K,V> extends AbstractMap<K,V> implements NavigableMap<K,V>, Cloneable, java.io.Serializable...
514.512.JAVA基础教程_枚举类与注解-集合框架涉及到的API(514).rar
11-09
本教程将深入探讨两个核心概念：枚举类（Enum）和注解（Annotation），并结合Java集合框架中的API进行讲解。以下是这些主题的详细说明。 首先，让我们了解一下枚举类。在Java中，枚举是一种特殊的类，它定义了一组...
手撕Java系列-集合框架详解，List，Set，Queue，Deque，Map，并发集合，集合工具类，Stream API
最新发布
横竖撇折点
10-26 984
手撕Java系列-集合框架详解，List，Set，Queue，Deque，Map，并发集合，集合工具类，Stream API
Java-collection-frame.rar_Java集合框架
09-20
在Java集合框架中，主要分为两大类：List（列表）、Set（集合）和Map（映射）。 1. List接口：List是一种有序的集合，允许包含重复元素。它定义了元素的插入、删除和访问方法，如add()、remove()和get()。ArrayList...
Java软件开发实战 Java基础与案例开发详解 11-1 Java集合框架和泛型机制 共6页.pdf
07-07
通过本章的学习，读者可以深入了解Java集合框架的各个组成部分及其使用方法，这对于开发高效可靠的Java应用程序至关重要。理解和掌握这些概念和技术，可以帮助开发者更好地组织和管理数据，提高代码的可读性和可维护...
Java-高级特性—集合框架
哆啦A梦
05-26 429
集合框架和泛型 Collection接口存储一组不唯一，无序的对象 List接口存储一组不唯一，有序（插入顺序）的对象 Set接口存储一组唯一，无序的对象 Map接口存储一组键值对象，提供key到value的映射（成对出现可以通过key找value，key是唯一的，无序的） 分为四大部分 ​ 1、Clollection集合 ​ 2、Map集合 ​ 3、Inerator迭代器 ​ 4、Utilities 工具类 List接口的实现类 ArrayList实现了长度可变的数组，在内存中分配连续
TreeMap的实现
05-11
TreeMap自己的理解
Java 集合系列12之 TreeMap详细介绍(源码解析)和使用示例
荒岛码农
10-08 2632
概要 这一章，我们对TreeMap进行学习。 我们先对TreeMap有个整体认识，然后再学习它的源码，最后再通过实例来学会使用TreeMap。内容包括： 第1部分 TreeMap介绍 第2部分 TreeMap数据结构 第3部分 TreeMap源码解析(基于JDK1.6.0_45) 第4部分 TreeMap遍历方式 第5部分 TreeMap示例 转载请注明出处：http:
API学习TreeMap
墨笙弘一
07-30 1605
package com.wonders.week01.collection;import java.util.Collection; import java.util.Iterator; import java.util.Map.Entry; import java.util.NavigableMap; import java.util.NavigableSet; import java.util.
Java集合框架：Map（HashMap、TreeMap）API
tjk12345的博客
11-08 218
Map集合中存储元素对(键(key)值(value)对)，每个键映射一个值，就像List的每个索引代表一个值一样，可以把List看作自带数值键的Map,但他们并没有什么联系。Map集合中存储的元素键(key)不能相同，但值(value)可以相同。不能储存基本数据类型(int等)。 Map的实现类有HashMap、TreeMap、LinkedHashMap等。 HashMap： 底层是一个数组结构(Node<K,V>[] table)，数组中的每一项都是一个链表，HashMap是数组和链表的结
java集合系列——Map之TreeMap介绍（九）
热门推荐
阿飞云漫步
03-05 1万+
TreeMap是一个有序的key-value集合，基于红黑树（Red-Black tree）的 NavigableMap实现。该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator进行排序，具体取决于使用的构造方法。
TreeMap和TreeSet特有的API
qq_43496435的博客
07-08 244
因为TreeMap能比较大小，新增的方法一般和大小比较有关 Map.Entry<K,V> ceilingEntry(K key)：返回大于等于并最接近key的一个键值对，不存在返回 null K ceilingKey(K key)：返回大于等于并最接近key的键值，不存在返回 null，相当于ceilingEntry的结果调用getKey() Comparator<? super K> comparator(): 返回比较器，如果map用自然顺序比较返回null Na.
Java.util.Map
qq_45512210的博客
09-12 142
概述 特点： 1.双列集合 2.Key不重复，value可重复 3.Key，value数据类型可以相同，也可以不同 4.Key和value一一对应 常用方法 V put（Object key） 返回值是该key值之前对应的value值。 V remove（Object key） 返回值是该key值之前对应的value值。（使用包装类接收，int不能接受null值）。 ...
JAVAAPI学习之TreeMap类
myjlvzlp的专栏
10-16 2265
package util; import java.util.Collection; import java.util.Comparator; import java.util.Iterator; import java.util.Map; import java.util.Map.Entry; import java.util.Set; import java.util.TreeMap; /
Java集合框架深度解析-Connection类图
本文主要讨论Java集合框架的基本概念、发展及主要组成部分。" 在Java编程中，集合框架是一个至关重要的部分，它为程序员提供了一种高效管理对象集合的方式。集合框架的核心理念是将多个元素组织成单一单元，便于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值