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.百度 √
15）Com.Baidu ×
16）bao.ceshi ×

注：标识符命名规范相当重要。

答：

命名规则：

（1）包：

包类似于操作系统中以文件夹的形式组织文件。

在JAVA语言中，以包来组织JAVA中的类，不同包下可以包含同名的类名。

为了包名的唯一，通常以域名反转的方式来命名包，例：com.百度.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、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）值，请交互它们的值。

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   1 =2元
    }

    System.out.print("您一共可以购买 "   bottleNumAll   " 瓶饮料。");
    input.close();
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
运行结果：

25、【循环练习-蜗牛爬井】
井里有一只蜗牛，他白天往上爬5米，晚上掉3.5 米，井深56.7米，计算蜗牛需要多少天才能从井底到爬出来。

public class JavaBasic25 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print(“请输入井深（m）：”);
Double wellDepth = input.nextDouble();

    /*
    int day = (int)((wellDepth -5) / 1.5)   ((wellDepth -5) % 1.5 == 0 ? 1:2 );
    System.out.print("蜗牛需要 "   day  "  天才能从井底到爬出来。");
     */

    int day = 1;    //蜗牛爬出井需要的天数,无论井深是多少，天数最少是1天。
    double sum = 0; //蜗牛爬过的距离
    while (true) {
        sum  = 5;
        if (sum >= wellDepth)
            break;
        sum -= 3.5;
        day   ;
    }
    System.out.print("蜗牛需要 "   day  "  天才能从井底到爬出来。");
    
    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、【键盘录入-求各位数之和】
键盘输入任意一个正整数，求各位数字之和。

public class JavaBasic26 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print(“请输入一个正整数:”);
int num = input.nextInt();
int sum = 0;

    while (num != 0) {
        sum  = num % 10;
        num /= 10;
    }

    System.out.print("您输入的正整数的各位数字之和是: "   sum);
    input.close();
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
运行结果：

27、【求和-去除7倍数和包含7】
打印出1-100之间所有不是7的倍数和不包含7的数字， 并求和。

public class JavaBasic27 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print(“请输入判断区间的上界(不包括此数)：”);
int max = input.nextInt();
int sum = 0;

    //因为知道上界是三位数，也可以分别求出 个、十、百 位置上的数字 于 7 进行比较
    //下面采用求素数的思想
    boolean[] arr = new boolean[max];
    for (int i = 0;i < arr.length;i   )
        arr[i] = true;

    for (int j = 7;j < max;j   ) {
        if (j % 7 == 0)       //去掉是7的倍数的数
            arr[j] = false;
        else {
            int temp = j;
            while (j != 0) {
                if (j % 10 == 7)   //去掉包含7的数字
                    arr[temp] = false;
                j /= 10;
            }
            j = temp;
        }
    }

    for (int k = 1;k < arr.length;k   )
        if (arr[k]) {
            System.out.print(k   "   ");
            sum  = k;
        }
    System.out.println();
    System.out.print("1 - "   max   " 之间所有不是7的倍数和不包含7的数字 之和是："   sum);
    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
运行结果：

28、【分数累加】
编写一个函数，输入n为偶数时，求1/2 1/4 1/6 … 1/n的结果；

当输入n为奇数时，求1/1 1/3 1/5 … 1/n 的结果。

public class JavaBasic28 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print(“请输入n的值：”);
int n = input.nextInt();
double result = 0;
double denominator = n % 2 ==0 ? 2 :1; //如果n是偶数，第一个相加的分数的分母为2，如果n是奇数，则第一个相加的分母为1
for (double i = denominator;i <= n; i = i 2)
result = 1 / i;
System.out.print(“函数运算的结果是：” String.format(“%.2f”, result)); //保留两位小数
input.close();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
运行结果:

29、【switch练习-某月天数】
输入年份和月份，输出这个月应该有多少天（使用switch结构，需要考虑闰年和平年，注意case穿越）

