Java基础50道经典练习题
Posted Oracle中文开发者社区
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java基础50道经典练习题相关的知识，希望对你有一定的参考价值。
一、基础问答15题
1、【基本概念问答】
请问Java语言是跨平台的吗？JVM是跨平台的吗？为什么？
答：
Java语言是跨平台的，JVM是不跨平台的。
Java能跨平台正是以JVM不跨平台为代价的。
Java的跨平台性由JVM实现，即JVM用于保证java的跨平台的特性。
原理分析：
JVM是在机器和编译程序之间加入的一层抽象的虚拟机器，
这台虚拟的机器在任何平台上都提供给编译程序一个的共同的接口。
编译程序只需要面向虚拟机，生成虚拟机能够理解的代码，然后由 解释器 来将虚拟机代码转换为特定系统的机器码执行。
在Java中，这种供虚拟机理解的代码叫做字节码（即Java源代码经过虚拟机编译器编译后产生的文件，扩展为.class的文件），它不面向任何特定的处理器，只面向虚拟机，使Java程序无须重新编译便可在多种不同的计算机上运行。
每一种平台的解释器是不同的，但是实现的虚拟机是相同的。
Java源代码---->编译器---->jvm可执行的Java字节码(即虚拟指令)---->jvm（字节码由虚拟机解释执行）---->jvm中解释器（虚拟机将每一条要执行的字节码送给解释器）----->机器可执行的二进制机器码---->程序运行。
2、【环境变量配置问答】
为什么要配置Java环境变量？
不配置环境变量可不可以命令行编译执行Java代码？
请尝试配置环境变量，达到在命令行（cmd）窗口输入qq 命令就能启动qq的效果。（效果截图）
答：
（1）path环境变量的配置：
path是配置Windows可执行文件的搜索路径，即扩展名为.exe的程序文件所在的目录，
用于指定DOS窗口命令的路径。
告诉操作系统到哪里去找javac可执行程序配置。
① 永久配置方式：
JAVA_HOME=%安装路径%\\Java\\jdk
path=%JAVA_HOME%\\bin
② 临时配置方式：
set path=路径；
（2）classpath的配置:
classpath是配置class文件所在的目录，用于指定类搜索路径，JVM就是通过它来寻找该类的class类文件的。
给jvm用，告诉jvm到哪里加载字节码文件配置。
如果没有定义环境变量classpath，java启动jvm后，会在当前目录下查找要运行的类文件；
如果指定了classpath，那么会在指定的目录下查找要运行的类文件。
（3）配置环境变量，达到在命令行（cmd）窗口输入wechat 命令就能启动 微信 的效果。:
注：因为 qq 启动 涉及到账号 和 密码位数，故将 启动qq，改成启动 微信。两者操作 完全一样。
① 设置 Path 环境变量之前：
② 设置 Path 环境变量之后
在Path变量中添加wechat启动程序的路径，即可以在任意目录下，通过命令行执行。
3、【命令行编程】
新建一个Java文件， 然后手写Hello World程序。
（要求记事本完成，该题目提交 Helloworld程序的代码及命令行cmd运行截图即可）
答：
4、【进制转换】
将67转换为二进制、八进制、十六进制。
再将0b0100101（二进制）、0345（八进制）、0Xef（十六进制） 转换为十进制。
注：该题无需写代码，在纸上手算一下过程，拍照附在文档中提交作业。
答：
（1）相应知识点：
十进制数：在数字的右下角标注10或D。默认是十进制。
二进制数：在数字的右下角标注2或B。
Java语言中0b开头。
八进制数：在数字的右下角标注8或字母O。
Java语言中数字0开头。
十六进制：在数字的右下角标注16或H。
Java语言中0X开头。
进制之间的转换：
① 二进制 --> 十进制
将二进制数写成按权展开式，并将式中各乘积项的积相加，即得对应十进制数。
② 十进制 --> 二进制 / 八进制等
分为整数部分转换和小数部分转换
在十进制的小数部分转换中，有时连续乘以2不一定能使小数部分等于0，这说明该十进制小数不能用有限位二进制小数表示。这时，只要取足够多的位数，使其误差达到所要求的精度就可以了。
示例：十进制转换成二进制
③ 二进制 --> 八进制
④ 八进制 --> 二进制
⑤ 二进制 --> 十六进制
⑥ 十六进制 --> 二进制
（2）67转换为二进制、八进制、十六进制。
① (67)10 转换成二进制
67 / 2 = 33 (a0 = 1) 最低整数位
33 / 2 = 16 (a1 = 1)
16 / 2 = 8 (a2 = 0)
8 / 2 = 4 (a3 = 0)
4 / 2 = 2 (a4 = 0)
2 / 2 = 1 (a5 = 0)
1 / 2 = 0 (a6 = 1) 最高整数位
故 (67)10 = (1000011)2
② (67)10 转换成八进制
67 / 8 = 8 (a0 = 3) 最低整数位
8 / 8 = 1 (a1 = 0)
1 / 2 = 0 (a2 = 1) 最高整数位
故 (67)10 = (103)O
③ (67)10 转换成十六进制
67 / 16 = 4 (a0 = 3) 最低整数位
4 / 16 = 0 (a1 = 4) 最高整数位
故 (67)10 = (43)H
（3）将0b0100101（二进制）、0345（八进制）、0Xef（十六进制） 转换为十进制。
(0100101)B = 0 × 26 + 1 × 25 + 0 × 24 + 0 × 23 + 1 × 22 + 0 × 21 + 1 × 20 = (37)B
(0345)O = 0 × 83 + 3 × 82 + 4 × 81 + 5 × 80 = (229)B
(ef)H = 14 × 161 + 15 × 160 = (239)B
5、【原码补码反码】
对于一个8位原码，01101010和11000110， 求它们的补码。
已知补码01101010和11000110，求它们的原码。（要求如题4）
注：进制和原码等概念属于计算机编程基础知识，建议了解并熟悉它。
答：
（1）相应知识点：
正数的原码 = 补码
负数原码 --> 补码：符号位不变，其余位取反，末位 + 1。
补码的补码（补码求补）= 补码对应的原码。
（2）练习
正数原码 01101010 = 补码
负数原码 11000110 补码是 10111010 （符号位不变，其余位取反，末位 + 1）
正数补码 01101010 = 原码
负数补码 11000110 原码是 10111010 （符号位不变，其余位取反，末位 + 1）
6、【数据类型转换】
语句 byte b = 300; 编译能通过吗？
如果不能为什么呢？怎样让它通过编译呢？
（作为简答题说明一下即可）
答：
1）编译结果如下：
编译不通过。
2）编译不通过的原因如下：
①相应知识点
精度从高到低 double float long int short(char) byte
自动类型转换（隐式转换）：低精度–>高精度
boolean 类型的值不能直接转化为其它数据类型的值。
short、char、byte相互之间不转换，他们参与运算会首先转换为 int 类型。
强制类型转换（显示转换）： 高精度–>低精度(精度会下降)
②具体原因：
byte的表示范围是 -128~127，300超出byte表示范围，故无法完成赋值。
3）通过编译的解决方法：
进行强制类型转换
byte b = (byte)300； // 此时，输出的b为44
或者将变量b定义成int类型，或者将byte类型的b变量的赋值，改为 -128~127内的一个数。
7、【算术运算符】
以int a = 0; 语句为前提， a = a + 0.1; 和a += 0.1; 两条语句都能正常运行吗？两者有什么区别？
（仍作为简答题回答）
答：
a+=b 和 a=a+b 的区别：
① a += b执行过程：先计算出a的值，然后用一个temp对象存储，之后和b进行相加，然后将值赋值给a引用。
+= 如果两边的操作数的精度不一样时会自动向低转化。
② a = a+b 执行过程：先计算 a + b，然后再赋值给a引用，给a引用的时候如果 引用a 有计算过程，则会再次计算。
a = a+b则不会自动转化，需要手动进行强制类型转化。
练习：
int a = 0; a = a + 0.1;（x）与 int a = 0; a += 0.1;（√）
对于 int a = 0; a = a + 0.1;由于 0.1 是 double 类型，因此 a + 0.1 运算结果也是 double 型，需要强制转换类型才能赋值给 int 型。
而 int a = 0; a += 0.1; 可以正确编译，因为 a += 0.1; 相当于 a = (int(a + 0.1);其中有隐含的强制类型转换。
8、【浮点数】
float a = 0.1F; 和double b = 0.1;
这两条语句定义的浮点数a和b，请问它们相等嘛？为什么？
答：不相等。
float 是32位的单精度，double 是64位的双精度。
浮点数都是近似值，位数越多，表示的就越精确。
9、【位运算符】
给出任意一个int 类型的正整数，如何快速判断该整数的值，是否是2的整数次幂？
（简答题，考虑位运算符）
public class Test
public static void main(String[] args)
Scanner input = new Scanner(System.in);
System.out.print(“请输入一个数：”);
int num = input.nextInt();
/*
//输入的数用二进制来表示，若只有1个1，其余位全部为0，则是 2 的整数次幂，反之，则不是。
//比如 8 = 1000 ，8&7 为 1000 & 0111 = 0000 ，是 2 的整数次幂。
//与 二进制的 满2进1 有关
if ((int)(num & (num - 1) )== 0)
System.out.print("您输入的数是2的整数次幂");
else
System.out.print("您输入的数不是2的整数次幂");
*/
//不采用位运算
boolean flag = true;
while (num != 1)
if (num % 2 != 0)
flag = false;
System.out.print("您输入的数不是2的整数次幂");
break;
else
num /= 2;
if (flag)
System.out.print("您输入的数是2的整数次幂");
input.close();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
运行结果：
10、【表达式】
对于一个变量a，给出一个表达式a + “hello” ，结果的数据类型是什么？
答：
（1） “+” 运算符：
① 可表示加法运算；
② 可表示正数；
③ 可表示字符串拼接；
操作数1 + 操作数2 + … 在多个操作数中，只要有一个是字符串，"+“操作执行的就是字符串拼接。
举例：
System.out.println(“hello” + ‘a’ + 1); // helloa1
System.out.println(‘a’ + 1 + “hello”); // 98hello （‘a’的ascii码是97）
System.out.println(“5+5=”+5+5); //5+5=55
System.out.println(5+5+”=5+5"); //10=5+5
（2）练习答案：
对于一个变量a，给出一个表达式a + “hello” ，结果的数据类型是 字符串类型，输出的是变量a的值和hello组成的字符串。
11、【读程序题】
读下列代码，指出输出结果以及原因。
int a = 10;
int b;
System.out.println(b = a + 10);
1
2
3
答：
输出结果是 20
b = a + 10;表示将a + 10 的结果赋值给b，于是b的结果是20 ，这个表达式的值是赋值后b的值。
12、【标识符命令规范】
分析以下标识符的字符串组成，哪些是符合语法的标识符，哪些不合法？
请在这道题下面附上符合语法的标识符命名规范。
1） 1myName ×
2.）你好% ×
3.）My_name √
4.）Points √
5.）$point √
6.）_sys_ta √
7） OK123 √
8）_23b# ×
9）3 √
10）main √
11）class ×
答：
标识符的命名规则：
由字母、数字、下划线“_”、美元符号“$”或者“￥”组成，首字符不能是数字。
大小写敏感。
不能是关键字。
13、【标识符命令规范】
标识符的命名除了语法要求外，更重要的是符合约定俗成的规范。
下列标识符的字符串组成，都是符合语法要求的，请问哪些是符合约定俗成命名规范的？哪些不符合？
请在这道题下面附上符合约定俗成规范的Java标识符命名规范。（根据不同语法结构给出）
类名：
1）demo ×
2）test ×
3） Student √
4） Student_ ×
5） program1 ×
6） MYDemo ×
7） myDemo ×
8） XueSheng √
变量名：
9）age √
10） nianLing √
11）myName √
12）_name ×
13）Variable ×
包名：
14）com.baidu √
15）Com.Baidu ×
16）bao.ceshi ×
注：标识符命名规范相当重要。
答：
命名规则：
（1）包：
包类似于操作系统中以文件夹的形式组织文件。
在JAVA语言中，以包来组织JAVA中的类，不同包下可以包含同名的类名。
为了包名的唯一，通常以域名反转的方式来命名包，例：com.baidu.www。
多级包： 以域名（是唯一的）反转的方式来命名包，单词全部小写。
单极包： 一个全部小写的单词。如 test
（2）类和接口:
单个：首字母大写，其余字母全部小写。如 Student
多个单词：多个单词的首字母均大写，其余字母全部小写 。如：JavaBasic 、MaxAge
（3）变量和方法：
单个：所有字母小写。 如：value
多个单词：第一个单词首字母小写，从第二个开始，每个单词首字母大写。 如：intValue
（4）常量：
所有单词字母都大写。如MAX
多个单词：单词之间用_来分割，如MAX_AGE
具体的Java开发规范文档：阿里巴巴Java开发手册（嵩山版）
14、【注释】
注释的作用是什么？
注释会对程序的运行产生影响嘛？
注释的内容会存在于Java代码编译执行的哪一部分？
答：
（1）知识点
单行注释
格式：// 注释文字
多行注释
格式：/* 注释文字 */
文档注释
格式：/** 注释文字 */
可用来生成网页格式的帮助文档。
多行和文档注释都不能嵌套使用。
（2）练习答案
① 注释的作用：对程序语言进行说明，有助于开发者和用户之间的交流，方便理解程序。
② 注释会对程序的运行产生影响嘛？
注释不是编程语句，因此被编译器忽略。不会对程序的运行产生影响。
③ 注释的内容会存在于Java代码编译执行的哪一部分？
注释只存在于.java文件中，编译的时候会将注释全部自动删除。
如果通过反编译工具由.class得到的.java文件是没有注释内容的。
15、【键盘输入】
如果我想在Java程序中进行键盘输入，提升程序的扩展性。
需要按几个步骤进行？请写出步骤。
答：
① 创建 扫描器 对象，获取用户的输入
② 读取数据，读取数据的方法见下面的详细知识点
③ 关闭
下面以int型数组为例：
public static void main(String[] args)
//Scanner类用于获取键盘输入，是一个基于正则表达式的文本扫描器
//创建 扫描器 对象，获取用户的输入
//System.in输入、System.out输出
Scanner input = new Scanner(System.in);
System.out.println("输入数据:");
int n = input.nextInt();
int[] arr = new int[n];
//int等基本数据类型的数组,读取用nextInt()
for(int i=0; i<n; i++)
arr[i] = input.nextInt();
//输出arr数组
System.out.println(Arrays.toString(arr));
//使用I/O流的类，若不关闭会一直占用资源。用完要及时关闭。
input.close();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
详细知识点：
hasNextXxx（）：判断下一个输入是否是某种类型的元素
如：hasNextInt()，hasNextFloat()、hasNextDouble()等
hasNest（）：判断下一个输入是否是字符串
nextXxx（）：用于获取下一个输入项
如：nextInt、nextFloat、nextDouble等
next（）：用于读取String字符串数组，以空格划分（只读取输入直到空格），在读取后将光标指向本行
nextLine()：用于读取String字符串数组，读取包括单词之间的空格和除回车以外的所有符号，在读取后将光标指向下一行
小技巧：
既要读取普通数据，又要读取nextLine（读取一行字符串）：使用两个Scanner对象
举例如下：
public class Test
public static void main(String[] args)
Scanner input = new Scanner(System.in);
Scanner strInput = new Scanner(System.in);
int i = input.nextInt();
boolean b = input.nextBoolean();
String s = strInput.nextLine();
System.out.println(i);
System.out.println(b);
System.out.println(s);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
运行结果：
二、编程基础30题
1、【回文数】
打印5位数中的所有回文数，每行打印10个数。最后统计一下一共有多少个5位回文数。
注：回文数即正反读都是一个数，5位数的话，只要个位与万位相同，十位与千位相同就是一个回文数。
public class JavaBasic01
public static void main(String[] args)
/*
//打印所有的5位回文数 ≠ 判断一个数是否是回文数
int count = 0;
//Dig_1表示个位数字，Dig_2表示十位数字，Dig_3表示百位数字
for (int Dig_1 = 1;Dig_1 < 10;Dig_1 ++)
for (int Dig_2 = 0;Dig_2 < 10;Dig_2 ++)
for (int Dig_3 = 0;Dig_3 < 10;Dig_3 ++)
System.out.print(Dig_1 + "" + Dig_2 + "" + Dig_3 + "" + Dig_2 + "" +Dig_1 + " ");
count ++;
if (count % 10 == 0)
System.out.println();
System.out.print("5位回文数的个数是：" + count + "个");
*/
//另外给出 判断输入的数是否是回文数的算法
Scanner input = new Scanner(System.in);
System.out.print("请输入需要判断的数(位数不限):");
int n = input.nextInt();
boolean flag = true;
//或者采用num%10、num/10的循环方式，将其存入int型数组
String s = Integer.toString(n); //将输入的正整数转换成字符串
char arr[] = s.toCharArray(); //将字符串存入字符数组
for (int i = 0;i < arr.length / 2 ; i ++)
if (arr[i] != arr[arr.length - i - 1]) //数组中从左向右数第i个数对应从左向右数第arr.length - i - 1个数(从右向左为第i个数)
flag = false;
System.out.print("您输入的数不是回文数！");
break;
if (flag)
System.out.print("您输入的数是回文数！");
input.close();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
运行结果：
1）输出所有的5位回文数
中间部分省略
2）判断是否是回文数
2、【键盘录入-switch-求星期】
根据键盘录入的数值1、2、3、4，…7输出对应的星期一、星期二、星期三…星期日。
（考虑使用switch）
public class JavaBasic02
public static void main(String[] args)
System.out.print(“请输入星期一、星期二、星期三、星期四。。。代表的数字:”);
Scanner input = new Scanner(System.in);
int num = input.nextInt();
switch (num)
case 1:
System.out.print(“星期一”);
break;
case 2:
System.out.print(“星期二”);
break;
case 3:
System.out.print(“星期三”);
break;
case 4:
System.out.print(“星期四”);
break;
case 5:
System.out.print(“星期五”);
break;
case 6:
System.out.print(“星期六”);
break;
case 7:
System.out.print(“星期七”);
break;
default:
System.out.print(“您输入的数字有误！”);
input.close();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
运行结果：
3、【if多分支-求成绩】
键盘录入一个学生成绩（用int表示），自动输出该同学的成绩评级。
学生的分数取值范围[0,100]
分数大于等于90的，评级"优秀"；
分数大于等于80，小于90的，评级"良好"；
分数大于等于70，小于80的，评级"中等"；
分数大于等于60，小于70的，评级"及格"；
分数小于60的，评级"不及格"；
public class JavaBasic03
public static void main(String[] args)
System.out.print(“请输入该学生的成绩:”);
Scanner input = new Scanner(System.in);
double score = input.nextDouble();
/*
//采用 if多分支方法求求解
if(score < 60)
System.out.print("该同学的成绩评级为：不及格");
else if (score < 70)
System.out.print("该同学的成绩评级为：及格");
else if (score < 80)
System.out.print("该同学的成绩评级为：中等");
else if (score < 90)
System.out.print("该同学的成绩评级为：良好");
else if (score <= 100)
System.out.print("该同学的成绩评级为：优秀");
else
System.out.print("您输入的学生成绩有误！");
*/
//采用switch来做
switch ((int) (score / 10))
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
System.out.print("该同学的成绩评级为：不及格");
break;
case 6:
System.out.print("该同学的成绩评级为：及格");
break;
case 7:
System.out.print("该同学的成绩评级为：中等");
break;
case 8:
System.out.print("该同学的成绩评级为：良好");
break;
case 9:
System.out.print("该同学的成绩评级为：优秀");
break;
default:
if (score == 100) //只有100是优秀，101则是输入错误，故不可以用case 10来判断
System.out.print("该同学的成绩评级为：优秀");
else
System.out.print("您输入的学生成绩有误！");
input.close();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
运行结果：
4、【水仙花数】
请打印出所有的水仙花数。
注：所谓的"水仙花数"是指一个三位数，其各位数字的立方和等于该数本身。例如153是一个"水仙花数"，因为153 = 1的三次方 + 5的三次方 + 3的三次方。（使用for循环遍历一下就出来了）
public class JavaBasic04
public static void main(String[] args)
//打印所有的三位水仙花数 ≠ 判断一个数是否是水仙花数
//与 JavaBasic01 打印所有的五位回文数相类似
for (int Dig_1 = 0;Dig_1 < 10;Dig_1 ++)
for (int Dig_2 = 0 ;Dig_2 <10 ;Dig_2 ++)
for (int Dig_3 = 1 ;Dig_3 <10 ;Dig_3 ++)
if (Math.pow((double) Dig_1,3)+ Math.pow((double) Dig_2,3) + Math.pow((double) Dig_3,3) == Dig_1 + Dig_2 * 10 + Dig_3 * 100 )
System.out.print(Dig_3 + “” + Dig_2 + “” + Dig_1 + " ");
1
2
3
4
5
6
7
8
9
10
11
运行结果：
5、【求素数】
判断101-200之间有多少个素数，并输出其中所有素数。
注：素数即是除了1和它本身以外不再有其他因数的自然数。程序中可以用这个数，遍历除以2到这个数减去1。如果能够被整除，则表明此数不是素数，反之是素数。
public class JavaBasic05
public static void main(String[] args)
//另解：按照题目的提示：用这个数，遍历除以2到这个数减去1。如果能够被整除，则表明此数不是素数，反之是素数。
//下面采用的解题思路：如果一个数能被小于等于此数平方根的素数整除，则此数不是素数，否则是素数
//1不是素数，2是素数
Scanner input = new Scanner(System.in);
System.out.print(“请输入判断区间的下界(不包括此数)：”);
int min = input.nextInt();
System.out.print(“请输入判断区间的上界(不包括此数)：”);
int max = input.nextInt();
//法一和法二的ArrayList集合定义
//List<Integer> prime = new ArrayList<Integer>(); //使用ArrayList集合可以很方便的直接在集合后面添加素数，而使用数组则需要找出数组中填写的最后一个元素的位置
//prime.add(2); //最小的素数是2
//法一法二主要一步是控制输出大于下界的素数，而不是全部素数。也可以在for循环中直接设置，不用设置其他变量较为发杂的做法。（思路见法三）
/*
//法一：通过定义标签找出第一个大于下界的数在ArrayList集合中的位置，从而使输出的素数均大于下界
boolean first = true; //用于判断是否是第一个大于下界的数
int k = 0,count = 0;
for (int i = 3;i < max;i ++)
boolean flag = true;
for (int j = 0;j < prime.size();j ++) //如果一个数能被小于此数的素数整除，则此数不是素数，否则是素数
if (i % prime.get(j) == 0)
flag = false;
break;
if (flag)
prime.add(i);
if (i > min)
count ++;
if (first)
first = false;
k = prime.indexOf(i);
System.out.print("在此区间内(不包括区间的头尾两数)的素数是： ");
for (;k <prime.size();k ++)
System.out.print(prime.get(k) + " ");
System.out.print("\\n数量是：" + count);
*/
/*
//法二：通过两个计数器找出第一个大于下界的数在ArrayList集合中的位置，从而使输出的素数均大于下界
int countAll = 0,countInterval = 0;//countAll用于统计最大值以前素数的个数, countInterval用于统计判断区间内的素数个数
for (int i = 3;i < max;i ++)
boolean flag = true;
for (int j = 0;j < prime.size();j ++)
if (prime.get(j) > Math.sqrt((double)i)) //如果一个数能被小于等于此数平方根的素数整除，则此数不是素数，否则是素数
break;
if (i % prime.get(j) == 0 )
flag = false;
break;
if (flag)
countAll ++; //最大值以前素数的个数加1
prime.add(i);
if (i > min)
countInterval ++; //区间内的素数个数加1
System.out.print("在此区间内(不包括区间的头尾两数)的素数是： ");
for (int k = countAll - countInterval;k <prime.size();k ++)
System.out.print(prime.get(k) + " ");
System.out.print("\\n数量是：" + countInterval);
*/
//使用数组来求
/*一维数组的三种声明方法：
数据类型 [ ] 数组名 = new 数据类型 [ 长度 ] ;
数据类型 [ ] 数组名 = 数据，数据，…，数据 ;
数据类型 [ ] 数组名 = new 数据类型 [ ] 数据，数据，…，数据 ;
*/
//此时输出数组，数组中元素的初始值(默认值)为false
boolean [] prime = new boolean[max] ; //创建大小为max的数组,数组最大数是max-1。数组的下标表示数，其中的内容表示此数是否是素数
//下面的这种方法错误！这种形式不能用于赋值操作！
//for (boolean element : prime) //数组的循环遍历，只能从左到右一次遍历数组中的所有元素
// element = true; //初始化数组元素为true
for (int k = min + 1;k < max ;k ++) //此时prime[min]为false，即min初始化为不是素数
prime[k] =true;
prime[0] = prime[1] = false; //0和1不是素数，2是素数
for (int i = min;i < max ;i ++) //直接将for中的i初始化为 min （若是素数则设置为false，不是则按照初始化的值为flase，结果相同）或者初始化为min + 1（从min + 1位开始检测）
for (int j = 2 ; j <= Math.sqrt((double) i) ;j ++)
if (i % j == 0)
prime[i] = false;
break;
int count = 0;
System.out.print("在此区间内(不包括区间的头尾两数)的素数是： ");
for (int k = 0;k < max ;k ++)
if (prime[k] == true)
//或者上面第一个for循环中设置k初始值为0，即设置prime数组中的所有元素为true（除0、1），第二个for循环中设置i初始值为3，即这两个for循环常规写法
//然后将上面这个if语句写成 if (prime[k] == true && k > min),在输出的时候检测是否大于下界
count ++;
System.out.print(k + " ");
System.out.print("\\n数量是：" + count);
input.close();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
运行结果：
6、【嵌套for循环-杨辉三角形】
打印下列图案（等腰三角形）
要求，根据键盘录入的行数，决定等腰三角形的行数。
public class JavaBasic06
public static void main(String[] args)
Scanner input = new Scanner(System.in);
System.out.print(“请输入想要打印的等腰三角形的行数：”);
int num = input.nextInt();
for (int i = 1;i<= num ;i ++) //i用于控制行数
for (int blank = 1;blank <= num-i;blank ++) //打印空白
System.out.print(" “);
for (int star = 1;star <= i * 2 - 1 ;star ++) //打印五角星
System.out.print(”*");
System.out.println(); //换行
input.close();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
运行结果：
7、【嵌套for循环-九九乘法表】
打印九九乘法表。（和题6基本一样）
public class JavaBasic07
public static void print(int num)
for (int i = 1;i <= num;i ++)
for (int j = 1; j <= i; j++)
System.out.print(i + “*” + j + “=” + i * j + " ");
System.out.println();
public static void main(String[] args)
Scanner input = new Scanner(System.in);
System.out.print(“请输入一个整数：”);
int num = input.nextInt();
print(num);
input.close();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
运行结果：
8、【求完数】
一个数如果恰好等于它的所有真因子（即除了自身外的所有因数）之和，这个数就称为"完数"。
请编程求出1000 以内的所有完数。
public class JavaBasic08
public static void main(String[] args)
int sum = 0;
for (int i = 2;i < 1000;i +=2) //最小的完数是2，并且完数都是偶数
for (int j = 1; j < i; j++)
if (i % j == 0)
sum += j;
if (i == sum)
System.out.print(i + " ");
sum = 0;
1
2
3
4
5
6
7
8
9
10
11
12
13
运行结果：
9、【求不重复数字】
有1、2、3、4一共四个数字，能组成多少个不相等且无重复数字的三位数？都是多少？
注：可填在百位、十位、个位的数字都是1、2、3、4。组成所有的排列后再去掉不满足条件的就可以了。
public class JavaBasic09
public static void main(String[] args)
/*错误
outer:
for (int Dig_1 = 1;Dig_1 <= 4;Dig_1 ++)
for (int Dig_2 = 1;Dig_2 <= 4;Dig_2 ++)
for (int Dig_3 = 1;Dig_3 <= 4;Dig_3 ++)
if (Dig_1 == Dig_2 || Dig_2 == Dig_3 || Dig_3 == Dig_1)
continue outer;
else
System.out.print(Dig_3 + “” + Dig_2 + “” +Dig_1 + " ");
此时没有输出的数据
第一次 循环 Dig_1 = 1,Dig_2 = 1,Dig_3 = 1 ,遇到i,continue outer;
然后接着刚刚的数值继续，
第二次循环 Dig_1 = 2,Dig_2 = 2,Dig_3 = 2 ,遇到i,continue outer;
然后如此再向下循环，于是没有符合条件的输出
*/
int count = 0 ;
for (int Dig_1 = 1;Dig_1 <= 4;Dig_1 ++)
for (int Dig_2 = 1;Dig_2 <= 4;Dig_2 ++)
for (int Dig_3 = 1;Dig_3 <= 4;Dig_3 ++)
if(Dig_1 != Dig_2 && Dig_1 != Dig_3 && Dig_3 != Dig_2)
count ++;
System.out.print(Dig_3 + "" + Dig_2 + "" +Dig_1 + " ");
System.out.print("\\n一共可以组成 " + count + " 个符合条件的三位数。");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
运行结果：
10、【根据输入求输出-求位数、逆序输出】
键盘录入一个正整数，请求：1.它是几位数？2.逆序打印出各位数字。
public class JavaBasic10
public static void main(String[] args)
Scanner input = new Scanner(System.in);
System.out.print("请输入一个正整数：");
int num = input.nextInt(); //输入的正整数
/*
//采用ArrayList集合来求
int digitNum = 0; //输入的正整数的位数
List<Integer> digit = new ArrayList<Integer>(); //使用ArrayList集合可以很方便的直接在集合后面添加素数，而使用数组则需要找出数组中填写的最后一个元素的位置
while (num != 0)
digit.add(num % 10);
digitNum ++;
num /= 10;
System.out.println("您输入的正整数的位数是：" + digitNum);
System.out.print("您输入的正整数的逆序是：" );
for (int element : digit)
System.out.print(element);
*/
//使用数组来求
String s= Integer.toString(num); //将输入的正整数转换成字符串
char arr[] = s.toCharArray(); //将字符串存入字符数组
/*
int digitNum = arr.length;
System.out.println("您输入的正整数的位数是：" + digitNum);
System.out.print("您输入的正整数的逆序是：" );
for (int i = arr.length - 1 ;i >= 0 ;i --)
System.out.print(arr[i]);
*/
//或者将数组中的元素逆序，从头输出
int mid = arr.length / 2;
for (int i = 0;i < mid;i ++)
char temp = arr[i];
arr[i] = arr[arr.length - i - 1];
arr[arr.length - i - 1] = temp;
System.out.println("您输入的正整数的位数是：" + arr.length);
System.out.print("您输入的正整数的逆序是：" );
for (char element : arr)
System.out.print(element);
//或者不用字符串数组，采用int型数组，用num % 10、num / 10的方式将正整数的各位分解存入数组中来求
input.close();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
运行结果：
11、【数列的前n项和】
有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13. 求出这个数列的前20项之和。
注：提前告诉你答案是32.66026079864164
//【数列的前n项和】有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13. 求出这个数列的前20项之和。
//注：提前告诉你答案是32.66026079864164
public class JavaBasic11
public static void main(String[] args)
int numerator = 2 , denominator = 1; //第一个数字是2/1
double result = 0;
System.out.print(numerator + “/” + denominator);
for (int num = 1;num <= 20; num ++) //计算前20项和–循环20次
result += (double) numerator / denominator;
numerator += denominator;
denominator = numerator - denominator;
System.out.print(" + " + numerator + “/” + denominator); //分子：numerator，分母：denominator
System.out.println(“\\n结果是:” + result);
input.close();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
运行结果：
12、【累加】
求前n个数的和，其中n>0。
public class JavaBasic12
public static void main(String[] args)
Scanner input = new Scanner(System.in);
System.out.print(“求前 n 个数的和，输入 n 的值（n > 0）:”);
int n = input.nextInt();
int sum = 0;
for (;n > 0;n --)
sum += n;
System.out.print("和为 " + sum);
input.close();
1
2
3
4
5
6
7
8
9
10
11
12
运行结果：
13、【累乘】
求前n个数的积，其中n>0。
public class JavaBasic13
public static void main(String[] args)
Scanner input = new Scanner(System.in);
System.out.print(“求前 n 个数积，输入 n 的值（n > 0）:”);
int n = input.nextInt();
int accumulate = 1;
for (;n > 0;n --)
accumulate *= n;
System.out.print("积为 " + accumulate);
input.close();
1
2
3
4
5
6
7
8
9
10
11
12
运行结果：
14、【求最大值】
分别用if和三目运算符求三个数的最大值。比较一下两种方式，哪种比较好？
public class JavaBasic14
public static void main(String[] args)
Scanner input = new Scanner(System.in);
System.out.print(“请分别输入这三个数：”);
int num1 = input.nextInt(),num2 = input.nextInt(),num3 = input.nextInt();
//if嵌套方式
if(num1 > num2)
if(num1 > num3)
System.out.println("max = " + num1);
else
System.out.println("max = " + num2);
else
if(num2 > num3)
System.out.println("max = " + num2);
else
System.out.println("max = " + num3);
//if非嵌套方式
int temp;
if(num1 > num2)
temp = num1;
else
temp = num2;
if(temp > num3)
System.out.println("max = " + temp);
else
System.out.println("max = " + num3);
//三目运算符方式
//三目运算符 - 法一
//采用一个中间变量的方式
//int tempNum = (num1 > num2) ? num1 : num2;
//int result = (temp > num3) ? temp : num3;
//注：求最小值时，直接将上述的所有 > 全变成 ＜ 即可
int result = num1 > num2 ?( num1 > num3 ? num1 :num3 ) : (num2 > num3 ? num2 : num3);
System.out.println("max = " + result);
input.close();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
运行结果：
15、【根据条件求数-加100/268是完全平方】
一个整数，它加上100或者268后都是一个完全平方数，请问在1万以内，这样的数有几个，分别是多少？
注：使用Math.sqrt(double a) 方法可以求a的平方根。
public class JavaBasic15
public static void main(String[] args)
// //错误示例：
// //逆向思维，先求出10000(10000 = 100 * 100)内大于100（100 = 10 * 10）的完全平方数，再减去100和268
// int count = 0;
// //结果仍然是错误的，漏掉9933，9933 + 268 = 10201 ,是101的平方
// for (int i = 11; i * i - 100 < 10000; i++)
// System.out.print(i * i - 100 + " “); //如果for循环中判断条件是 i <100,则求得的最大数是9701
// count++;
// //在这里还要去掉 加上100和加上268都是完全平方数的数。相当于求：一个整数，它加上100 和 加上268后都是一个完全平方数，问题和题目要求类似。故此方法复杂。
// if (i * i - 268 > 0 )
// System.out.print(i * i - 268 + " “);
// count++;
// if (count % 10 == 0)
// System.out.println();
//
//
// System.out.print(”\\n在1万以内，这样的数有” + count + “个”);
//正向思维
int count = 0;
for (int i =1;i < 10000;i ++)
//一个整数，它加上100或者268后都是一个完全平方数
if (Math.sqrt(i + 100) % 1 == 0 || (Math.sqrt(i + 268) % 1 == 0))
count ++;
if (count % 10 == 0)
System.out.println();
System.out.print(i + " ");
System.out.print("\\n在1万以内，这样的数有" + count +"个");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
运行结果：
16、【求奇数/偶数和】
求100以内的所有奇数/偶数的和。
public class JavaBasic16
public static void main(String[] args)
Scanner input = new Scanner(System.in);
System.out.print(“求n以内所有的奇数和偶数和，输入n:”);
int num = input.nextInt();
int oddSum = 0,evenSum = 0;
for (int i = 1;i <= num;i += 2)
oddSum += i;
//num为偶数，则evenSum - oddSum = (num - 3)/ 2 + 2;
//num为奇数，则oddSum - evenSum = (num - 3)/ 2 + 2;
evenSum = num % 2 == 0 ? (num - 3)/ 2 + 2 + oddSum : oddSum - (num - 3)/ 2 - 2;
System.out.print(num + “以内所有的奇数和为：” + oddSum + “，所有的偶数和为” + evenSum);
input.close();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
运行结果：
17、【自由落体】
假如一个小球从100米高度自由落下，每次落地后就反跳回原高度的一半。那么求它在第10次落地时，共经过多少米？第10次反弹多高？
public class JavaBasic17
//计算第 num 次反弹的高度（m）
public static double getHeight(int num)
if (num == 1)
return 100 / 2;
return getHeight(num - 1) / 2;
//计算第 num 次落地时经过的路程（m）
public static double getSum(int num)
double sum = 0;
for (int i = 1;i < num ;i ++)
sum += getHeight(i) * 3; //初始高度为1，弹跳高度为0.5，总共高度为1.5，是弹跳高度的3倍。
return sum;
public static void main(String[] args)
Scanner input = new Scanner(System.in);
System.out.print("本程序求小球在第n次落地时经过的路程（m）和第n次落地后反弹的高度，请输入n：");
int n = input.nextInt();
/*
//直接计算
//double allDistance = 0,bounceDistance = 0;
//allDistance = 100 + 2 * (100 / 2 + 100 / 2^2 + 100 / 2^3 + ... + 100 / 2^(n-1))
//上式括号内的是，首项为50，公比为1/2，数量为(n-1)的等比数列求和，结果为(50*[1-(1/2)^n]) / (1-1/2),化简结果为：300 - 200 * (1/2)^n
//bounceDistance = 100 / 2^n
System.out.print("小球从100米自由落下，每次反跳一半路程，则在第n次落地时经过的路程为：" + (300 - 200 * Math.pow(0.5,n-1)) +
", 第n次落地后反弹的高度为：" + 100/Math.pow(2.0,n));
*/
double sum = 0;
System.out.print("小球从100米自由落下，每次反跳一半路程，则在第 "+ n + " 次落地时经过的路程为：" + getSum(n) + ", 第n次落地后反弹的高度为" + getHeight(n));
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
运行结果：
18、【被几个9整除】
键盘录入一个数，请判断它数能被几个9整除 。如81就可以被2个9整除。
public class JavaBasic18
public static void main(String[] args)
Scanner input = new Scanner(System.in);
System.out.print(“输入一个数：”);
int num = input.nextInt();
int count = 0;
while (num != 1)
if (num % 9 == 0)
num /= 9;
count ++;
else
System.out.print("您输入的数字不能被 9 整除。");
break;
if (count != 0)
System.out.print("您输入的数字能被 " + count + " 个 9 整除。");
input.close();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
运行结果：
19、【判断奇偶数】
键盘录入一个in数字，判断输出它是奇数还是偶数。
public class JavaBasic19
public static void main(String[] args)
Scanner input = new Scanner(System.in);
System.out.print(“请输入一个整数：”);
int num = input.nextInt();
if(num % 2 == 0)
System.out.print(“您输入的数字是偶数”);
else
System.out.print(“您输入的数字是奇数”);
input.close();
1
2
3
4
5
6
7
8
9
10
11
12
运行结果:
20、【分解质因数】
将一个大于2的正整数分解质因数。例如：输入3的话，输出 3=3； 输入6，输出6 = 2 *3等。
public class JavaBasic20
public static boolean isPrime(int num)
//采用最简单直白的方式 判断一个数是否是 素数
for (int i = 2;i <= Math.sqrt(num);i ++)
if (num % i == 0)
return false; //不是素数
return true;
//分解质因数 函数
static boolean first = true;
public static void getPrimeFactor(int num)
if (isPrime(num)) //如果是素数，则直接输出
if (first) //如果用户键盘输入的数字本身是素数，则直接输出
System.out.print(num);
else //否则，是分解质因数 中的一步
System.out.print(" * " + num);
else
for (int i = 2;i <= num / 2;i ++) //质因数 一定小于等于此数的 1/2
if (num % i == 0)
if (i == 2 && first)
System.out.print(i);
else
System.out.print(" * " + i);
first = false;
getPrimeFactor(num / i);
break;
public static void main(String[] args)
Scanner input = new Scanner(System.in);
System.out.print("请输入一个大于2的正整数用于分解质因数:");
int num = input.nextInt();
System.out.print(num + " = ");
getPrimeFactor(num);
input.close();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
运行结果：
21、【三个数由小到大排序】
键盘输入三个整数x、y、z，请把这三个数由小到大输出。
public class JavaBasic21
public static void main(String[] args)
Scanner input = new Scanner(System.in);
System.out.print(“请分别输入这三个数：”);
int max = input.nextInt(), mid = input.nextInt(), min = input.nextInt();
if (max < mid)
//交换 max 和 mid 的值
int temp = max;
max = mid;
mid = temp;
if (max < min)
//交换 max 和 min 的值
int temp = max;
max = min;
min = temp;
if (mid < min)
//交换 mid 和 min 的值
int temp = mid;
mid = min;
min = temp;
System.out.print("您输入的这3个数，由小到大排序为：" + min + "，" + mid + "，" + max);
input.close();
//也可以采用将输入的三个数字放在一维数组中，然后对数组进行排序输出（可以参考 JavaExtend03 中的排序方法）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
运行结果：
22、【交换值】
任意给两个整数（int）值，请交互它们的值。
反射部分和错误示例 参考 CSDN 文章 java实现值交换（swap）
内容较复杂，写进了CSDN 文章 Java–交换两数的值 中，截图如下：
23、【求自守数】
自守数是指一个数的平方的尾数等于该数自身的自然数。例如：252 = 625，762 = 5776，93762 = 87909376。请求出10000（一万）以内的自守数的个数，并分别输出。
public class JavaBasic23
//用于判断这一个数是否是自守数
public static boolean isSelfGuardingNumber (int num)
//boolean flag = true;
String s = Integer.toString(num); //将输入的正整数转换成字符串
char arr[] = s.toCharArray(); //将字符串存入字符数组
int numSquare = (int)Math.pow((double)num,2);
String sSquare = Integer.toString(numSquare);
char arrSquare[] = sSquare.toCharArray(); //将字符串的平方存入字符数组
for (int i = 0,j = arrSquare.length - arr.length + i;i < arr.length;i ++,j ++ )
if (arr[i] != arrSquare[j])
//flag = false;
//System.out.print("您输入的数不是自守数。");
//break;
return false;
//if (flag)
//System.out.print("您输入的数是自守数。");
return true;
public static void main(String[] args)
Scanner input = new Scanner(System.in);
System.out.print("请输入一个正整数：");
int max = input.nextInt(); //输出此数之前自守数的个数
int count = 0;
for (int i = 0 ;i < max ; i ++)
if (isSelfGuardingNumber(i))
count ++;
System.out.print(i + " ");
System.out.print("\\n" + max + " 以内 自守数的个数是：" + count + " 个。");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
运行结果：
24、【循环练习-买饮料】
给20块钱买饮料，每瓶饮料3块钱，喝完之后退瓶子可以换回1块钱。问最多可以喝到多少瓶饮料？
public class JavaBasic24
public static void main(String[] args)
Scanner input = new Scanner(System.in);
System.out.print(“您现在有多少钱（元）？”);
int money =input.nextInt();
int bottleNum = 0,bottleNumAll = 0; //bottleNum记录暂时的瓶子数，bottleNumAll记录总共的瓶子数，即输出的结果
while (money >= 3) //剩下的钱不够买饮料的
bottleNum = money / 3 ; //第一步：买20 / 3 =6瓶饮料 //第四步：买8 / 3 =2瓶饮料 //第六步：买4 / 3 =1瓶饮料
bottleNumAll += bottleNum;
money = money - bottleNum *3 +bottleNum; //第二步：还剩20 - 18 +6 =8元 //第五步：还剩8 - 6 +2 =4元 //第七步：还剩4 - 3 &#Java基础50道经典练习题（21）——求阶乘
【程序 21 求阶乘】
题目：求 1+2!+3!+...+20!的和
程序分析：此程序只是把累加变成了累乘。
源码：
package com.homework.test;
/*
【程序 21 求阶乘】
题目：求 1+2!+3!+...+20!的和
程序分析：此程序只是把累加变成了累乘。
*/
public class Test21 {
public static void main(String [] args){
long Sum = 1;
long temp = 1;
for (int i=2; i<=20; i++){
temp *= i;
Sum += temp;
}
System.out.println(Sum);
}
}
以上是关于Java基础50道经典练习题的主要内容，如果未能解决你的问题，请参考以下文章