Java基础大总结

Charles776

376人浏览 · 2026-04-08 18:13:57

Charles776 · 2026-04-08 18:13:57 发布

一、输入输出

题目 1：多组A+B（基础版）

题目描述：
输入多组数据，每组数据包含两个整数 A 和 B，计算它们的和。输入以文件结尾（EOF）结束。

输入格式：
每行包含两个整数 A 和 B（-10^9 ≤ A, B ≤ 10^9）。

输出格式：
对于每组输入，输出 A+B 的结果，每行输出一个结果。

输入示例：

1 2

3 4

5 6

输出示例：

解题思路：

题目要求输入 多组数据，并且以 EOF（End Of File） 结束，因此不能使用固定次数的循环。

使用 Scanner.hasNextInt() 或 BufferedReader.readLine() 来判断是否有新的输入。

方法一：

import java.util.Scanner;
import java.util.*;

public class Main {
    public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);

		List<Integer> list = new ArrayList<>();


		while(scanner.hasNext()){

			int a = scanner.nextInt();
			int b = scanner.nextInt();
			list.add(a+b);
		}

		for(int i : list){
			System.out.println(i);
		}
			
		scanner.close();	
	}
}

方法二：

BufferedReader 可以包装任何 Reader 子类，为其增加缓冲功能。常见的组合包括:

FileReader：用于读取字符文件
InputStreamReader：将字节流转换为字符流
StringReader：从String中读取字符

readLine（）方法

readLine()是 BufferedReader 最常用的方法之一，它读取一整行文本，直到遇到行终止符（'\n'， '\r' 或 “\r\n”）。

String line;
while ((line = br.readLine()) != null) {
    System.out.println(line);
}

readLine()方法的实现原理:

从缓冲区读取字符,直到遇到换行符或到达缓冲区末尾
如果缓冲区已空,则从底层流读取更多数据
返回不包含行终止符的字符串

import java.util.Scanner;
import java.util.*;
import java.io.*;
import java.io.IOException;


public class Main {
    public static void main(String[] args) throws IOException {
		Scanner scanner = new Scanner(System.in);

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		List<Integer> list = new ArrayList<Integer>();

		String line;
		while((line = br.readLine() )!=null){
			String nums[] = line.split(" ");

			int a = Integer.parseInt(nums[0]);
			int b = Integer.parseInt(nums[1]);

			list.add(a+b);

		}

		for (Integer integer : list) {
			System.err.println(integer);
		}

		scanner.close();
	}
}

题目 2：计算圆的面积

题目描述：
输入一个半径 r，计算圆的面积，并保留两位小数。

输入格式：
输入一个正整数 r（1 ≤ r ≤ 1000）

输出格式：
输出圆的面积，结果保留两位小数。

输入示例：

输出示例：

12.57

解题思路：

计算圆的面积，公式为 π * r * r。
需要使用格式化输出，保留两位小数，使用 System.out.printf("%.2f", area);

import java.util.Scanner;
import java.util.*;

public class Main{
	public static void main(String[] args){
		Scanner scanner = new Scanner(System.in);
		
		int r =scanner.nextInt();
		System.out.printf("%.2f",Math.PI * r * r);

		scanner.close();
	}
}

题目 3：整数除法

题目描述：
输入两个整数 A 和 B，计算 A 除以 B 的整数部分，以及余数。

输入格式：
输入包含两个整数 A 和 B（-10^9 ≤ A ≤ 10^9, 1 ≤ B ≤ 1000）。

输出格式：
输出 A 除以 B 的整数部分和余数，用空格隔开。

输入示例：

10 3

输出示例：

3 1

解题思路：

直接使用 A / B 求整数部分，使用 A % B 求余数

import java.util.Scanner;
import java.util.*;

public class Main{
	public static void main(String[] args){
		Scanner scanner = new Scanner(System.in);
		
		int a = scanner.nextInt();
		int b = scanner.nextInt();

		System.out.println(a / b + " " + a % b);

		scanner.close();
	}
}

题目 4：换行输入的 A+B

题目描述：
输入两行，每行一个整数 A 和 B，计算 A+B。

输入格式：
第一行输入整数 A（-10^9 ≤ A ≤ 10^9），第二行输入整数 B。

