JAVA集合常用用法及常用函数（这一篇就够了）

于 2025-03-16 15:50:42 发布
阅读量880 收藏 23
点赞数 15
文章标签： java windows python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_65203311/article/details/146296170
版权

我来详细介绍Java刷题过程中常用的集合用法。

一、List接口及实现类

ArrayList

List<Integer> list = new ArrayList<>();
list.add(1);                 // 添加元素
list.add(0, 2);              // 在指定位置添加元素
list.get(0);                 // 获取元素
list.set(1, 3);              // 修改元素
list.remove(0);              // 删除指定位置元素
list.remove(Integer.valueOf(3)); // 删除指定元素
list.contains(1);            // 判断是否包含
list.size();                 // 获取大小
list.isEmpty();              // 判断是否为空
list.clear();                // 清空列表

LinkedList

LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("a");         // 添加元素
linkedList.addFirst("b");    // 添加到头部
linkedList.addLast("c");     // 添加到尾部
linkedList.getFirst();       // 获取头部元素
linkedList.getLast();        // 获取尾部元素
linkedList.removeFirst();    // 删除头部元素
linkedList.removeLast();     // 删除尾部元素
linkedList.poll();           // 检索并删除头部元素(为空返回null)
linkedList.peek();           // 检索但不删除头部元素(为空返回null)

二、Set接口及实现类

HashSet

Set<Character> set = new HashSet<>();
set.add('a');                // 添加元素
set.remove('a');             // 删除元素
set.contains('b');           // 判断是否包含
set.size();                  // 获取大小
set.isEmpty();               // 判断是否为空
set.clear();                 // 清空集合

TreeSet

// 默认升序排列
TreeSet<Integer> treeSet = new TreeSet<>();
// 自定义排序
TreeSet<Integer> customSet = new TreeSet<>((a, b) -> b - a); // 降序
treeSet.add(3);
treeSet.add(1);
treeSet.add(2);
treeSet.first();            // 获取最小元素
treeSet.last();             // 获取最大元素
treeSet.lower(2);           // 返回小于指定元素的最大元素
treeSet.higher(2);          // 返回大于指定元素的最小元素
treeSet.floor(2);           // 返回小于等于指定元素的最大元素
treeSet.ceiling(2);         // 返回大于等于指定元素的最小元素

三、Map接口及实现类

HashMap

Map<Integer, String> map = new HashMap<>();
map.put(1, "one");           // 添加键值对
map.get(1);                  // 获取值
map.getOrDefault(2, "unknown"); // 获取值，不存在返回默认值
map.containsKey(1);          // 判断是否包含键
map.containsValue("one");    // 判断是否包含值
map.remove(1);               // 删除键值对
map.size();                  // 获取大小
map.isEmpty();               // 判断是否为空
map.putIfAbsent(1, "one");   // 不存在则添加

// 遍历Map
for (Map.Entry<Integer, String> entry : map.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}
for (Integer key : map.keySet()) {
    System.out.println(key);
}
for (String value : map.values()) {
    System.out.println(value);
}
 

TreeMap

// 默认键升序排列
TreeMap<Integer, String> treeMap = new TreeMap<>();
// 自定义排序
TreeMap<Integer, String> customMap = new TreeMap<>((a, b) -> b - a); // 键降序
treeMap.put(3, "three");
treeMap.put(1, "one");
treeMap.put(2, "two");
treeMap.firstKey();          // 获取最小键
treeMap.lastKey();           // 获取最大键
treeMap.floorKey(2);         // 返回小于等于指定键的最大键
treeMap.ceilingKey(2);       // 返回大于等于指定键的最小键

四、优先队列

// 默认小顶堆
PriorityQueue<Integer> minHeap = new PriorityQueue<>();
// 大顶堆
PriorityQueue<Integer> maxHeap = new PriorityQueue<>((a, b) -> b - a);
minHeap.add(3);              // 添加元素
minHeap.add(1);
minHeap.add(2);
minHeap.peek();              // 获取堆顶元素但不删除
minHeap.poll();              // 获取并删除堆顶元素
minHeap.size();              // 获取大小
minHeap.isEmpty();           // 判断是否为空

五、双端队列Deque