public class JavaBasic29 {
public static void main(String[] args) {
//闰年是指能被4整除，但是不能被100整除的年份 或者 能被400整除的年份
//平年2月有28天，闰年2月有29天
Scanner input = new Scanner(System.in);
System.out.print(“请输入年份和月份:”);
int year = input.nextInt();
int month = input.nextInt();
int day = 28;
switch (month) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
day = 31;
break;
case 2:
if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0)
day = 29;
break;
case 4:
case 6:
case 9:
case 11:
break;
}
System.out.print(“在 " year " 年 " month " 月一共有 " day " 天。”);
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
运行结果：

30、【三目运算符-点餐优惠方式】
某小伙想定一份外卖，商家的优惠方式如下： 鱼香肉丝单点 24 元，油炸花生米单点 8 元，米饭单点 3 元。订单满 30 元 8 折优惠。鱼香肉丝优惠价 16 元，但是优惠价和折扣不能同时使用。那么这个小伙要点这三样东西，最少要花多少钱？

public class JavaBasic30 {
public static void main(String[] args) {
int moneyPreferential = 16 8 3;
double moneyDiscount = 24 8 3 > 30 ? (24 8 3) * 0.8 : 24 8 3;
double result = moneyPreferential < moneyDiscount ? moneyPreferential : moneyDiscount;
System.out.print(“这个小伙要点这三样东西，最小要花 " result " 元”);
}
}
1
2
3
4
5
6
7
8
运行结果：

三、扩展5题
扩展5题，大多涉及方法、数组、递归等知识。

1、【递归经典问题-不死神兔】
有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子对数为多少？ （其实就是斐波那契数列）

public class JavaExtend01 {
//兔子 对数为1，1，2，3，5，8，13，21
public static int rabbit(int month) {
if (month == 1 || month == 2)
return 1; //第一个月和第二个月 兔子的对数均为1 ，没有出生的新兔子
return rabbit(month - 1) rabbit(month - 2);
}
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   )   //打印 1 ~ num 月份的兔子数
        System.out.println("第 "   i   " 月兔子总共有 "   rabbit(i)   "对。");
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
运行结果：

2、【递归】
有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。问第4个人岁数，他说比第3个人大2岁。问第三个人，又说比第2人大两岁。问第2个人，说比第一个人大两岁。最后问第一个人，他说是10岁。请问第五个人多大？

public class JavaExtend02 {
/*
参考：斐波那契数列

（1）伪代码形式:
fibonacci(n):       // n 表示求数列中第 n 个位置上的数的值
if n == 1:          // 设置结束递归的限制条件
    return 1
if n == 2:          // 设置结束递归的限制条件
    return 1
return fibonacci(n-1)   fibonacci(n-2)    // F(n) = F(n-1)   F(n-2)

（2）Java代码形式：
public class Demo {

    public static int fibonacci(int index) {        // index 表示求数列中第 index 个位置上的数的值
        if (index == 1 || index == 2)               // 设置结束递归的限制条件
            return 1;
        return fibonacci(index - 1)   fibonacci(index - 2);      // F(index) = F(index-1)   F(index-2)
    }

    public static void main(String[] args) {
        for (int i = 1; i <= 10; i  )               // 输出前 10 个数
            System.out.print(fibonacci(i)   " ");
    }
}
 */

public static int ageFunction(int people) {
    if (people == 1)
        return 10;
    return ageFunction(people - 1)   2;
}

public static void main(String[] args) {
    System.out.print("第五个人 "   ageFunction(5)   " 岁");
}

}

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
运行结果：

3、【排序】
随机给十个数字，对它们进行排序。（可以给一个有10个整数元素的数组，然后对数组排序）

