本文面向Java初学者，重点介绍在实际编程中常用的集合框架、大数处理和字符串操作等核心知识点。掌握这些基础后，你可以更专注于业务逻辑的实现，而不是在底层数据结构上重复造轮子。

一、输入输出与程序基本结构

Java标准输入输出是编程题的基础，以下是常用的模板：

```java

importjava.util.;

publicclassMain{

publicstaticvoidmain(String[]args){

Scannersc=newScanner(System.in);

//...处理输入

sc.close();

}

}

```

编程提示：

如果输入的第一行是一个单独的整数，推荐使用`Integer.parseInt(sc.nextLine())`来避免处理行末尾的换行符问题（相比`sc.nextInt()`更安全）

示例：

```java

intn=Integer.parseInt(sc.nextLine());

for(inti=0;i<n;i++){

//处理每行数据

}

```

二、大数处理：BigInteger

当需要处理超过long类型范围的整数时，使用`BigInteger`类。

例题：计算n!中某个数码a出现的次数（洛谷P1591）

```java

importjava.math.BigInteger;

importjava.util.Scanner;

classMain{

publicstaticvoidmain(String[]args){

Scannersc=newScanner(System.in);

intt=Integer.parseInt(sc.nextLine());

for(inti=0;i<t;i++){

String[]param=sc.nextLine().split("");

intn=Integer.parseInt(param[0]);

BigIntegerres=newBigInteger("1");

//计算阶乘

for(intj=1;j<=n;j++){

res=res.multiply(BigInteger.valueOf(j));

}

//统计数字出现次数

Stringtemp=res.toString();

intcnt=0;

for(intj=0;j<temp.length();j++){

if(temp.charAt(j)==param[1].charAt(0)){

cnt++;

}

}

System.out.println(cnt);

}

sc.close();

}

}

```

三、List：有序集合

1.使用lambda表达式排序

例题：学生按生日排序（洛谷P1104）

```java

importjava.util.;

classStudent{

intid;

Stringname;

intyyyy,mm,dd;

Student(intid,Stringname,Stringy,Stringm,Stringd){

this.id=id;

this.name=name;

this.yyyy=Integer.parseInt(y);

this.mm=Integer.parseInt(m);

this.dd=Integer.parseInt(d);

}

@Override

publicStringtoString(){

returnname;

}

}

publicclassMain{

publicstaticvoidmain(String[]args){

Scannersc=newScanner(System.in);

intn=Integer.parseInt(sc.nextLine());

List<Student>myList=newArrayList<>();

//读取数据

for(inti=1;i<=n;i++){

String[]param=sc.nextLine().split("");

myList.add(newStudent(i,param[0],param[1],param[2],param[3]));

}

//使用lambda表达式排序

Collections.sort(myList,(s1,s2)>{

if(s1.yyyy!=s2.yyyy){

returns1.yyyys2.yyyy;

}elseif(s1.mm!=s2.mm){

returns1.mms2.mm;

}elseif(s1.dd!=s2.dd){

returns1.dds2.dd;

}else{

returns2.ids1.id;//后输入的排在前面

}

});

//输出结果

for(inti=0;i<n;i++){

System.out.println(myList.get(i));

}

sc.close();

}

}

```

2.二维List（类似二维数组）

例题：杨辉三角（LeetCode118）

```java

importjava.util.ArrayList;

importjava.util.List;

classSolution{

publicList<List<Integer>>generate(intnumRows){

List<List<Integer>>ans=newArrayList<>();

for(inti=0;i<numRows;i++){

List<Integer>row=newArrayList<>();

for(intj=0;j<=i;j++){

if(j==0||j==i){

row.add(1);//首尾为1

}else{

List<Integer>preRow=ans.get(i1);

intnum=preRow.get(j)+preRow.get(j1);

row.add(num);

}

}

ans.add(row);

}

returnans;

}

}

```

四、Set：无序且不重复的集合

1.基本使用

例题：数组去重与排序（洛谷P1059）

```java

importjava.util.;

classMain{

publicstaticvoidmain(Stringargs[]){

Scannersc=newScanner(System.in);

intn=sc.nextInt();

Set<Integer>mySet=newHashSet<>();

//添加元素（自动去重）

for(inti=0;i<n;i++){

mySet.add(sc.nextInt());

}

//输出大小

System.out.println(mySet.size());

//转换为List并排序

List<Integer>arr=newArrayList<>(mySet);

Collections.sort(arr);

//输出结果

for(inti=0;i<arr.size();i++){

System.out.print(arr.get(i)+"");

}

sc.close();

}

}

```

2.使用TreeSet自动排序

```java

Set<Integer>mySet=newTreeSet<>();

//输入逻辑略...

List<Integer>arr=newArrayList<>(mySet);

for(inti=0;i<arr.size();i++){

System.out.print(arr.get(i)+"");

}

```

3.集合运算（交集、并集、差集）

