标签：Java Scanner int System 复习题 程序设计 public out

Java程序设计基础1-6

一、Java语言概述

1.Java语言有哪些特点？

• 简单易学。Java去掉了C/C++语言支持的单个不易理解和掌握的数据类型（指针pointer、联合体unions、结构体structs），转而用类和类的属性等面向对象的方法来实现，更加合理规范，且降低学习难度。
• 面向对象。Java是一种以对象为中心、以消息为驱动的面向对象的编程语言，支持封装、继承、多态。
• 平台无关性。Java语言是靠Java虚拟机（JVM）在目标代码级实现平台无关性的。
• 分布式。分布式包括数据分布和操作分布，Java语言支持这两种分布性。
• 可靠性。Java解释器运行时实施检查，可以发现数组和字符串的访问越界，另外，Java语言提供了异常处理机制，可以把一组错误的代码放在一个地方，这样可以简化错误处理任务，便于恢复。
• 安全性。当Java字节码进入解释器时，首先必须经过字节码校验器的检查；其次，Java解释器将决定程序中类的内存布局；再次，类装载器负责把来自网络的类装载到单独的内存区域，避免应用程序之间相互干扰破坏；最后，客户端用户还可以限制从网络上装载的类只能访问某些文件系统。
• 支持多线程。一方面，Java环境本身就是多线程的，若干系统线程运行，负责必要的无用单元回收、系统维护等系统级操作。另一方面，Java语言内置多线程机制，可以大大简化多线程应用程序开发。
• 支持网络编程。Java语言通过它所提供的类库可以处理TCP/IP，用户可以用URL地址在网络上很方便地方位其他对象。
• 编译与解释并存。.java文件首先会被编译成字节码文件（.class文件），字节码文件可以被Java解释器执行，有解释器将字节码文件再翻译成二进制码，使程序得以运行。

2.什么是Java虚拟机？

任何一种可以运行Java字节码的软件均可被看成Java的“虚拟机”（JVM），如浏览器与Java的开发工具等皆可以被视为一部JVM。可以把Java的字节码看成JVM上所运行的机器码（machine code），即JVM中解释器负责将字节码解释成本地的机器码。所以从底层上看，JVM就是以Java字节码为指令组的“软CPU”。可以说JVM是可运行Java字节码的假想计算机。它的作用类似于Windows操作系统，只不过在Windows上运行的是.exe文件，而在JVM上运行的是Java字节码文件，也就是扩展名为.class的文件。JVM其实就是一个字节码解释器。

3.什么是字节码？采用字节码的最大好处是什么？

（1）字节码是Java虚拟机（Java Virtual Machine，JVM）的指令组，和CPU上的微指令码很相像。Java程序编译成字节码后文件尺寸较小，便于网络传输。

（2）字节码最大的好处是可跨平台运行，即Java的字节码可以编写一次，到处运行。用户使用任何一种Java编译器将Java源程序（.java）编译成字节码文件（.class）后，无论使用哪种操作系统，都可以在含有JVM的平台上运行，这种跨越平台的特性也是让Java语言急速普及的原因之一。

4.什么是平台无关性？Java语言是怎样实现平台无关性的？

（1）平台无关性：某种语言编写的程序不用修改就可在不同的软硬件平台上运行。

• 平台无关有两种：源代码级和目标代码级。C和C++语言编写的应用程序不用修改，只需要重新编译就可以在不同平台上运行。

（2）Java语言是靠Java虚拟机（JVM）在目标代码级实现平台无关性的。

5.Java语言程序有几种？每种程序的结构包含那几个方面？

（1）使用Java语言可以编写两种类型的程序：Application（应用程序）和Applet（小程序）。这两种程序的开发原理是相同的，但是在运行环境和计算结构上却有着显著的不同。

（2）Java应用程序是可以在Java平台上独立运行的程序，应用程序中包括至多一个package语句、0个或多个import语句和至少一个类三部分。Java小程序是嵌入在HTML文件中的Java程序，是一种需要搭配浏览器才能运行的Java程序，所以小程序处理应用程序包括的三部分之外，还应有一个HTML文档将小程序嵌入其中。

6.什么是Java程序的主类？应用程序于小程序的主类有何不同？

（1）主类是Java程序执行的的入口点。一个程序中，可以有多个类，但只能有一个类是主类。在Java应用程序中，这个主类是指包含main()方法的类。在Java小程序里，这个主类是一个继承自系统类JApplet的子类。

（2）应用程序的主类不一定要求是public类，但小程序的主类一定要求是public类。

---

二、Java语言开发环境

1.什么是JDK？什么是JRE？JDK与JRE的关系是什么？

Java SE可以分为四部分：JVM、JRE、JDK和Java语言。

（1）JDK（Java Development Kits，Java开发工具包），是一个编写Java Application应用程序和Applet小程序的程序开发环境，其中包括一些Java开发工具和Java的核心类库（Java API）等，是所有Java开发工具的基础。