public class JavaExtend03 {

//输出数组中的元素
public static void print(int[] arr) {       //这里一定要是static
    for (int i = 0;i < arr.length;i  )
        System.out.print(arr[i]   "   ");
    System.out.println();
}


//获取一个打乱的数组
public static int[] getRandomArr(int num) {
    int[] arr = new int[num];
    for (int i = 0;i < arr.length;i   )
        arr[i] = new Random().nextInt(arr.length);
    return arr;
}


//1、对数组中的元素进行 直接插入排序
public static void Insertsort(int[] arr) {    //这里一定要是static
    if (arr.length >= 2) {              //数组长度为1时，没有必要进行排序

        //不采用哨兵，数组中元素从0位置开始存放，如果采用哨兵，数组中元素从1位置开始存放，则arr[0]为哨兵
        for (int i = 1; i < arr.length; i  ) {      //从数组的第二个元素开始处理
            int x = arr[i];         //用x存放现在处理的数据，以便后面进行数据的插入操作。
            int j = i -1 ;
            for (;j >= 0 && arr[j] > x;j --)   //将待处理的元素与这一元素前面的元素进行比较，这里循环中的x不可以写成arr[i],因为此时arr[i]上的元素可能已经变化，不是原来的值
                arr[j   1] = arr[j];                //进行数据的移动操作
            arr[j   1] = x;         //将处理的这个元素插入到合适的位置
        }
    }
}


//2、对数组中的元素进行 冒泡排序
public static void Bubblesort(int[] arr) {
    for (int i = 0;i < arr.length - 1 ;i   ) {
        boolean flag = false;   //表示本趟冒泡是否发生交换的标志
        for (int j = arr.length - 1 ;j > i ;j --)   //一趟冒泡过程
            if (arr [j - 1] > arr [j]) {            //若为逆序
                //swap (arr[j-1],arr[j]) 交换
                int temp = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = temp;

                flag = true;
            }
        if (flag == false)      //本趟遍历后没有发生交换，说明表已经有序
            break;  //或者return;
    }
}


//3、对数组中的元素进行 快速排序
public static void Quicksort(int[] arr,int low,int high) {
    if (low < high){        //递归跳出的条件
        int pivotpos = Partition(arr,low,high);     //划分
        Quicksort(arr,low,pivotpos - 1);
        Quicksort(arr,pivotpos   1 ,high);
    }

}

//划分元素操作，将表arr[low...high]划分为满足上述条件的两个子表
public static int Partition(int[] arr,int low,int high) {  //一趟划分
    int pivot = arr[low];   //设当前表中第一个元素为枢轴，对表进行划分
    while(low < high) {       //循环跳出条件

        while (low < high && arr[high] >= pivot)   --high;
        arr[low] = arr[high];   //将比枢轴小的元素移动到左端

        while (low < high && arr[low] <= pivot)     low;
        arr[high] = arr[low];   //将比枢轴大的元素移动到右端
    }//while

    arr[low] = pivot;   //枢轴元素存放到最终位置
    return low;     //返回存放枢轴的最终位置
}


//4、对数组中的元素进行 简单选择排序
public static void Selectsort(int[] arr) {
    for (int i = 0; i < arr.length - 1 ;i   ){  //一共进行 n - 1 趟
        int min = i;                            //记录最小元素位置
        for (int j = i   1 ;j < arr.length;j   )    //在arr[i...n-1]中选择最小的元素
            if (arr[j] < arr[min])
                min = j;                    //更新最小元素位置
        if (min != i) {
            //swap (arr[i],arr[min]) 交换
            int temp = arr[i];
            arr[i] = arr[min];
            arr[min] = temp;
        }
    }
}


//5、对数组中的元素进行 归并排序
public static void Mergesort(int[] arr,int low,int high) {
    if (low < high){        //递归跳出的条件
        int mid = (low   high) / 2; //从中间划分两个子序列
        Mergesort(arr,low,mid);          //对左侧子序列进行递归排序
        Mergesort(arr,mid 1,high);   //对右侧子序列进行递归排序
        Merge(arr,low,mid,high);    //归并
    }

}

//Merge（）的功能是将前后相邻的两个有序表归并为一个有序表。
//设两段有序表arr[low...mid]、arr[mid 1...high]存放在同一顺序表中的相邻位置，先将它们复制到辅助数组temp中。
//每次从对应temp数组中的两个段取出一个记录进行关键字比较，将较小者放入arr中，
//当辅助数组temp中有一段的下标超出其对应的表长（即该段的所有元素都已经复制到数组arr中）时，将另一段中的剩余部分直接复制到arr数组中。
public static void Merge(int[] arr,int low,int mid,int high) {
    //表arr的两段A[low...mid]和arr[mid 1...high]各自有序，将它们合并成一个有序表

    //Java中没有malloc对内存进行直接操作的函数，直接使用new来申请。
    int[] temp = new int[arr.length 1];     //创建一个辅助数组temp
    int i,j,k;
    for (k = low;k <= high; k   )
        temp[k] = arr[k];   ///将arr中所有元素复制到temp中
    for (i =low,j = mid   1,k = i;i <= mid && j <= high ;k   ) {
        if (temp[i] <= temp[j])    //比较temp的左右两段中的元素
            arr[k] = temp[i  ];     //将较小值复制到arr数组中
        else
            arr[k] = temp[j  ];
    }//for

    //下面的两个while循环只有1个会执行
    while (i <= mid)
        arr[k  ] = temp[i   ];      //若第一个表未检测完，复制
    while (j <= high)
        arr[k  ] = temp[j  ];       //若第二个表未检测完，复制

}


//测试
public static void main(String[] args) {
    int[] arr = getRandomArr(10);

    System.out.print("直接插入排序后：");
    Insertsort(arr);
    print(arr);

    System.out.print("冒泡排序后：");
    Bubblesort(arr);
    print(arr);

    System.out.print("快速排序后：");
    Quicksort(arr,0,arr.length - 1);
    print(arr);

    System.out.print("简单选择排序后：");
    Selectsort(arr);
    print(arr);

    System.out.print("归并排序后：");
    Mergesort(arr,0,arr.length - 1);
    print(arr);
    //也可以采用Arrays.sort(arr)对数组进行排序
    //或者采用Arrays.sort(arr,int fromIndex, int toIndex)对数组的下标从fromIndex 到 toIndex - 1进行排序，toIndex元素不参与排序。
}

}

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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
运行结果：