```java

importjava.util.;

publicclassMain{

publicstaticvoidmain(String[]args){

//A班名单

Set<String>classA=newHashSet<>(Arrays.asList("Alice","Bob","Charlie","David"));

//B班名单

Set<String>classB=newHashSet<>(Arrays.asList("Charlie","David","Eve","Frank"));

//1.求并集：两个班总共有哪些学生？

Set<String>union=newHashSet<>(classA);//创建副本，保护原数据

union.addAll(classB);

System.out.println("并集:"+union);//[Alice,Bob,Charlie,David,Eve,Frank]

//2.求交集：同时报了两个班的学生是谁？

Set<String>intersection=newHashSet<>(classA);

intersection.retainAll(classB);

System.out.println("交集:"+intersection);//[Charlie,David]

//3.求差集：只报了A班、没报B班的是谁？

Set<String>difference=newHashSet<>(classA);

difference.removeAll(classB);

System.out.println("只在A班的:"+difference);//[Alice,Bob]

//4.判断包含关系

booleanisSubset=classA.containsAll(Arrays.asList("Alice","Bob"));

System.out.println("Alice和Bob都在A班吗？"+isSubset);//true

}

}

```

五、Map：键值对映射

1.简单管理系统

例题：教务管理系统（洛谷P5266）

```java

importjava.util.;

publicclassMain{

publicstaticvoidmain(String[]args){

Scannersc=newScanner(System.in);

intn=Integer.parseInt(sc.nextLine());

Map<String,Integer>myMap=newHashMap<>()

for(inti=0;i<n;i++){

String[]param=sc.nextLine().split("");

Stringop=param[0];

switch(op){

case"1":

myMap.put(param[1],Integer.parseInt(param[2]));

System.out.println("OK");

break;

case"2":

if(myMap.containsKey(param[1])){

System.out.println(myMap.get(param[1]));

}else{

System.out.println("Notfound");

}

break;

case"3":

if(myMap.containsKey(param[1])){

myMap.remove(param[1]);

System.out.println("Deletedsuccessfully");

}else{

System.out.println("Notfound");

}

break;

case"4":

System.out.println(myMap.size());

}

}

sc.close();

}

}

```

2.计数问题

例题：按字符频率排序（LeetCode451）

```java

publicStringfrequencySort(Strings){

Map<Character,Integer>myMap=newHashMap<>();

//统计字符频率

for(inti=0;i<s.length();i++){

charc=s.charAt(i);

myMap.put(c,myMap.getOrDefault(c,0)+1);//getOrDefault的妙用

}

//按频率降序排序

List<Character>myList=newArrayList<>(myMap.keySet());

Collections.sort(myList,(a,b)>myMap.get(b)myMap.get(a));

//构建结果字符串

StringBuildersb=newStringBuilder();

for(charc:myList){

intcount=myMap.get(c);

for(inti=0;i<count;i++){

sb.append(c);

}

}

returnsb.toString();

}

```

六、杂项：实用工具类

1.最小时间差（LeetCode539）

```java

publicintfindMinDifference(List<String>timePoints){

List<Integer>mins=newArrayList<>();

//转换为分钟数

for(Stringtime:timePoints){

String[]parts=time.split(":");

inth=Integer.parseInt(parts[0]);

intm=Integer.parseInt(parts[1]);

mins.add(h60+m);

}

//排序

Collections.sort(mins);

//计算相邻时间差

intminDiff=Integer.MAX_VALUE;

for(inti=1;i<mins.size();i++){

minDiff=Math.min(minDiff,mins.get(i)mins.get(i1));

}

//特殊处理跨天情况

minDiff=Math.min(1440+mins.get(0)mins.get(mins.size()1),minDiff);

returnminDiff;

}

``

2.StringBuilder使用

例题：反转字符串中的单词（LeetCode151）

```java

publicStringreverseWords(Strings){

StringBuildersb=newStringBuilder();

s=s.trim();//去除首尾空格

String[]words=s.split("+");//正则表达式：一个或多个空格

//从后向前添加单词

for(inti=words.length1;i>=0;i){

sb.append(words[i]);

if(i!=0){

sb.append("");

}

}

returnsb.toString();

}

```

3.栈的应用：括号匹配

```java

publicbooleanisValid(Strings){

Deque<Character>myStack=newArrayDeque<>();

for(charc:s.toCharArray()){

if(c=='{'||c=='['||c=='('){

myStack.push(c);//左括号入栈

}elseif(c=='}'||c==']'||c==')'){

if(myStack.isEmpty())returnfalse;//栈空但遇到右括号

chartemp=myStack.peek();//查看栈顶

if((temp=='('&&c==')')||

(temp=='['&&c==']')||

(temp=='{'&&c=='}')){

myStack.pop();//匹配成功，弹出栈顶

}else{

returnfalse;//不匹配

}

}

}

returnmyStack.isEmpty();//栈空说明全部匹配

}

```

七、常用工具小结

1.集合排序：`Collections.sort(list,comparator)`

2.最大值常量：`Integer.MAX_VALUE`、`Integer.MIN_VALUE`

3.字符串分割：`String.split("+")`按空格分割

4.数学函数：`Math.min()`、`Math.max()`、`Math.abs()`

5.StringBuilder：处理字符串拼接的高效方式

八、总结

掌握这些Java基础语法和集合框架的核心用法，可以帮助你：

快速解决编程题中的输入输出、数据处理问题

理解和使用常见的数据结构（List、Set、Map）

处理大数、字符串等常见数据类型

为后续学习面向对象设计和更复杂的算法打下坚实基础

在实际开发中，这些基础知识同样重要，它们是你构建复杂系统的基石。建议多练习相关题目，将这些知识内化为编程直觉。