（2）JRE（Java Runtime Environment，Java运行环境）是Java执行程序所必须的，JRE主要是为开发好的Java程序提供程序平台。

（3）JDK与JRE的关系是：JRE是一个运行环境，JDK是一个开发环境。JRE不包含开发工具，如编译器、调试器和其他工具等，而JDK包含了JRE以及开发过程中需要的一些工具程序，引起安装JDK后除了可以编辑Java程序外，也可以运行Java程序。所以编写Java程序时需要JDK，而运行Java程序时需要JRE。

2.Java开发工具JDK 10安装后，在安装文件夹下生成几个子文件夹？这些子文件夹中包含的内容有哪些？

在JDK安装文件夹下包含的子文件夹及相应子文件夹下所包含的内容如下：

• bin：该文件夹存放javac.exe、java.exe、jmod.exe、jar.exe等命令程序。
• conf：该文件夹存放一些可供开发者编辑的Java系统配置文件。
• include：该文件夹存放支持本地代码编程与C程序相关的头文件。
• jmods：该文件夹存放预编译的Java模块，相当于JDK9之前的.jar文件。
• legal：该文件夹存放有关Java每个模块的版权声明和许可协议等。
• lib：该文件夹存放Java类库。

3.环境变量Path和ClassPath的作用是什么？如何设置Path环境变量？

（1）Path环境变量的作用是设置供操作系统去寻找和执行应用程序（.exe、.com、.bat等）路径的顺序，对Java而言即Java的安装路径；ClassPath是JVM执行Java程序时搜索类的路径（类所在的文件夹）的顺序，以最先找到的为准，JVM除了在ClassPath的环境变量指定的文件夹中查找要运行的类之外，默认是不会在当前文件夹下查找相应类的，除非设置在当前文件夹下查找。

（2）设置Path环境变量的方法有两种：一种是在控制面板中“系统和安全”下的“系统”页面内（或右击“我的电脑”图标，在弹出的快捷菜单中选择“属性”命令）设置；另一种是在命令行窗口中利用set命令进行设置。系统环境变量ClassPath在Java 10中不用再设置，Java程序完全可以编译与运行。

4.编写Java程序有哪些注意事项？

首先要安装JDK，然后必须设置系统环境变量Path。还需注意必须要按程序的命名规则给程序命名。程序中的每个类都有类名和类体，类体重通常包含两种成分：一种是成员变量；另一种是成员方法，方法体中的每个美剧以分号“;”结尾，方法体内不能再定义其他方法。另外，Java是严格区分大小写的语言。

5.Java应用程序源文件的命名有什么规定？

Java应用程序源文件的命令规则为，首先源文件的扩展名必须是.java；如果源文件中有多个类，则最多只能有一个public类，如果有，那么源文件的名字必须与这个public类的名字相同（文件名的大小写可以与public类名的大小写不同），如果源文件没有public类，那么源文件的名字由用户任意命名。

6.Java应用程序的主类是什么样的类？

主类是Java程序执行的入口点，一个Java程序可以有多个类，但只能有一个类是主类。对应用程序而言其主类必须是包含有main()方法的类。

7.如何在命令行方式下编译与运行Java应用程序？

首先在命令行窗口将应用程序源文件使用“javac 文件名.java”命令编译成扩展名为.class的字节码文件，然后运行字节码文件即可，即在命令行提示符下输入“java 主类名”。需要注意的是，原文件名和主类名可能不同，所以编译和运行程序时要注意区别。

---

三、Java语言基础

1.Java语言定义了哪几种基本数据类型？

Java语言定义了4类8种基本类型，其中4种整型、2种浮点型、1种布尔型、1种字符型。

• 整型：byte、short、int、long
• 浮点型：float、double
• 布尔型：boolean
• 字符型：char

2.表示整数类型数据的关键字有哪几个？他们各占用几个字节？

（1）表示整数类型数据的关键字有4个，分别是：byte、short、int、long

（2）占用字节数如下：

• byte：1个字节
• short：2个字节
• int：4个字节
• long：8个字节

3.单精度浮点型（float）和双精度浮点型（double）的区别是什么？

单精度浮点型和双精度浮点型表示的都是实数，双精度浮点型数占8个字节，而单精度浮点型数占4个字节，双精度浮点型数的精度是单精度浮点型数精度的2倍。

4.字符型常量与字符串常量的主要区别是什么？

字符型常量是用单引号括起来的单个字符，而字符串常量是用双引号括起来的多个字符，且字符数可以为0个。

5.简述Java语言对定义标识符的规定。

（1）标识符可以有字母、数字、下划线（_）和美元符号（$）等组合而成；

（2）标识符必须以字母、下划线或美元符号开头，不能以数字开头。