输出格式：
输出 A+B 的结果。

输入示例：

输出示例：

解题思路：

需要读取两行输入，并计算它们的和。

import java.util.Scanner;
import java.util.*;

public class Main{
	public static void main(String[] args){
		Scanner scanner = new Scanner(System.in);
		
		int a = scanner.nextInt();
		int b = scanner.nextInt();

		System.out.println(a+b);

		scanner.close();
	}
}

题目 5：浮点数的四舍五入

题目描述：
输入一个浮点数 x（0 ≤ x ≤ 10000），对其进行四舍五入，输出整数。

输入格式：
输入一个浮点数 x。

输出格式：
输出 x 四舍五入后的整数。

输入示例：

3.6

输出示例：

解题思路：

直接使用 Math.round(x) 进行四舍五入

import java.util.Scanner;
import java.util.*;

public class Main{
	public static void main(String[] args){
		Scanner scanner = new Scanner(System.in);
		
		double a = scanner.nextDouble();
		System.out.println(Math.round(a));

		scanner.close();
	}
}

题目6：大数求和（int溢出问题）

题目描述：

输入两个整数A和B（取值范围为-1e18到1e18），输出A+B的值。

输入示例：

1000000000000000000 2000000000000000000

输出示例:

3000000000000000000

import java.util.Scanner;
import java.math.BigInteger;
import java.util.*;
import java.io.*;
import java.io.IOException;

public class Main{
	public static void main(String[] args) throws IOException {
		Scanner scanner = new Scanner(System.in);
		
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		String[] nums = br.readLine().split(" ");
		BigInteger a = new BigInteger(nums[0]);
		BigInteger b = new BigInteger(nums[1]);

		System.out.println(a.add(b));

		scanner.close();
	}
}

题目7：星期计算

蓝桥杯真题，第十三届蓝桥杯Java B组省赛

已知今天是星期六，请问 $20^{22}$ 天后是星期几?

注意用数字 1 到 7表示星期一到星期日

import java.util.Scanner;
import java.math.BigInteger;
import java.util.*;

public class Main{
	public static void main(String[] args){
		Scanner scanner = new Scanner(System.in);

		BigInteger a = BigInteger.valueOf(20);
		BigInteger b = a.pow(22);
		BigInteger c = BigInteger.valueOf(7);
		BigInteger d = b.mod(c);

		System.out.println(d);
		scanner.close();
	}
}

开始时星期六，加一天那就是星期日，输出7即可

题目8：外星日历

题目描述：
某星系深处发现了文明遗迹。

他们的计数也是用十进制。
他们的文明也有日历。日历只有天数，没有年、月的概念。
有趣的是，他们也使用了类似“星期”的概念，
只不过他们的一个星期包含了9天，
为了方便，这里分别记为: A,B,C…H,I

从一些资料上看到，
他们的23日是星期E
他们的190日是星期A
他们的343251日是星期I

令人兴奋的是，他们居然也预见了“世界末日”的那天，
当然是一个很大很大的数字
651764141421415346185

请你计算一下，这遥远的一天是该文明的星期几？

你需要提交的是一个大写字母，表示该文明的星期几，
不要填写任何多余的内容。

import java.util.Scanner;
import java.math.BigInteger;
import java.util.*;

public class Main{
	public static void main(String[] args){
		Scanner scanner = new Scanner(System.in);

		char[] c ={'I','A','B','C','D','E','F','G','H'};
		BigInteger a = new BigInteger("651764141421415346185");
		BigInteger b = BigInteger.valueOf(9);

		BigInteger result = a.mod(b);
		int index = result.intValue();

		System.out.println(c[index]);
		scanner.close();
	}
}

二、条件和循环

题目1：闰年判断

题目描述：
输入一个年份，判断是否为闰年。闰年规则：
1. 能被4整除但不能被100整除；
2. 或能被400整除。
输入示例：
2000

输出示例：

true

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		
		int year = scanner.nextInt();
		if((year % 4 == 0 &&year % 100 != 0) || year % 400 == 0 ){
			System.out.println("YES");
		}else{
			System.out.println("NO");
		}
		
		scanner.close();
	}
}

题目2：计算阶乘