Deque<Integer> deque = new ArrayDeque<>();
deque.addFirst(1);           // 添加到队首
deque.addLast(2);            // 添加到队尾
deque.offerFirst(3);         // 添加到队首，有容量限制时返回是否成功
deque.offerLast(4);          // 添加到队尾，有容量限制时返回是否成功
deque.getFirst();            // 获取队首元素
deque.getLast();             // 获取队尾元素
deque.peekFirst();           // 获取队首元素，为空返回null
deque.peekLast();            // 获取队尾元素，为空返回null
deque.removeFirst();         // 移除并返回队首元素
deque.removeLast();          // 移除并返回队尾元素
deque.pollFirst();           // 移除并返回队首元素，为空返回null
deque.pollLast();            // 移除并返回队尾元素，为空返回null

六、集合工具类Collections

List<Integer> list = new ArrayList<>(Arrays.asList(3, 1, 2));
Collections.sort(list);                      // 升序排序
Collections.sort(list, (a, b) -> b - a);     // 自定义排序
Collections.reverse(list);                   // 反转
Collections.shuffle(list);                   // 随机打乱
Collections.swap(list, 0, 1);                // 交换元素
Collections.binarySearch(list, 2);           // 二分查找(需先排序)
Collections.max(list);                       // 最大值
Collections.min(list);                       // 最小值
Collections.fill(list, 0);                   // 填充

七、数组工具类Arrays

int[] arr = {3, 1, 2};
Arrays.sort(arr);                            // 升序排序
Arrays.sort(arr, 0, 2);                      // 部分排序
Arrays.binarySearch(arr, 2);                 // 二分查找(需先排序)
Arrays.fill(arr, 0);                         // 填充
Arrays.equals(arr, new int[]{0, 0, 0});      // 判断数组是否相等
List<Integer> list = Arrays.asList(1, 2, 3); // 数组转List

八、常见算法场景应用

  1. 滑动窗口
Map<Character, Integer> window = new HashMap<>();
// 添加元素到窗口
window.put(c, window.getOrDefault(c, 0) + 1);
// 移除元素
window.put(c, window.get(c) - 1);
if (window.get(c) == 0) window.remove(c);
  1. 单调队列
Deque<Integer> deque = new ArrayDeque<>();
// 维护单调递减队列
while (!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) {
    deque.pollLast();
}
deque.offerLast(i);
  1. 两个堆维护中位数
PriorityQueue<Integer> minHeap = new PriorityQueue<>();
PriorityQueue<Integer> maxHeap = new PriorityQueue<>((a, b) -> b - a);

按类别整理的Java常用函数：

字符串操作函数

String str = "hello world";
str.length();                // 获取字符串长度
str.charAt(0);               // 获取指定位置字符
str.substring(0, 5);         // 截取子串(起始索引,结束索引)
str.substring(6);            // 从指定位置截取到结尾
str.indexOf("world");        // 查找子串首次出现位置,未找到返回-1
str.lastIndexOf("l");        // 查找子串最后出现位置
str.startsWith("he");        // 判断是否以指定前缀开始
str.endsWith("ld");          // 判断是否以指定后缀结束
str.contains("wor");         // 判断是否包含子串
str.replace("l", "L");       // 替换所有匹配字符
str.replaceAll("\\s+", "");  // 使用正则表达式替换
str.toLowerCase();           // 转小写
str.toUpperCase();           // 转大写
str.trim();                  // 去除首尾空格
str.split(" ");              // 按空格分割字符串
str.toCharArray();           // 转换为字符数组
 转换为字符数组

数组操作函数

int[] nums = {1, 2, 3, 4, 5};
Arrays.toString(nums);       // 数组转字符串
Arrays.sort(nums);           // 数组排序
Arrays.sort(nums, 1, 4);     // 部分排序(起始索引,结束索引)
Arrays.sort(nums, Collections.reverseOrder()); // 降序排序(需要包装类数组)
Arrays.sort(nums, (a, b) -> b - a); // 自定义排序
Arrays.binarySearch(nums, 3); // 二分查找(需已排序)
Arrays.fill(nums, 0);        // 填充数组
Arrays.equals(nums, new int[]{0,0,0,0,0}); // 比较数组
Arrays.copyOf(nums, nums.length); // 复制数组
Arrays.copyOfRange(nums, 1, 3); // 复制数组的一部分

数字处理函数

Math.max(a, b);              // 最大值
Math.min(a, b);              // 最小值
Math.abs(-10);               // 绝对值
Math.pow(2, 3);              // 幂运算(2的3次方)
Math.sqrt(9);                // 平方根
Math.ceil(4.3);              // 向上取整
Math.floor(4.7);             // 向下取整
Math.round(4.5);             // 四舍五入
Math.random();               // 随机数[0,1)
Integer.parseInt("123");     // 字符串转整数
Double.parseDouble("123.45"); // 字符串转小数
Integer.toBinaryString(10);  // 十进制转二进制字符串
Integer.toString(10, 16);    // 十进制转十六进制字符串
Character.isDigit('9');      // 判断是否为数字
Character.isLetter('a');     // 判断是否为字母
Character.isLetterOrDigit('a'); // 判断是否为字母或数字
Character.toLowerCase('A');  // 转小写
Character.toUpperCase('a');  // 转大写