4、【数组元素的插入】
有一个已经排好序的int数组{1, 2, 3, 4, 5, 6, 7, 8} 。现输入一个数（要求该数在1-8之间），按原来的规律将它插入数组中。

public class JavaExtend04 {
//JavaBasic03中的getRandomArr(int num)方法进行部分修改
public static int[] getRandomArr(int num , int digit) {
int[] arr = new int[num 1]; //将数组的元素设置成num 1，因为后面还要插入一个元素，设置成num会出现java.lang.ArrayIndexOutOfBoundsException：数组越界错误
int i = 0;
for (;i < num;i )
arr[i] = new Random().nextInt(arr.length); //数组中前面的 num 个数随机生成，后面一个数用户输入或者随机生成，数组中一共 num 1 个数。
arr[i] = digit;
return arr;
}

//JavaBasic03中的Insertsort(int[] arr)方法进行部分修改
//1、对数组 前面的num个 元素 进行 直接插入排序
public static void Insertsort(int[] arr ,int length) {    //这里一定要是static
    if (length >= 2) {              //数组长度为1时，没有必要进行排序

        //不采用哨兵，数组中元素从0位置开始存放，如果采用哨兵，数组中元素从1位置开始存放，则arr[0]为哨兵
        for (int i = 1; i < length; i  ) {      //从数组的第二个元素开始处理
            int x = arr[i];         //用x存放现在处理的数据，以便后面进行数据的插入操作。
            int j = i -1 ;
            for (;j >= 0 && arr[j] > x;j --)   //将待处理的元素与这一元素前面的元素进行比较，这里循环中的x不可以写成arr[i],因为此时arr[i]上的元素可能已经变化，不是原来的值
                arr[j   1] = arr[j];                //进行数据的移动操作
            arr[j   1] = x;         //将处理的这个元素插入到合适的位置
        }
    }
}

//JavaBasic03中的print(int[] arr)方法进行部分修改
//输出数组中的前length个元素
public static void print(int[] arr,int length) {       //这里一定要是static
    for (int i = 0;i <length;i  )
        System.out.print(arr[i]   "   ");
    System.out.println();
}


public static void main(String[] args) {
    Scanner input = new Scanner(System.in);
    //或者采用Random r = new Random();  int digit = r.nextInt(10); 效果一样的
    int digit = new Random().nextInt(10);         //要求插入的数据随机生成
    System.out.print("请输入已经排好序的int数组的元素数：");
    int num = input.nextInt();                  //表示已经排好序的int数组的元素数

    //使用数组做，手动将数组移位
    int[] arr = getRandomArr(num , digit);      //数组中的元素随机生成
    //当待排序的元素数目n较小时，采用直接插入排序或简单选择排序更好
    System.out.print("已经排好序的初始int数组是：");
    Insertsort(arr,num);
    print(arr ,num);

    //下面采用 直接插入排序 的思想
    //也可以将待插入的数字，放在数组的末尾，再次将整个数组进行排序，因为此时数组基本有序，故采用直接插入排序效率较高。
    int i = arr.length - 2;
    for (;arr[i] > digit;i --)      //将待处理的元素与这一元素前面的元素进行比较
        arr[i   1] = arr[i];                            //进行数据的移动操作
    arr[i   1] = digit;           //将处理的这个元素插入到合适的位置

    System.out.print("将 "   digit   " 加入已经排好序的int数组后：");
    JavaExtend03.print(arr);
    input.close();
    
    //也可以采用Arrays类中的sort()方法对数组进行排序，
}

}

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
运行结果：