同时，应注意Java语言是大小写敏感的语言。例如，class和Class、System和system分别代表不同的标识符，在定义和使用时要特别注意这一点。

用Java语言编程是，经常遵循一下命名习惯（不是强制的）：

• 类名首字母大写；变量名、方法名及对象名的首字母小写；
• 对于所有标识符，其中包含的所有单词都应紧靠在一起，而且中间单词的首字母大写。例如：ThisIsAClassName、thisIsMethodOrFieldName；
• 若定义常量时，则所有字母大写，这样便可标志出他们属于编译期的常数；
• Java包（package）属于一种特殊情况，他们全都是小写字母，即便中间的单词亦是如此。

6.Java语言采用何种编码方案？有何特点？

（1）Java语言中的字符采用的是Unicode字符集编码方案，在内存中占两个字节，是16位如符号的整数，一共有65536个，字符的取值范围为0~65535，表示其在Unicode字符集中的排序位置

（2）Unicode字符表的前128个字符刚好是ASCII表。每个国家的字母表的字母都是UNicode表中的一个字符。由于Java语言的字符类型采用了Unicode这种新的国际标准编码方案，因而便于中文字符和西文字符的处理。

7.什么是强制类型转换？在什么情况下需要用强制类型转换？

（1）数值型数据的类型转换分为自动类型转换（或称隐含类型转换）和强制类型转换两种。把占用比特数较少的数据（简称较短的数据）转换成占用比特数较多的数据（简称较长的数据），都使用自动类型转换，即类型转换由编译系统自动完成，不需要程序做特别的说明。但如果把较长的数据转换成较短的数据时，就要进行强制类型转换，否则就会产生编译错误。

（2）强制类型转换必须在程序中用“(欲转换的数据类型)变量名”形式的语句显性说明将变量名的类型强制转换成什么类型。需要说明的是，指定的变量名及其数据本身将不会因此而改变。

8.自动类型转换的前提是什么？转换时从“短”到“长”的优先级顺序是怎样的？

（1）Java语言会在下列条件同时成立时，自动进行数据类型的转换。

• 转换前的数据类型与转换后的类型兼容；
• 转换后数据类型的表示范围比及转换前数据类型的表示范围大。
  • 条件二说明不同类型的数据进行运算时，需先转换为同一类型，然后进行运算。

（2）转换从“短”到“长”的优先关系为：

byte ----> short ----> char ----> int ----> long ----> float ----> double

9.数字字符串转换为数值型数据时，所使用的方法有哪些？

转换的方法	功能说明
Byte.parseByte(String s)	将数字字符串转换为字节型数据
Short.parseShort(String s)	将数字字符串转换为短整型数据
Integer.parseInt(String s)	将数字字符串转换为整形数据
Long.parseLong(String s)	将数字字符串转换为长整型数据
Float.parseFloat(String s)	将数字字符串转换为浮点型数据
Double.parseDouble(String s)	将数字字符串转换为双精度型数据
Boolean.parseBoolean(String s)	将字符串转换为布尔型数据

10.写出由键盘输入数据的两种基本格式。

（1）数据输入方式1：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class test10 {
    public static void main(String[] args) throws IOException {
        String str;
        BufferedReader buf;
        buf = new BufferedReader(new InputStreamReader(System.in));
        str = buf.readLine();
        System.out.println(str);
    }
}

（2）数据输入方式2：

import java.util.Scanner;

public class test10 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        double num;
        num = scanner.nextDouble();
        System.out.println(num);
    }
}

11.编写程序，从键盘上输入一个浮点数，然后将该浮点数的整数部分输出。

import java.util.Scanner;

public class test11 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        float f = scanner.nextFloat();
        System.out.println((int)f);
    }
}

12.编写程序，从键盘上输入两个整数，然后计算他们相除后得到的结果并输出。

import java.util.Scanner;

public class test12 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int a = scanner.nextInt();
        double b = scanner.nextDouble();
        System.out.println(a/b);
    }
}

13.编写程序，从键盘上输入圆柱体的底半径r和高h，然后计算其体积并输出。

import java.util.Scanner;

public class test13 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        double r = scanner.nextDouble();
        double h = scanner.nextDouble();
        double V = Math.PI * r * r * h;
        System.out.println(V);
    }
}

14.Java语言有哪些算术运算符、关系运算符、逻辑运算符、位运算符和赋值运算符？

（1）算术运算符：

• 二元算术运算符：+ - * / %
• 一元算术运算符：+ - ++ --

（2）关系运算符：> >= <

（3）逻辑运算符：& | ! ^ && ||

（4）运算符：~ & | ^ >> << >>>

（5）赋值运算符：= += -= *= /= %= &= |= ^= >>= <<= >>>=

15.逻辑运算符中的逻辑与、逻辑或和简洁与、简洁活的区别是什么？