题目描述：
输入一个整数n（0 ≤ n ≤ 12），输出n的阶乘（n!）。
输入示例：
5
输出示例：
120

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		
		int num =scanner.nextInt();

		if(num < 0 ){
			System.out.println("负数没有阶乘");
		}else if(num == 0){
			System.out.println("1");
		}else{
			
			long result = fac(num);
			System.out.println(result);
		}
		
		
		scanner.close();
	}
	public static int fac(int num) {
	
		if(num == 1){
			return 1;
		}else{
			return num * fac(num-1);
		}
	
	}
}

题目3：输出斐波那契数列前n项

题目描述：
输入一个整数n（n ≥ 1），输出斐波那契数列的前n项（每项用空格分隔）。
斐波那契数列定义：
- F(0) = 0, F(1) = 1
- F(n) = F(n-1) + F(n-2)（n ≥ 2）
输入示例：
5
输出示例：
0 1 1 2 3

解法一（递归法）：

import java.util.*;
import java.util.Scanner;

public class Main {

	static	List<Integer> list = new ArrayList<>();
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
	
		int n = scanner.nextInt();
		
		for(int i=1; i <= n; i++){
			list.add(fib(i));
		}

		for (int a : list) {
			System.out.print(a +" ");
		}

		scanner.close();
	}

	public static int fib(int n){
		if(n == 1){
			return 1;
		}else if(n == 2){
			return 1;
		}else{
			return fib(n-1) + fib(n-2);
		}
	}
}

解法二（迭代法）：

import java.util.*;

public class Main {

	static List<Integer> list = new ArrayList<>();

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);

		int n = scanner.nextInt();

		fib(n);

		for (int a : list) {
			System.out.print(a + " ");
		}
	}

	public static void fib(int n) {

		int a = 1;
		int b = 1;

		if (n == 0) {
			list.add(a);
		} else if (n == 1) {
			list.add(b);
		} else {

			list.add(1);
			list.add(1);
			for (int i = 2; i < n; i++) {
				int c = a + b;
				a = b;
				b = c;
				list.add(c);
			}

		}
	}
}

解法三（动态规划）：

import java.util.*;

public class Main {

	static List<Integer> list = new ArrayList<>();

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);

		int n = scanner.nextInt();

		fib(n);

		for (int a : list) {
			System.out.print(a + " ");
		}
	}

	public static void fib(int n) {

		if (n == 1) {
			list.add(1);
		}else if (n == 2) {
			list.add(1);
		}else {
			list.add(1);
			list.add(1);
			for(int i = 2 ; i < n ; i++){
				int c = list.get(i-1) + list.get(i-2);
				list.add(c);
			}
		}
	}
}

题目4：判断素数

题目描述：
输入一个整数n（n ≥ 0），判断是否为素数（质数）。
输入示例：
17
输出示例：
true

import java.util.*;
import java.util.Scanner;

public class Main {

	static	List<Integer> list = new ArrayList<>();
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
	
		int n =	scanner.nextInt();

		boolean isPrime = true;

		if(n <= 1){
			isPrime = false;
		}else{
			for(int i=2; i<=Math.sqrt(n); i++){
				if(n % i == 0){
					isPrime = false;
					break;
				}
			}
		}

		System.out.println(isPrime);
		
		scanner.close();
	}

	
}

题目5：数字反转

题目描述：
输入一个整数n（-10000 ≤ n ≤ 10000），输出反转后的数字（保留符号，去除前导零）。
输入示例：
-1230
输出示例：
-321

import java.util.*;
import java.util.Scanner;

public class Main {

	static	List<Integer> list = new ArrayList<>();
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
	
		int n =	scanner.nextInt();

		int sign = n < 0 ? -1 : 1;
		
		n = Math.abs(n);

		int reversed = 0;
		while(n!=0){
			int digit = n%10;
			reversed = reversed*10 + digit;
			n/=10;
		}
		
		System.out.println(sign*reversed);

		scanner.close();
	}
}

注意：

符号位
前导0
绝对值

问题6：汉诺塔问题

题目介绍
汉诺塔问题：汉诺塔问题是一个经典的递归问题，目标是把所有盘子从一根柱子移动到另一根柱子，每次只能移动一个盘子，且大盘子不能放在小盘子上面。