5、【数组元素的交换】
给出一个int数组，把它最大的元素与第一个元素交换，最小的元素与最后一个元素交换，输出交换后的数组。

public class JavaExtend05 {
//交换函数，与JavaBasic22中四、利用数组完全一样。
//定义为静态方法
//如果不定义为静态方法，则在主函数中需要依赖于对象，需要通过对象来调用
public static void swap(int[] arr,int num1,int num2){
int temp = arr[num1];
arr[num1] = arr[num2];
arr[num2] = temp;

}

//本题的关键在于找出给出的int数组的最大元素和最小元素
public static void main(String[] args) {
    int num = new Random().nextInt(10);         //数组元素的个数随机生成（10以内）
    int[] arr = JavaExtend03.getRandomArr(num);          //获取一个长度随机，元素内容随机的数组
    System.out.print("随机生成的int数组是：");
    JavaExtend03.print(arr);

    int min = 0,max = 0;        //min 和 max 分别是数组中最小值的下标和最大值的下标
    for (int i = 0;i < arr.length;i   ) {
        if (arr[i] < arr[min])
            min = i;        //因为最后还要交换最大值与第一个元素，最小值与最后一个元素，故要知道最小值和最大值的下标
        if (arr[i] > arr[max])
            max = i;
    }

    System.out.println("数组中的最大值是 "   arr[max]   ",最小值是 "   arr[min]);

    //将题目中的交换理解为：先将数组中最大元素与第一个元素交换，然后再将第一次交换后的数组中的最小元素与此时的最后一个元素交换
    swap(arr,0,max);
    if (min == 0)
        swap(arr,arr.length-1,max);
    else
        swap(arr,arr.length-1,min);
    System.out.print("交换后的int数组是：");
    JavaExtend03.print(arr);
}

}

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
运行结果:

&amp

这篇好文章是转载于：学新通技术网