简洁运算（&&、||）与非简洁运算（&、|）的区别在于：非简洁运算在必须计算完成运算符左右两个表达式之后，才取结果；简洁运算可能只需计算运算符左边的表达式而不用计算右边的表达式，即对于&&，只要左边的表达式为false，就不用计算右边表达式，则整个表达式为false；对于||，只要左边表达式为true，就不用计算右边表达式，则整个表达式为true。

16.逻辑运算符与位运算符的区别是什么？

位运算符的操作数只能为整型或字符型数据，但逻辑运算符的操作数据为boolean型的量。

17.什么是位运算符的优先级和结合性？

位运算符的优先级决定了表达式中不同运算符执行的先后顺序；结合性决定了并列的多个同级运算符的先后执行顺序。

18.写出下列表达式的值，设x=3，y=17，yn=true。

（1）x+y*x-- 54

（2）-x*y+y -34

（3）x<y&&yn true

（4）x>y||!yn false

（5）y!=++x?x:y 4

（6）y++/--x 8

---

四、流程控制

1.将学生的学习成绩按不同的分数段分为优、良、中、及和不及格五个等级，从键盘上输入一个0~100的成绩，输出相应的等级。要求用switch语句实现。

import java.util.Scanner;

public class test01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int score = scanner.nextInt();
        int tag = score / 10;
        System.out.print("该学生的成绩为： ");
        switch (tag) {
            case 10:
            case 9:
                System.out.println("优");
                break;
            case 8:
                System.out.println("良");
                break;
            case 7:
                System.out.println("中");
                break;
            case 6:
                System.out.println("及");
                break;
            default:
                System.out.println("不及格");
        }
    }
}

2.将学生的学习成绩按如下的分数段评定为四个等级：85_100为A；7084位B；60_69为C；059为D。从键盘上输入一个0~100的成绩，要求用switch语句根据成绩，评定并输出相应的等级。

import java.util.Scanner;

public class test02 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入学生的成绩：");
        int score = scanner.nextInt();
        if (score < 60) {
            System.out.println("D");
            return;
        }
        int tag = score / 5;
        switch (tag) {
            case 20:
            case 19:
            case 18:
            case 17:
                System.out.println("A");
                break;
            case 16:
            case 15:
            case 14:
                System.out.println("B");
                break;
            default:
                System.out.println("C");
        }
    }
}

3.编写一个Java应用程序，从键盘输一个1~100之间的整数，然后判断该数是否既可以被3整除又可以被7整除的数。

import java.util.Scanner;

public class test03 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个1~100之间的整数：");
        int num = scanner.nextInt();
        if (num % 3 == 0 && num % 7 == 0) System.out.println("yes");
        else System.out.println("NO");
    }
}

4.编写一个Java应用程序，在键盘上输入数n，计算并输出1!+2!+...+n!的结果。

import java.util.Scanner;

public class test04 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个整数n：");
        int n = scanner.nextInt();
        if (n == 0) {
            System.out.println(1);
            return;
        }
        int sumTemp = 1;
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sumTemp = sumTemp * i;
            sum = sum + sumTemp;
        }
        System.out.println(sum);
    }
}

5.在键盘上输入数n，编程计算sum=1-1/2!+1/3!-...(-1)^(n-1)*1/n!。

import java.util.Scanner;

public class test05_2 {
    public static void main(String[] args) {
        int n, i = 1;
        double s = 1, sum = 0;
        Scanner buf = new Scanner(System.in);
        do {
            System.out.println("请输入n的值：");
            n = buf.nextInt();
        } while (n <= 0);
        do {
            sum = sum + s;
            i++;
            s = -s / i;
        } while (i <= n);
        System.out.println("sum=" + sum);
    }
}

6.水仙花数是指其个位、十位和百位三个数字的立方和等于这个三位数本身，求出所有的水仙花数。

import java.util.Scanner;

public class test06 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        for (int i = 100; i < 999; i++) {
            int ge = i % 10;
            int shi = i / 10 % 10;
            int bai = i / 100 % 10;
            if (i == ge * ge * ge + shi * shi * shi + bai * bai * bai) System.out.println(i);
        }
    }
}

7.从键盘输入一个整数，判断该数是否是完全数。完全数是指其所有的因数（包括1但不包括其本身）的和等于该数自身的数。例如，28=1+2+4+7+14就是一个完全数。

import java.util.Scanner;

public class test07 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int num = scanner.nextInt();
        int sum = 0;
        for (int i = 1; i < num; i++) {
            if (num % i == 0) {
                sum = sum + i;
            }
        }
        if (sum == num) System.out.println("是完全数");
        else System.out.println("不是完全数");
    }
}

8.计算并输出一个整数各位数字之和。例如：5423的各位数字之和位5+4+2+3。

import java.util.Scanner;