位操作函数

 

java
 

& (与) // 两位都为1才为1 | (或) // 两位有一个为1就为1 ^ (异或) // 两位不同为1,相同为0 ~ (取反) // 0变1,1变0 << (左移) // 每左移一位相当于乘2 >> (右移) // 每右移一位相当于除2 >>> (无符号右移) // 右移补0 Integer.bitCount(n); // 计算二进制中1的个数 Integer.highestOneBit(n); // 获取最高位的1 Integer.lowestOneBit(n); // 获取最低位的1 Integer.numberOfLeadingZeros(n); // 前导0的个数 Integer.numberOfTrailingZeros(n); // 后置0的个数
 

常用算法工具函数
 

// 判断质数
boolean isPrime(int n) {
    if (n <= 1) return false;
    if (n <= 3) return true;
    if (n % 2 == 0 || n % 3 == 0) return false;
    for (int i = 5; i * i <= n; i += 6) {
        if (n % i == 0 || n % (i + 2) == 0) return false;
    }
    return true;
}

// 最大公约数
int gcd(int a, int b) {
    return b == 0 ? a : gcd(b, a % b);
}

// 最小公倍数
int lcm(int a, int b) {
    return a * b / gcd(a, b);
}

// 快速幂
long fastPow(long base, long exponent, long mod) {
    long result = 1;
    while (exponent > 0) {
        if ((exponent & 1) == 1) result = (result * base) % mod;
        base = (base * base) % mod;
        exponent >>= 1;
    }
    return result;
}

// 求组合数
int[][] generateCombinations(int n) {
    int[][] C = new int[n+1][n+1];
    for (int i = 0; i <= n; i++) {
        C[i][0] = 1;
        for (int j = 1; j <= i; j++) {
            C[i][j] = (C[i-1][j-1] + C[i-1][j]);
        }
    }
    return C;
}


 

输入输出处理
 

// 读取输入
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();           // 读取整数
double d = scanner.nextDouble();     // 读取小数
String s = scanner.next();           // 读取一个单词
String line = scanner.nextLine();    // 读取一行

// 更高效的输入
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
String line = reader.readLine();
String[] parts = line.split(" ");
int n = Integer.parseInt(parts[0]);

// 更高效的输出
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out));
writer.write(String.valueOf(result));
writer.newLine();
writer.flush();


 

二叉树遍历模板
 

// 前序遍历
void preorder(TreeNode root) {
    if (root == null) return;
    // 处理当前节点
    preorder(root.left);
    preorder(root.right);
}

// 中序遍历
void inorder(TreeNode root) {
    if (root == null) return;
    inorder(root.left);
    // 处理当前节点
    inorder(root.right);
}

// 后序遍历
void postorder(TreeNode root) {
    if (root == null) return;
    postorder(root.left);
    postorder(root.right);
    // 处理当前节点
}

// 层序遍历
void levelOrder(TreeNode root) {
    if (root == null) return;
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);
    while (!queue.isEmpty()) {
        int size = queue.size();
        for (int i = 0; i < size; i++) {
            TreeNode node = queue.poll();
            // 处理当前节点
            if (node.left != null) queue.offer(node.left);
            if (node.right != null) queue.offer(node.right);
        }
    }
}


 

图算法模板
 

// DFS模板
void dfs(int[][] graph, boolean[] visited, int node) {
    visited[node] = true;
    // 处理当前节点
    for (int next : graph[node]) {
        if (!visited[next]) {
            dfs(graph, visited, next);
        }
    }
}

// BFS模板
void bfs(int[][] graph, boolean[] visited, int start) {
    Queue<Integer> queue = new LinkedList<>();
    queue.offer(start);
    visited[start] = true;
    while (!queue.isEmpty()) {
        int node = queue.poll();
        // 处理当前节点
        for (int next : graph[node]) {
            if (!visited[next]) {
                visited[next] = true;
                queue.offer(next);
            }
        }
    }
}
补充：
 

System.arraycopy()
 