有 n 个盘子，从 A 移到 C，借助 B。
规则：
一次只能移动一个盘子
不能将大盘子放在小盘子上
输入
3

输出
Move disk 1 from A to C

Move disk 2 from A to B

Move disk 1 from C to B

Move disk 3 from A to C

Move disk 1 from B to A

Move disk 2 from B to C

Move disk 1 from A to C

import java.util.Scanner;
import java.util.*;


public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		
		int num = scanner.nextInt();

		hanoi(num, 'A', 'B', 'C');
		
		scanner.close();
	}

	public static void hanoi(int n ,char from ,char to , char temp){
		if(n == 1){
			System.out.println("Move disk 1 from "+from+"to"+to);
		}else{
			hanoi(n-1,from,temp,to);
			System.out.println("Move disk "+n+" from "+from+"to"+to);
			hanoi(n-1,temp,to,from);
		}
	}

}

三、字符串操作

题目1：字符串反转

题目描述

输入一个字符串，输出它的反转结果。

输入示例

hello

输出示例

olleh

import java.util.Scanner;
import java.util.*;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		
		String s = scanner.nextLine();
		StringBuffer st = new StringBuffer(s);
		st.reverse();

		System.out.println(st);

		scanner.close();
	}
}

String类型没有直接反转的方法，可以利用StringBuffer里的reverse()方法

题目 2：统计字符出现次数

题目描述

输入一个字符串，统计其中每个字符出现的次数。

输入示例

aabbbcccc

输出示例

a:2

b:3

c:4

import java.util.Scanner;
import java.util.*;


public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		
		String s = scanner.nextLine();

		char[] c = s.toCharArray();

		Map<Character,Integer> map = new HashMap<>();
		for(char ch : c){
			if(map.containsKey(ch)){
				map.put(ch , map.get(ch)+1);
			}else{
				map.put(ch,1);
			}
		}

		for(Map.Entry<Character,Integer> entry : map.entrySet()){
			System.out.println(entry.getKey() + ":" +entry.getValue());
		}
			
		scanner.close();
	}
}

题目3：判断回文串

题目描述

输入一个字符串，判断它是否是回文（即正着和反着读都一样）。

输入示例

abba

输出示例

YES

import java.util.Scanner;
import java.util.*;


public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		
		String s = scanner.nextLine();

		StringBuffer st = new StringBuffer(s);
		st.reverse();

		String str = st.toString();

		if (s.equals(str)) {
			System.out.println("YES");
		}else{
			System.out.println("NO");
		}

		scanner.close();
	}
}

注意，利用StringBuffer反转之后一定要再次转成String类型，不然数据类型不匹配的话，怎么比较都是错误

四、综合应用

学生成绩管理系统

目标：

输入学生姓名和成绩
存储数据（ArrayList + HashMap）
计算平均分
找出最高分、最低分
按成绩排序

import java.util.*;
import java.util.Scanner;
/*
输入学生姓名和成绩

存储数据

计算平均分

找出最高分、最低分

按成绩排序

按姓名查询
*/

public class studentSystem{
    public static void main(String[] args){

        Scanner scanner = new Scanner(System.in);

        List<student> stu = new ArrayList<>();
        
        while(scanner.hasNext()){
            String name = scanner.next();
            double score = scanner.nextDouble();
            stu.add(new student(name,score));      
        }

        double maxScore = stu.get(0).score;
        double minScore = stu.get(0).score;
        double sumScore = 0;
        
        for(student student : stu){
            sumScore += student.score;
            maxScore = Math.max(maxScore, student.score);
            minScore = Math.min(minScore, student.score);
        }

        double avgScore = sumScore / stu.size();

        System.out.println("平均分：" + avgScore);
        System.out.println("最高分：" + maxScore);
        System.out.println("最低分：" + minScore);

        Collections.sort(stu);

        for(student student : stu){
            System.out.println(student.name + " " + student.score);
        }

        scanner.close();
    }
}

class student implements Comparable<student>{
    String name;
    double score;

    public student(String name , double score){
        this.name = name;
        this.score = score;
    }
    public student(){
    }

    public int compareTo(student other){
        return Double.compare(this.score, other.score);
    }


}