public class test08 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int num = scanner.nextInt();
        int s;
        int sum = 0;
        while (num > 0) {
            s = num % 10;
            sum = sum + s;
            num = num / 10;
        }
        System.out.println(sum);
    }
}

9.从键盘上输入一个浮点数，然后将该浮点数的整数部分和小数部分分别输出。

import java.util.Scanner;

public class test09 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        float f = scanner.nextFloat();
        String s = f + "";
        int index = s.indexOf('.');
        System.out.println("整数部分:" + s.substring(0, index));
        System.out.println("小数部分:" + s.substring(index + 1));
    }
}

10.编程输出如下数字图案。

1 3 6 10 15

2 5 9 14

4 8 13

7 12

11

public class test10 {
    public static void main(String[] args) {
        int i, count, a, c;
        int b = 1;
        for (count = 1; count <= 5; count++) {
            c = count;
            c--;
            a = b + c;
            b = a;
            System.out.print(b + " ");
            for (i = 1 + count; i <= 5; i++) {
                a += i;
                System.out.print(a + " ");
            }
            System.out.print("\n");
        }
    }
}

---

第五章、数组与字符串

1.从键盘输入n个数，输出这些数中大于其平均值的数。

import java.util.Scanner;

public class test01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入数组的长度：");
        int n = scanner.nextInt();
        int[] ints = new int[n];
        System.out.println("请依次输入数组的每个元素：");
        for (int i = 0; i < n; i++) {
            ints[i] = scanner.nextInt();
        }
        int sum = 0;
        for (int i = 0; i < n; i++) {
            sum = sum + ints[i];
        }
        float ave = sum / n;
        StringBuilder sb = new StringBuilder("");
        for (int i = 0; i < n; i++) {
            if (ints[i] > ave) {
                sb = sb.append(ints[i]).append(",");
            }
        }
        System.out.println(sb.substring(0, sb.length() - 1));
    }
}

2.从键盘输入n个数，求这n个数中的最大数与最小数并输出。

import java.util.Scanner;

public class test02_2 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一组数，中间用空格隔开：");
        String[] strings = scanner.nextLine().split(" ");
        int n = strings.length;
        int[] ints = new int[n];
        for (int i = 0; i < n; i++) {
            ints[i] = Integer.parseInt(strings[i]);
        }
        int MIN = ints[0];
        int MAX = ints[0];
        for (int i = 0; i < n; i++) {
            if (MIN > ints[i]) {
                MIN = ints[i];
            }
            if (MAX < ints[i]) {
                MAX = ints[i];
            }
        }
        System.out.println("最小数为：" + MIN);
        System.out.println("最大数为：" + MAX);
    }
}

3.求一个3阶方阵的对角线上各元素之和。

import java.util.Scanner;

public class test03 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int[][] ints = new int[3][3];
        System.out.println("请输入一个三阶方阵：");
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                ints[i][j] = scanner.nextInt();
            }
        }
        int sum = 0;
        for (int i = 0; i < 3; i++) {
            sum = sum + ints[i][i];
        }
        System.out.println("对角线各元素之和为：" + sum);
    }
}

4.找出4×5矩阵中值最小和最大的元素，并分别输出其值及所在的行号和列号。

import java.util.Scanner;

public class test04 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int[][] ints = new int[3][3];
        System.out.println("请输入一个4×5矩阵：");
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 5; j++) {
                ints[i][j] = scanner.nextInt();
            }
        }
        int MIN = ints[0][0];
        int MAX = ints[0][0];
        int row1 = 0, col1 = 0, row2 = 0, col2 = 0;
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 5; j++) {
                if (MIN > ints[i][j]) {
                    MIN = ints[i][j];
                    row1 = i;
                    col1 = j;
                }
                if (MAX < ints[i][j]) {
                    MAX = ints[i][j];
                    row2 = i;
                    col2 = j;
                }
            }
        }
        System.out.println("矩阵元素最小值：" + MIN + "，行号为：" + row1 + "，列号为：" + col1);
        System.out.println("矩阵元素最大值：" + MAX + "，行号为：" + row2 + "，列号为：" + col2);
    }

5.产生0~100的8个随机整数，并利用冒泡排序法将其升序后输出（冒泡排序算法：每次进行相邻两数的比较，若次序不对，则交换两数的次序）。

import java.util.Arrays;

public class test05 {
    public static void main(String[] args) {
        int[] ints = new int[8];
        for (int i = 0; i < 8; i++) {
            ints[i] = (int)(100 * Math.random());
        }
        System.out.println("产生的随机数为：");
        System.out.println(Arrays.toString(ints));
        int temp;
        for (int i = 0; i < 8; i++) {
            for (int j = 0; j < 8; j++) {
                if (ints[i] < ints[j]) {
                    temp = ints[i];
                    ints[i] = ints[j];
                    ints[j] = temp;
                }
            }
        }
        System.out.println("冒泡升序之后的随机数为：");
        System.out.println(Arrays.toString(ints));
    }
}