// System.arraycopy(源数组, 源数组起始位置, 目标数组, 目标数组起始位置, 要复制的元素个数)
int[] source = {1, 2, 3, 4, 5};
int[] dest = new int[5];
System.arraycopy(source, 0, dest, 0, source.length);  // 完整复制
System.arraycopy(source, 1, dest, 2, 2);  // 部分复制: 将source的索引1开始的2个元素复制到dest的索引2开始的位置



                

        

    

  



    



                



	

		

			

				
					
Java集合汇总篇

				
			

			

				

					
				

				

					12-13
					
					22万+
					
				

			

		

		

			
				
一. 集合框架
Java 集合框架一些列的接口和类来实现很多常见的数据结构和算法，例如 LinkedList 就是集合框架提供的实现了双向链表的数据结构，关于这一篇文章建议大家收藏，我会不断地完善和扩充它的内容，例如最下面的系列文章我以后也会对它进行不断的更新
集合框架的接口
集合框架提供了很多接口，这些接口都包含了特定的方法来实现对集合上的特定操作
)
我们将要学习这些接口以及子接口和它们的各种实现类，在开始之前我们先简单学习一下这些广泛运用的接口，可以看到整个集合框架，总共有三个顶级接口Collecti

			
		

	



                

            
              



	

		

			

				
					
java常用函数

				
			

			

				

					一个不懂编程的编程大佬，当一个人面对疾风，走上前去当一个逆行者，才是卫国黑客（AI终将代替人类）
				

				

					07-13
					
					347
					
				

			

		

		

			
				
本文将介绍一些常用的Java函数，并提供相应的代码示例。replace()函数用于替换字符串中的指定字符或子串。它接受两个参数，第一个参数是要被替换的字符或子串，第二个参数是替换后的字符或子串。substring()函数用于提取字符串的子串。它接受两个参数，起始位置和结束位置（不包括结束位置），并返回一个新的字符串。split()函数用于将字符串按照指定的分隔符拆分成多个子串，并返回一个字符串数组。length()函数用于获取字符串的长度。Java的Math类提供了许多用于数学计算的函数。

			
		

	



              


  
              

                


	

		

			

				
					
java中各种集合的用法和比较

				
			

			

				

					jackie03的专栏
				

				

					03-02
					
					3万+
					
				

			

		

		

			
				
一，java中各种集合的关系图 

Collection       接口的接口     对象的集合 
├ List           子接口         按进入先后有序保存   可重复 
│├ LinkedList    接口实现类     链表     插入删除   没有同步   线程不安全 
│├ ArrayList     接口实现类     数组     随机访问   没

			
		

	





	

		

			

				
					
java的常用函数

				
			

			

				

					u010673067的专栏
				

				

					07-08
					
					478
					
				

			

		

		

			
				
将字符串变成字符数组：*.toCharArray();
将字符串中取字符函数：*.charAt();
查询并返回位置的函数：*.indexOf( "有参数");
去掉数组中的空格的函数：*.trim();
截取字符串的函数：*.substring（参数）；
字符串的拆分函数：*.split（有参数）；
大小写的转换：*.toUpperCase（）；
。。。

			
		

	



		

			
		



	

		

			

				
					
JAVA常用函数汇总(Math函数、栈Stack、队列Qurue、哈希...)

				
			

			

				

					mosun_zgs的博客
				

				

					03-02
					
					2787
					
				

			

		

		

			
				
通过刷题发现许多常用的函数自己用的频繁但是少许生疏，因此自己归纳总结了以下常用的函数Math函数、栈Stack、队列Qurue、动态数组ArrayList、升序排列、反转...

			
		

	





	

		

			

				
					
Java函数式接口看这一篇就够了

				
			

			

				

					记录博主学到的点滴
				

				

					04-27
					
					764
					
				

			

		

		

			
				
目录：
 1.函数式接口的基本概念和格式
1.函数式接口的基本概念和格式
1.函数式接口的基本概念:

函数式接口在Java中是指：有且仅有一个抽象方法的接口。
函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可 以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。

如果对Lam...

			
		

	





	

		

			

				
					
Java函数式编程(二)：集合的使用

				
			

			

				

					09-04
				

			

		

		

			
				
Java函数式编程在处理集合时提供了更优雅的方式来遍历、转换和操作集合，尤其是在Java 8及更高版本中引入的Lambda表达式。本篇文章主要关注的是如何使用Lambda表达式来优化集合操作，尤其是针对列表的遍历。  首先，...

			
		

	





	

		

			

				
					
一篇文章来你学完Java中的集合（超详细）

					
最新发布

				
			

			

				

					2301_79842503的博客
				

				

					08-05
					
					3993
					
				

			

		

		

			
				
