目录
知识点全面整理与复习指南
本文系统整理了蓝桥杯Java组竞赛所需的核心知识点，涵盖从基础语法到高级算法的各个方面，旨在帮助参赛选手高效备赛。内容基于CSDN等多篇高质量技术博客的精华内容整合而成，包括输入输出处理、数据结构应用、算法模板、数学知识等关键领域。每个知识点都配有典型例题和代码实现，特别适合备赛蓝桥杯省赛及国赛的Java选手参考学习。
基础语法与输入输出
标准输入输出处理
Java中的标准输入输出是蓝桥杯竞赛中最基础也是最重要的部分。Scanner类是处理输入最常用的工具：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
while (scanner.hasNext()) {
int a = scanner.nextInt();
int b = scanner.nextInt();
System.out.println(a + b);
}
}
}
注意事项：
nextInt()读取整数，nextDouble()读取浮点数next()读取不包含空格的字符串nextLine()读取整行（包含空格）
快速输入输出
当输入输出规模超过1e6时，必须使用快速IO：
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
String[] input = br.readLine().split(" ");
int n = Integer.parseInt(input[0]);
pw.println("输出内容");
pw.flush(); // 必须调用flush
性能对比：
- Scanner读取1e7数据约需30秒
- BufferedReader读取1e7数据仅需3秒
格式化输出
double pi = 3.1415926;
System.out.printf("%.2f", pi); // 输出3.14
int hh=12, mm=5, ss=9;
System.out.printf("%02d:%02d:%02d", hh, mm, ss); // 输出12:05:09
字符串操作
基本字符串方法
String s = "Hello World";
// 获取字符
char c = s.charAt(1); // 'e'
// 查找索引
int idx = s.indexOf("World"); // 6
// 子字符串
String sub = s.substring(6); // "World"
// 分割字符串
String[] arr = "a,b,c".split(",");
// 特殊分割(如小数点)
String[] nums = "1.2.3".split("\\.");
// 字符串比较
boolean eq = s.equals("hello"); // false
boolean eqIgnore = s.equalsIgnoreCase("hello world"); // true
字符串与其他类型转换
// 字符串转数字
String numStr = "123";
int num = Integer.parseInt(numStr);
// 数字转字符串
String str = String.valueOf(123);
// 字符数组转字符串
char[] chars = {'a','b','c'};
String str = new String(chars); // 正确方式
String wrong = chars.toString(); // 错误方式
字符串构建
对于频繁修改的字符串，使用StringBuilder更高效：
StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(" ");
sb.append("World");
String result = sb.toString(); // "Hello World"
数据结构应用
数组与集合
一维数组：
int[] arr = new int[10];
Arrays.sort(arr); // 排序
Arrays.fill(arr, -1); // 填充
二维数组：
int[][] matrix = new int[n][m];
// 输出二维数组建议使用快写
PrintWriter pw = ...;
for(int[] row : matrix) {
for(int num : row) {
pw.print(num + " ");
}
pw.println();
}
pw.flush();
ArrayList动态数组：
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.get(0);
list.size();
list.remove(0);
集合框架
HashSet：
Set<Integer> set = new HashSet<>();
set.add(1);
set.contains(1);
set.remove(1);
HashMap：
Map<String, Integer> map = new HashMap<>();
map.put("key", 1);
map.get("key");
map.containsKey("key");
优先队列：
// 最小堆
PriorityQueue<Integer> minHeap = new PriorityQueue<>();
// 最大堆
PriorityQueue<Integer> maxHeap = new PriorityQueue<>((a,b)->b-a);
// 自定义比较器
PriorityQueue<Student> pq = new PriorityQueue<>(
(a,b) -> a.score != b.score ? b.score - a.score : a.name.compareTo(b.name)
);
常用算法模板
排序与查找
自定义排序：
class Student implements Comparable<Student> {
String name;
int score;
@Override
public int compareTo(Student o) {
return this.score != o.score ? o.score - this.score
: this.name.compareTo(o.name);
}
}
// 使用
Student[] students = ...;
Arrays.sort(students);
// 或使用Lambda表达式
Arrays.sort(students, (a,b) -> b.score - a.score);
二分查找：
int binarySearch(int[] nums, int target) {
int left = 0, right = nums.length - 1;
while(left <= right) {
int mid = left + (right - left)/2;
if(nums[mid] == target) return mid;
else if(nums[mid] < target) left = mid + 1;
else right = mid - 1;
}
return -1;
}
数学运算
最大公约数与最小公倍数：
// 辗转相除法
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 a, long b, long mod) {
long res = 1;
while(b > 0) {
if((b & 1) == 1) res = res * a % mod;
a = a * a % mod;
b >>= 1;
}
return res;
}
位运算技巧
// 基本操作
int a = 5; // 0101
int b = 3; // 0011
a & b; // 0001 (1)
a | b; // 0111 (7)
a ^ b; // 0110 (6)
~a; // 1010 (-6)
a << 1; // 1010 (10)
a >> 1; // 0010 (2)
// 常用技巧
(x & 1) == 0; // 判断偶数
x & (x-1); // 去掉最后一位1
x & -x; // 获取最后一位1
动态规划与图论
动态规划模板
一维DP：
int[] dp = new int[n+1];
dp[0] = 0; // 初始条件
for(int i=1; i<=n; i++) {
dp[i] = Math.max(dp[i-1], dp[i-2] + nums[i]);
}
return dp[n];
二维DP：
int[][] dp = new int[m][n];
// 初始化第一行和第一列
for(int i=1; i<m; i++) {
for(int j=1; j<n; j++) {
dp[i][j] = dp[i-1][j] + dp[i][j-1];
}
}
图论算法
邻接表表示：
List<Integer>[] graph = new ArrayList[n];
for(int i=0; i<n; i++) graph[i] = new ArrayList<>();
// 添加边
graph[u].add(v);
DFS模板：
void dfs(int u, boolean[] visited) {
visited[u] = true;
for(int v : graph[u]) {
if(!visited[v]) {
dfs(v, visited);
}
}
}
BFS模板：
void bfs(int start) {
Queue<Integer> q = new LinkedList<>();
boolean[] visited = new boolean[n];
q.offer(start);
visited[start] = true;
while(!q.isEmpty()) {
int u = q.poll();
for(int v : graph[u]) {
if(!visited[v]) {
visited[v] = true;
q.offer(v);
}
}
}
}
大数处理与特殊技巧
BigInteger大整数
import java.math.BigInteger;
BigInteger a = new BigInteger("123456789");
BigInteger b = new BigInteger("987654321");
a.add(b); // 加法
a.subtract(b); // 减法
a.multiply(b); // 乘法
a.divide(b); // 除法
a.mod(b); // 取模
a.compareTo(b); // 比较
实用技巧
浮点数精度处理：
double a = 0.1 + 0.2;
// 错误比较: if(a == 0.3)
// 正确比较:
final double EPS = 1e-10;
if(Math.abs(a - 0.3) < EPS) {
// 认为相等
}
日期处理：
import java.util.Calendar;
Calendar cal = Calendar.getInstance();
cal.set(2023, Calendar.JANUARY, 1); // 月份0-11
cal.add(Calendar.DAY_OF_MONTH, 1); // 加1天
int dayOfWeek = cal.get(Calendar.DAY_OF_WEEK);
全排列生成：
// 使用递归
void permute(int[] nums, int start, List<List<Integer>> result) {
if(start == nums.length-1) {
result.add(Arrays.stream(nums).boxed().collect(Collectors.toList()));
return;
}
for(int i=start; i<nums.length; i++) {
swap(nums, start, i);
permute(nums, start+1, result);
swap(nums, start, i);
}
}
// 使用库函数
Arrays.sort(nums);
do {
// 处理当前排列
} while(nextPermutation(nums));
蓝桥杯备赛建议
- 基础优先：确保熟练掌握所有基础语法和数据结构
- 模板记忆：熟记常用算法模板，如排序、搜索、DP等
- 真题训练：至少完成近3年的真题，理解出题思路
- 时间管理：练习时注意时间分配，简单题快速解决
- 调试技巧：学会使用打印调试和边界条件测试
推荐练习顺序：
- 基础语法和输入输出
- 字符串处理和数学问题
- 数据结构应用
- 动态规划和图论算法
- 综合真题模拟
通过系统性地学习和练习这些知识点，配合适量的真题训练，可以在蓝桥杯竞赛中取得优异成绩。建议每天保持3-5小时的专注练习时间，持续2-3个月，省一等奖乃至国奖将大有希望。
扫一扫
9348
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