6.有15个红球和15个绿球排成一圈，从第1个球开始数，当数到第13个球时就拿出此球，然后再从下一个球开始数，当再数到第13个球时又取出此球，如此循环进行，直到谨慎15个球为止，问怎样排才能使每次去除的球都是红球？

public class test06 {
    public static void main(String[] args) {
        int[] a = new int[31];
        int k = 1;
        for (int i = 1; i <= 15; i++) {
            for (int j = 1; j <= 13; j++, k++) {
                if (k > 30) k = 1;
                while (a[k] != 0) if (++k > 30) k = 1;
            }
            a[k - 1] = 1;
        }
        for (int i = 0; i <= 30; i++) System.out.print(" " + a[i]);
        System.out.println("\n 1：表示红球  0：表示绿球");
    }
}

7.编写Java应用程序，比较命令行中给出的两个字符串是否相等，并输出比较的结果。

public class test07 {
    public static void main(String[] args) {
        boolean result = false;
        if (args.length <= 1) System.out.println("命令行中数据的个数不对");
        else if (args[0].equals(args[1])) {
            result = true;
            System.out.println("命令行给出的两个字符串比较结果是：" + result);
        } else {
            System.out.println("命令行给出的两个字符串比较结果是：" + result);
        }
    }
}

8.从键盘上输入一个字符串和子串开始的位置与长度，截取该字符串的子串并输出。

import java.util.Scanner;

public class test08 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str = scanner.nextLine();
        System.out.println("请输入子串开始的位置：");
        int beginIndex = scanner.nextInt();
        System.out.println("请输入子串的长度：");
        int length = scanner.nextInt();
        int endIndex = beginIndex + length;
        if (beginIndex -1 +length > str.length()) {
            System.out.println("数据输入有误！");
            return;
        }
        String sonStr = str.substring(beginIndex - 1, endIndex - 1);
        System.out.println("截取的子串为：" + sonStr);
    }
}

9.从键盘上输入一个字符串和一个字符，从该字符串中删除给定的字符。

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

public class test09 {
    public static void main(String[] args) throws IOException {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str = scanner.nextLine();
        System.out.println("请输入一个字符：");
//        char c = scanner.next().charAt(0);
        char c = (char)System.in.read();
        int len = str.length();
        String newStr = "";
        for (int i = 0; i < len; i++) {
            if (str.charAt(i) != c) {
                newStr = newStr + str.charAt(i);
            }
        }
        System.out.println("新字符串为：" + newStr);
    }
}

10.编程统计用户从键盘输入的字符串所包含的字母、数字和其他字符的个数。

import java.util.Scanner;

public class test10 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String str = scanner.nextLine();
        int len = str.length();
        int letter = 0;
        int character = 0;
        int other = 0;
        for (int i = 0; i < len; i++) {
            if (str.charAt(i) >= 'a' && str.charAt(i) <= 'z' || str.charAt(i) >= 'A' && str.charAt(i) <= 'Z') {
                letter++;
            } else if (str.charAt(i) >= '0' && str.charAt(i) <= '9') {
                character++;
            } else {
                other++;
            }
        }
        System.out.println("字母字符个数为：" + letter);
        System.out.println("数字字符个数为：" + character);
        System.out.println("其他字符个数为：" + other);
    }
}

11.将用户从键盘输入的每行数据都显示输出，知道输入“exit"字符串，程序运行结束。

public class test11 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String str;
        System.out.println("请输入字符串，输入 exit 退出：");
        do {
            str = scanner.nextLine();
            System.out.println(str);
        } while (!str.equals("exit"));
    }
}

第五章面试题：

1.String、StringBuffer与StringBuilder之间区别、以及使用场景？

（1）解释：

• String：字符串常量

  • String类被final修饰，在Java中，被final修饰的类是不允许被继承的，并且该类中的成员方法都默认为final方法
  • String类底层是通过 char[] 数组来保存字符串
  • 对String对象的任何改变都不影响到原对象，相关的任何change操作都会生成新的对象

• StringBuffer：字符创变量

• StringBuilder：字符创变量

三者在执行速度方面的比较：StringBuilder > StringBuffer > String

why？

String s = "abc";
s = s + "def";			// 实际上没有改变变量s
System.out.print(s); // result : abcdef

例如上面这段代码，我们明明就是改变了String型的变量 s 的，为什么说是没有改变呢? 其实这是一种障眼法。JVM是这样解析这段代码的：首先创建对象s，赋予一个abc，然后再创建一个新的对象 s 用来执行第二行代码，也就是说我们之前对象s并没有变化（new String("abc") 开辟的内存空间地址并没有变化），所以我们说String类型是不可改变的对象了，由于这种机制，每当用String操作字符串时，实际上是在不断的创建新的对象，而原来的对象就会变为垃圾被GC回收掉，可想而知这样执行效率会非常低。