存储的是引用：Java集合存储的是对象的引用，而不是对象本身。操作的是引用：对集合的操作（如添加、获取、更新、删除）实际上是在操作这些引用。影响垃圾回收：集合中存储的引用会影响对象的垃圾回收过程，因为只要引用存在，对象就不会被回收。ListJava中的Set集合主要用于存储不重复的元素。Set接口继承自Collection接口，但它不保证维护任何特定的顺序（除非该集合是某个特定类型的，比如，它按照元素被插入的顺序来遍历元素）。Set接口的实现类主要有HashSetTreeSet等。

			
		

	





	

		

			

				
					
java常用集合之Map

				
			

			

				

					weixin_64938628的博客
				

				

					07-02
					
					1146
					
				

			

		

		

			
				
初始容量16，负载因子0.75，扩容增量1倍特点：线程不安全，最常用，速度快            内部采用数组来存放数据        put(key,val)方法的执行过程 链表结构示意图红黑树结构示意图线程安全，比HashTable性能高jdk8之前，使用的是分段锁，共16段jdk8之后，使用一桶一锁，加CAS操作key 值一定的顺序排序添加或获取元素时性能较HashMap慢   因为需求维护内部的红黑树，用于保证key值的顺序继承HashMapLinkedHashMap是有序的，且默认为插入顺序  

			
		

	





	

		

			

				
					
SpringBoot自动装配原理，这一篇就够了！

					
热门推荐

				
			

			

				

					CC_且听风吟丶的博客
				

				

					05-08
					
					8万+
					
				

			

		

		

			
				
有关SpringBoot自动装配原理，你需要知道的一切。

			
		

	





	

		

			

				
					
java基本数据型态转换成 String

				
			

			

				

					weixin_42182694的博客
				

				

					12-07
					
					219
					
				

			

		

		

			
				
由 基本数据型态转换成 String
String 类别中已经提供了将基本数据型态转换成 String 的 方法
也就是 String.valueOf() 这个参数多载的方法
有下列几种
1、String.valueOf(boolean b) : 将 boolean 变量 b 转换成字符串
2、String.valueOf(char c) : 将 char 变量 c 转换成字符串
3、String.valueOf(char[] data) : 将 char 数组 data 转换成字符串
4、String.v

			
		

	





	

		

			

				
					
【QA】Java集合常用的函数

				
			

			

				

					HMTeen
				

				

					05-10
					
					603
					
				

			

		

		

			
				
本文介绍Java集合中常用的函数。

			
		

	





	

		

			

				
					
java 集合 常用_Java 常用集合

				
			

			

				

					weixin_39632327的博客
				

				

					02-20
					
					81
					
				

			

		

		

			
				
---|Collection:单列集合,定义了最常规的操作方法---|List:有存储顺序,可重复---|ArrayList:数组实现,查找快,增删慢---|LinkedList:链表实现,增删快,查找慢实现了栈 队列---|Vector:和ArrayList原理相同,但线程安全,效率略低---| Stack 类---|Set:无存储顺序,不可重复---|...

			
		

	





	

		

			

				
					
java常用方法_java常用函数方法

				
			

			

				

					weixin_35995565的博客
				

				

					02-12
					
					310
					
				

			

		

		

			
				
展开全部Java的一些常用函数32313133353236313431303231363533e59b9ee7ad9431333337393463,方法总结：1:数组方面:数组是一个对象,数组名可以理解和C++里面一样,1):System.arraycopy(src,srcindex,dst,dstindex,src.length);2):java.util.Arrays.sort(数组名);//...

			
		

	





	

		

			

				
					
[Java] 各种常用函数

				
			

			

				

					weixin_30412167的博客
				

				

					02-22
					
					380
					
				

			

		

		

			
				
1.writeInt()和readInt()
这两个函数并不是写入一个整数,读取一个整数。它们实际上是写入4个字节,读取4个字节。
writeInt(int i)把i按四个字节,二进制形式写到输出流里,
例如i = 1,则将822938125写到文件输出流。
822938125转换为二进制是 110001 00001101 00001010 00001101每个字节对应的十进...

			
		

	





	

		

			

				
					
Java面试必备用书：常用面试题及答案解析

				
			

			

				

					
				

			

		

		

			
				
 Stream API提供了一种高效且易于使用的处理数据的方式，支持函数式编程风格，能够对集合进行链式操作。  4. **Java的异常处理机制是怎样的？**   Java的异常处理机制包括了try、catch、finally和throw、throws...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值