而StringBuffer与StringBuilder就不一样了，他们是字符串变量，是可改变的对象，每当我们用它们对字符串做操作时，实际上是在一个对象上操作的，这样就不会像String一样创建一些而外的对象进行操作了，当然速度就快了。

（2）相同点：

• jdk的实现中StringBuffer与StringBuilder都继承自AbstractStringBuilder。
  • AbstractStringBuilder的实现原理：我们使用StringBuffer等无非就是为了提高java中字符串连接的效率，因为直接使用 + 进行字符串连接的话，jvm会创建多个String对象，因此造成一定的开销。
  • AbstractStringBuilder中采用一个 char[] 数组来保存需要append的字符串， char[] 数组有一个初始大小，当append的字符串长度超过当前 char[] 数组容量时，则对 char[] 数组进行动态扩展，一般是申请当前2倍的内存空间。
• StringBuffer 与 StringBuilder 中的方法和功能完全是等价的，只是StringBuffer 中的方法大都采用了 synchronized 关键字进行修饰，因此是线程安全的，而 StringBuilder 没有这个修饰，可以被认为是线程不安全的。

（3）不同点：

• StringBuffer 线程安全；StringBuilder 线程不安全。
• StringBuffer 始于 JDK 1.0，StringBuilder 始于 JDK 1.5，从 JDK 1.5 开始，带有字符串变量的连接操作（+），JVM 内部采用的是StringBuilder 来实现的，而之前这个操作是采用 StringBuffer 实现的。

（4）使用场景：

• 如果要操作少量的数据用 = String

• 单线程操作字符串缓冲区 下操作大量数据 = StringBuilder

• 多线程操作字符串缓冲区 下操作大量数据 = StringBuffer

2.Java创建一个数组，在内存中的执行情况？

Java中，使用关键字new创建数组对象。格式为：new 数组元素的类型[数组元素的个数]

---

第六章、

1.类与对象的区别是什么？

在面向对象的程序设计语言里，类就是把事物的数据与相关功能封装在一起，形成一种特殊的数据结构，用以表达真实事物的一种抽象。类是由成员对象与成员方法封装而成的，其中，成员变量表示类的属性，成员方法表示类的行为。而对象则是该类事物具体的个体，也称为实例。所以说类描述了对象的属性和行为。

我的理解：

类是同类型事物的统称，是抽象的，该类事物具有共同属性。比如：水果，具有颜色属性、重量、价格属性。具有解渴、补充营养等行为。对象是类的实体，是具体的。比如：苹果、橘子、西瓜等。

2.如何定义一个类？类的结构是怎么样的？

（1）定义类要使用关键字class；

（2）类的内部既可以定于成员变量，也可以定义成员方法。其一般的语法结构如下：

[类修饰符] class 类名称 {
    [修饰符] 数据类型 成员变量名称;
    	...
    [修饰符] 返回值的数据类型 方法名(参数1, 参数2, 参数3, ...) {
        语句序列；
        return [表达式];
    } 
    	...
}

3.定义一个类时所使用的修饰符有哪几个？每个修饰符的作用是什么？是否可以混用？

（1）类修饰符分为公共访问修饰符、抽象类说明符、最终类说明符和缺省访问控制符四种。

（2）每个修饰符的作用：

• 公共访问控制符：public，表示讲一个类声明为公共类。
• 抽象类说明符：abstract，表示将一个类声明为抽象类。
• 最终类说明符：final，表示将一个类生命为最终类。
• 缺省访问控制符：表示只有在相同包中的对象才能访问该类。

（3）有些修饰符可混用，但abstract和final相互对立，所以不能同时应用在一个类的定义中。

4.成员变量的修饰符有哪些？各修饰符的作用是什么？是否可以混用？

（1）成员变量的修饰符有访问控制符、静态修饰符、最终修饰符、过渡修饰符和易失修饰符等。

（2）每个修饰符的作用：

• 访问控制符，四个：

  • public：公共访问控制符，指定该变量为公共的；
  • private：私有访问控制符，指定该便令只允许自己类的方法访问，其他任何类（包括子类）中的方法均不能访问次变量；
  • protected：保护访问控制符，指定该变量只可以被它自己的累及其子类或同一包中的其他类访问；
  • 缺省：缺省访问控制符，表示在该成员变量只能被同一个包中的类所访问，而其他包中的类不能访问该成员变量。

• 静态修饰符：static，指定该变量是隶属于类的变量，可被所有对象共享。

• 最终修饰符：final，指定此变量的值不能改变。

• 过度修饰符：transient，指定该变量是一个系统保留、暂无特别作用的临时性变量。

• 易失修饰符：volatile，指定该变量可以同时被几个线程控制和修改。

（3）一个成员变量可以同时被两个以上的修饰符同时修饰，但有些修饰符是不能同时定义在一起的。

5.成员方法的修饰符有哪些？各修饰符的功能是什么？是否可以混用？

（1）成员方法的修饰符包括访问控制修饰符、静态修饰符、抽象修饰符、最终修饰符、同步修饰符和本地修饰符等。

（2）各修饰符的作用：

• 访问控制修饰符，四个：
  • public：公共访问控制符，指定该方法为公共的；
  • private：私有访问控制符，指定该方法只允许自己类的方法访问，其他任何类（包括子类）中的方法均不能访问此方法；
  • protected：保护访问控制符，指定该方法只可以被它的类及其子类或同一包中的其他类访问；
  • 缺省：缺省访问控制符，表示该成员方法只能被同一个包中的类所调用，而其他包中的类不能访问该成员方法。
• 静态修饰符：static，指定该方法是隶属于类的方法，可以直接使用类型调用该方法。
• 抽象修饰符：abstract，指定该方法只声明方法头，而没有方法体，抽象方法需在子类中被覆盖并实现。
• 最终修饰符：final，指定该方法不能被覆盖。
• 同步修饰符：synchronized，在多线程程序中，该修饰符对于同步资源加锁。
• 本地修饰符：native，指定此方法的方法体是用其他语言（如C）在程序外部编写的。

6.成员变量与局部变量的区别有哪些？

类的成员变量和方法中的局部变量的区别主要有如下几个方面：

• 从语法形式上看，成员变量属于类的，而局部变量是在方法中定义的变量或是方法的参数。成员变量可以被public、private、static等修饰符所修饰，而局部变量则不能被访问控制符及static所修饰；成员变量和局部变量都可以被final所修饰；
• 从变量在内存中的存储方式上看，成员变量是对象的一部分，而对象是存在于堆内存的，而局部变量是存在于栈内村的；
• 从变量在内存中的生存时间上看，成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而产生，随着方法调用的结束而自动消失；
• 成员变量如果没有被赋初值，则会自动以类型的默认值赋值；而局部变量则不会自动赋值，必须显示的赋值后才能使用。

7.创建一个对象使用什么运算符？对象实体和对象引用有何不同？

（1）声明对象时使用new运算符创建对象。

（2）创建的对象实体是存放在堆内存中的，而对象的引用变量是存放在栈内存中的，引用变量中存放的是对象在堆内存中的首地址。

8.对象的成员如何表示？

对象成员主要是通过对象名引用的。其格式如下：

对象名.对象成员

9.在成员变量或成员方法前加上关键字this表示什么含义？

在成员变量或成员方法前加上关键字this，表示强调对象本身的成员，即此时this表示调用此成员的对象。

10.什么是方法的返回值？返回值在类的方法里的作用是什么？

方法的返回值是指在方法体中进行的计算并能回传的值，其作用就是将其计算结果传回给调用该方法的语句。

11.在方法调用中，使用对象作为参数进行传递时，是“传值”还是“传址”？对象作为参数起到什么作用？

在方法调用中，使用对象作为参数进行传递时，即当参数是引用型的变量时，则是传址方式调用。对象作为参数传递给方法后，方法实际是通过引用变量对存放在堆中的对象进行操作的。所以其引用变量的值不会改变。

12.什么叫匿名对象？一般在什么情况下使用匿名对象？

（1）当一个对象被创建之后，在调用该对象的方法时，也可以不定义对象的引用变量，而直接调用这个对象的方法，这样的对象叫做匿名对象。

（2）使用匿名对象通常有如下两种情况：

• 如果对一个对象只需进行一次方法调用，那么就可以使用匿名对象；
• 将匿名对象作为实参传递给一个方法调用。

13.以m行n列二维数组为参数进行方法调用，分别计算二维数组各列元素之和，返回并输出所计算的结果。

public class SumNum {
    public int[] colNum(int[][] array) {
        int[] ints = new int[array[0].length];
        for (int i = 0; i < array[0].length; i++) {
            for (int j = 0; j < array.length; j++) {
                ints[i] = ints[i] + array[j][i];
            }
        }
        return ints;
    }
}

import java.util.Scanner;

public class test13 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入二维数组的行数m:");
        int m = scanner.nextInt();
        System.out.println("请输入二维数组的列数n:");
        int n = scanner.nextInt();
        System.out.println("请输入一个" + m + "*" + n + "的二维数组：");

        int[][] ints = new int[m][n];
        int[] col;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                ints[i][j] = scanner.nextInt();
            }
        }
        SumNum sumNum = new SumNum();
        col = sumNum.colNum(ints);
        for (int i = 0; i < col.length; i++) {
            System.out.println("第" + (i + 1) + "列数的和 = " + col[i]);
        }
    }
}

---

标签：Java,Scanner,int,System,复习题,程序设计,public,out
From： https://www.cnblogs.com/wqr2023/p/17091078.html