JAVA从键盘输入一个整数判断是否为素数代码

JA V A编程实例大全及详解答案(50例)【程序1】题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？//这是一个菲波拉契数列问题public class lianxi01 {public static void main(String[] args) {System.out.println("第1个月的兔子对数: 1");System.out.println("第2个月的兔子对数: 1");int f1 = 1, f2 = 1, f, M=24;for(int i=3; i<=M; i++) {f = f2;f2 = f1 + f2;f1 = f;System.out.println("第" + i +"个月的兔子对数: "+f2);}}}【程序2】题目：判断101-200之间有多少个素数，并输出所有素数。

程序分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除，则表明此数不是素数，反之是素数。

public class lianxi02 {public static void main(String[] args) {int count = 0;for(int i=101; i<200; i+=2) {boolean b = false;for(int j=2; j<=Math.sqrt(i); j++){if(i % j == 0) { b = false; break; }else { b = true; }}if(b == true) {count ++;System.out.println(i );}}System.out.println( "素数个数是: " + count);}}【程序3】题目：打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。

素数java代码素数是指只能被1和自己整除的正整数，像2、3、5、7、11等都是素数。

在计算机编程中，判断一个数是否为素数是一项基本的算法。

本文将从Java语言的角度入手，介绍如何编写素数判断的代码，包括两种方法：暴力枚举法和筛法。

一、暴力枚举法暴力枚举法是一种较为简单粗暴的方法，通过一个循环枚举所有可能的因子，判断是否能被整除。

其Java代码如下：public static boolean isPrime(int n) { if (n < 2) { //小于2的数均不是素数 return false; } for (int i = 2; i <= Math.sqrt(n); i++) { if (n % i == 0) { //能被整除，即不是素数 return false; } } return true; //不被整除，即是素数 }首先判断输入的数n是否小于2，如果n小于2，则直接返回false，因为小于2的数均不是素数。

然后从2开始循环到n的平方根，检查是否能被整除，如果能则返回false，否则继续循环，最后返回true表示是素数。

这种方法的时间复杂度为O(√n)，因为最多需要枚举n的平方根次数。

在较小的n值的情况下，这种方法较为有效，但当n较大时，效率低下。

二、筛法筛法是用于快速筛选素数的一种高效算法，它的原理是从小到大依次枚举素数，将其倍数标记为合数。

例如，当枚举到2时，将4、6、8、10等标记为合数；当枚举到3时，将6、9、12等标记为合数。

由于合数被标记多次，所以这种方法比暴力枚举法更快。

筛法主要有两种：埃氏筛法和欧拉筛法。

下面分别介绍它们的Java代码实现。

2.1 埃氏筛法埃氏筛法是一种简单直接的筛法，其Java代码如下：public static int[] getPrimes(int n) { if (n < 2) { //小于2的数没有素数 return new int[0]; } boolean[] isPrime = new boolean[n + 1]; //初始化所有数为素数 for (int i = 2; i <= n; i++) { isPrime[i] = true; } for (int i = 2; i <= Math.sqrt(n); i++) { if (isPrime[i]) { //当前数为素数 for (int j = i * i; j <= n; j += i) { //枚举它的倍数isPrime[j] = false; //标记为合数 } } } List<Integer> list = new ArrayList<>(); for (int i = 2; i <= n; i++) { if (isPrime[i]) { //将素数添加到列表中 list.add(i); } } int[] primes = new int[list.size()]; //将列表转成数组 for (int i = 0; i < primes.length; i++){ primes[i] = list.get(i); } return primes; }首先判断输入的n是否小于2，如果n小于2，则返回一个长度为0的素数数组。

【试题1】任务一：输入某年某月某日，判断这一天是这一年的第几天。

例如，2001年3月5日是这一年的第64天。

要求：使用分支结构语句实现。

任务二：输出阶梯形式的9*9口诀表，如图1.1所示。

图1.1阶梯形式的9*9口诀表要求：使用循环结构语句实现。

任务三：编程实现判断一个整数是否为“水仙花数”。

所谓“水仙花数”是指一个三位的整数，其各位数字立方和等于该数本身。

例如：153是一个“水仙花数”，因为153=13＋53＋33。

要求：用带有一个输入参数的方法或函数实现，返回值类型为布尔类型。

【试题2】任务一：已知某字符串数组，包含如下初始数据：a1,a2,a3,a4,a5 已知另一字符串数组,包含如下初始数据:b1,b2,b3,b4,b5,做程序将该两个数组的每一对应项数据相加存入另外一个数组，并输出。

输出结果为：a1b1,a2b2,a3b3,a4b4,a5b5。

要求：●定义2个数组,用于存储初始数据。

定义另外一个数组，用于输出结果。

●做循环将两个初始数组的对应项值相加，结果存入另外一个数组。

（不要边加边输出）●做循环将结果数组中的值按顺序输出。

任务二：写出一个函数：将某已知数组的奇数项组合成一个新的数组。

在主函数中调用该函数，并循环输出新数组的内容。

要求：●主函数定义一个初始化的数组，该数组中的值为：1,2,3,4,5,6,7,8,9,10,11●写出一个函数，该函数的函数名为：OddArray,函数需要的参数个数1个,参数数据类型为数组。

函数的返回值为数组。

函数体实现功能：将参数数组中的奇数项存入另外一个数组，并返回该数组到主函数中。

●在主函数定义一个新的数组，用于取得函数OddArray的返回值，然后循环显示数组的值。

（显示出来1,3,5,7,9,11）任务三：现有学生类，有2个属性：学号，姓名。

有大学生类继承此学生类，新增一个属性：专业。

写出学生类，以及大学生类。

实例化大学类为一个对象并给大学生类的所有属性赋值。

java输出1~100之间的全部素数的5种⽅式总结⽬录需求：输出1~100的所有素数分析java输出素数找出素数规范输出需求：输出1~100的所有素数分析1.素数：判断条件1：只能被1和本⾝整除的称为素数；判断条件2：在区间（1，x/2）中找不到能整除素数x的整数；判断条件3：在区间（1，sqrt(x)）中找不到能整除素数x的整数；2.⽅法：很多，但不外是循环嵌套外加条件语句；class PrintSuShu {public static void main(String[] args) {//⽅法⼀：根据素数的定义来遍历检查//外层循环遍历被除数i(因为1既不是素数也不是和数，所以直接从2开始遍历)for (int i = 2; i <= 100; i++) {//定义⼀个逻辑值，初值为trueboolean flag = true;//内层遍历除数jfor (int j = 2; j < i; j++) {//判断是否存在j能整除i，若存在，则更改flag的值并跳出循环if (0 == i % j) {flag = false;break;}}//根据flag的值判断是否输出iif (flag) {System.out.print(i + " ");}}System.out.println('\n' + "---------------------------");//⽅法⼆：根据判断条件2进⾏遍历检查，减少遍历次数//外层循环遍历被除数i(因为1既不是素数也不是和数，所以直接从2开始遍历)for (int i = 2; i <= 100; i++) {//定义⼀个逻辑值flag，初始值为trueboolean flag = true;//内层循环遍历除数j(注意：此处若不取边界，则当i=4时，j=2会因为⼩于i/2=2⽽直接跳出内循环)for (int j = 2; j <= (i / 2); j++) {//判断是否存在除数j能整除i，若存在，则修改flag的值并跳出循环if (0 == i % j) {flag = false;break;}}//根据flag的值判断是否输出iif (flag) {System.out.print(i + " ");}}System.out.println('\n' + "---------------------------");//⽅法三：根据判断条件3进⾏遍历检查，减少遍历次数//外层循环遍历被除数i(因为1既不是素数也不是和数，所以直接从2开始遍历)for (int i = 2; i <= 100; i++) {//定义⼀个逻辑值flag，初始值为trueboolean flag = true;//内层循环遍历除数j(注意：此处若不取边界，则当i=4时，j=2会因为⼩于sqrt(i)=2⽽直接跳出内循环)//再思考⼀下若i=25时呢？若不取边界还有那些不是素数的数会输出呢？for (int j = 2; j <= Math.sqrt(i); j++) {//判断是否存在除数j能整除i，若存在，则修改flag的值并跳出循环if (0 == i % j) {flag = false;break;}}//根据flag的值判断是否输出iif (flag) {System.out.print(i + " ");}}System.out.println('\n' + "---------------------------");/*⽅法四：在⽅法三的前提上优化，优化基础是除2外的所有偶数均不是素数，*(i+=2)只遍历奇数，减少外层遍历次数；同理，由于奇数是不能被偶数整除的，*(j+=2)只遍历奇数，减少内层遍历次数*/System.out.print("2 ");//外层循环遍历被除数i(因为1既不是素数也不是和数，所以直接从2开始遍历)for (int i = 3; i <= 100; i += 2) {//定义⼀个逻辑值flag，初始值为trueboolean flag = true;//内层循环遍历除数j(注意：此处若不取边界，则当i=4时，j=2会因为⼩于sqrt(i)=2⽽直接跳出内循环)//再思考⼀下若i=25时呢？若不取边界还有那些不是素数的数会输出呢？for (int j = 3; j <= Math.sqrt(i); j += 2) {//判断是否存在除数j能整除i，若存在，则修改flag的值并跳出循环if (0 == i % j) {flag = false;break;}}//根据flag的值判断是否输出iif (flag) {System.out.print(i + " ");}}System.out.println('\n' + "---------------------------");//联想⼀下，能被2整除（偶数）的直接剔除，同样的道理，能被3or5整除的剔除掉会不会让外层循环的次数更少呢？//此处才到100，若是1000呢？10000呢？//定义⼀个数组，由于剔除了偶数，故数组长度不会超过总个数的⼀半int[] arr = new int[500];int count = 0;for (int i = 6; i <= 1000; i++) {boolean flag = true;if (0 == i % 2 || 0 == i % 3 || 0 == i % 5) {flag = false;}if (flag) {arr[count] = i;count++;}}System.out.println("6~1000中剔除能被2or3or5整除的数后还剩" + count + "个");System.out.println("1~1000中所有素数为：");System.out.print("2" + "\t");System.out.print("3" + "\t");System.out.print("5" + "\t");count = 0;for (int i = 0; i < 500; i++) {boolean flag = true;if (0 == arr[i]) {break;}for (int j = 7; j <= Math.sqrt(arr[i]); j += 2) {if (0 == (arr[i]) % j) {flag = false;break;}}if (flag) {System.out.print((arr[i]) + "\t");count++;}}System.out.println("\n" + "---------------------");System.out.println("\n" + "其中6~1000中剔除能被2or3or5整除的数中还是素数的有" + count + "个");}}java输出素数java输出1,000,000之内的所有素数找出素数for(n=3;n<=1000000;) {for(i=2;i<n;i++) {if(n%i= =0) break;if(i= =n-1) {su[count]=n;count++;｝}n+=2;}加⼆是因为从3开始奇数有可能是素数，第⼀个循环遍历1000000个数，第⼆个循环看它是不是素数。

课堂作业模块1 Java编程逻辑【第1课】【作业1】编写一个Java程序，在控制台上输出如下两行信息：Hello，World！Hello，Java！考核点1：了解一个Java程序的启动位置（即程序入口）。

考核点2：掌握基本输出语句：System.out.println(字符串)【第2课】【作业1】从键盘输入3个整数a、b、c，计算a+b*c的结果后输出，验证计算结果是否遵循运算符的优先级顺序。

考核点1：使用Scanner类获取键盘输入。

考核点2：基本运算符及其优先级顺序。

【作业2】从键盘输入1个实数r，计算以r为半径的圆的面积并输出结果，要求将π定义为符号常量。

考核点：符号常量的基本用法。

【第3课】【作业1】从键盘输入3个整数，比较大小后输出最大者。

考核点：if-else语句的运用。

【作业2】从键盘输入一个3位数，判断其是否为水仙花数。

所谓“水仙花数”是指一个三位整数，其各位数字立方和等于该数本身。

例如：153=13+53+33,所以153是一个水仙花数。

考核点：基本数学运算符和逻辑运算符的用法。

【第4课】【作业1】从键盘输入3个整数，比较大小后按由小到大的顺序输出。

考核点：if-else语句嵌套运用。

【作业2】从键盘输入一个年份和一个月份，输出此月份有多少天（考虑闰二月的情况）。

考核点：使用switch-case多分支语句。

【第5课】【作业1】从键盘输入一个正整数，判断其是否为素数。

素数指只有1和它本身两个因子的整数。

考核点：基本循环语句的用法。

【作业2】输出100-999之间的全部水仙花数。

考核点：基本循环语句的用法。

【作业3】从键盘输入一个正整数，判断并输出该正整数是几位数。

考核点1：基本循环语句的用法。

考核点2：分离一个整数各个位数字的方法。

【第6课】【作业1】编写一个Java程序，输出如下图案，图案的行数由键盘输入。

（1）观察图案中行、列及星星个数之间的关系。

（2）扩展练习，输出如下图案，图案的行数由键盘输入。

（完整版）java程序填空题一、程序填空题（每空3分，共30分）1.以下程序要求从键盘输入一个整数，判别该整数为几位数，并输出结果，请将下面的程序填写完整。

public class Blank1 {public static void main(String[] args) throws IOException { Scanner sc=new Scanner( （1） );int count=0,t;int x=sc.nextInt();sc.close();t=x;while(t!=0){count++;（2） ;}System.out.println(x+"是"+count+"位数。

");}}答案：（1）System.in（2）t=t/102.在下面的程序中使用方法重载分别实现了两个和三个整数的相加，请将下面的程序填写完整。

class AddOver{public （3）{return a+b;}public int add( int a, int b, int c ){return a+b+c ;}}public class Blank2{public static void main(String[] args){AddOver a= （4） ;System.out.println(a.add(1,2));System.out.println(a.add(1,2,3));}}答案：（3）int add(int a,int b)（4）new AddOver()3. 构造一个类来描述一个点，该类的构成包括点的x和y两个坐标，以及一些对点进行的操作，包括：取得点的坐标值，利用另一个点对当前点的坐标进行赋值，请将下面的程序填写完整。

class Point{int x,y;public（5） (int x, int y){this.x=x; this.y=y;}public Point getPoint(){Point temp = new Point(0,0);temp.x=x; temp.y=y;return （6）;}public void setPoint( （7） ){this.x=s.x; this.y=s.y;}}public class Blank3 {public static void main(String[] args){Point a = new Point(3,4);Point b = new Point(0,0);b=a.getPoint();Point c = new Point(0,0);c.setPoint(b);}}答案：（5）Point（6）temp（7）Point s4. 下面的程序完成从D:\Hello.txt中读取文本并显示在屏幕上，请将下面的程序填写完整。

20个java案例以下是20个Java案例，涵盖了不同的主题和功能。

每个案例都有一个简要的描述和示例代码。

1. 计算两个数的和。

描述，编写一个程序，计算两个整数的和并输出结果。

示例代码：java.int num1 = 10;int num2 = 5;int sum = num1 + num2;System.out.println("两个数的和为，" + sum);2. 判断一个数是否为偶数。

描述，编写一个程序，判断一个整数是否为偶数，并输出结果。

示例代码：java.int num = 6;if (num % 2 == 0) {。

System.out.println(num + "是偶数。

");} else {。

System.out.println(num + "不是偶数。

");}。

3. 求一个数的阶乘。

描述，编写一个程序，计算一个正整数的阶乘，并输出结果。

示例代码：java.int num = 5;int factorial = 1;for (int i = 1; i <= num; i++) {。

factorial = i;}。

System.out.println(num + "的阶乘为，" + factorial);4. 判断一个字符串是否为回文字符串。

描述，编写一个程序，判断一个字符串是否为回文字符串，并输出结果。

示例代码：java.String str = "level";boolean isPalindrome = true;for (int i = 0; i < str.length() / 2; i++) {。

if (str.charAt(i) != str.charAt(str.length() 1 i)) {。

isPalindrome = false;break;}。

JAVA程序设计实验实验１ JAVA基础一、实验目的1.掌握JA V A语言的各种数据类型2.熟悉运算符和表达式。

3.学会编写简单程序二、实验环境硬件：计算机软件：操作系统：windows98以上或LINUX、JDK 1.2以上三、实验内容：下面是一个简单的JA V A程序，将多种类型变量通过各种运算符组成不同的表达式，并将运算结果赋值给同类型的变量，使用println()方法输出各变量的值。

Public class ExampleTest(){Public static void main(String args[]){Int no=(11+20)*3/5; //A行System.out.println(“no=”+no);no++; //B行System.out.println(“no=”+no);Boolean bool=false; //C行bool=true&!bool; //D行System.out.println(“bool=”+bool);Byte bV alue=0x10; //E行System.out.println(“bV alue=”+bV alue);Bool=(no>bV alue); //F行System.out.println(“bool=”+bool);}}四、实验的主要步骤1．用edit录入以上程序内容并保存，注意文件名。

2．用javac.exe命令编译刚保存的JA V A文件。

3．如果编译通不过，用edit打开源代码进行修改。

重复第2步和第3步至到编译通过。

4．用java.exe运行编译生成的类文件。

5．查看运行结果。

实验２ JAVA流程控制一、实验目的1．掌握条件语句的使用。

2．熟悉循环语句的使用。

二、实验环境硬件：计算机软件：操作系统：windows98以上或LINUX、JDK 1.2以上。

三、实验内容1．求a+aa+aaa+…+a..a (n个)的和，其中a为1－9之间的整数。

第一章java程序设计概述一、单选1. 下列说法正确的是（）A. 当运行javac 命令对一个java源程序（.java文件）进行编译时，不必写出该源文件的扩展名.java。

B. 当用java命令解析执行一个class文件时，必须写出该文件的完整扩展名，包括扩展名.class。

C. 当运行javac 命令对一个java源程序（.java文件）进行编译时，必须写出该源文件的完整文件名，包括扩展名.java。

D. 无论是运行javac 还是 java命令，后面的源文件都必须给出文件的扩展名。

2. main方法是Java Application程序执行的入口点，关于main方法的方法头以下哪项是合法的（）A.public static void main（）B. public static void main（String[ ] args）B.public static int main（String[ ] args） D. public void main（String[] args）3. 解释执行和编译一个Java应用程序应分别采用的命令是（）A. java 和 javacB. javac 和java4. 下列不属于Java语言特点的是（）A. 动态性B. 多线程C. 多重继承D. 可移植性5. 编译Java Application 源程序文件将产生相应的字节码文件，这些字节码文件的扩展名为( )A. .javaB. .classC. .htmlD. .exe二、判断题1. 后缀名是 .java的文件是Java的类文件。

2. 命令java 与 javac 的实现效果是相同的。

三、填空1. Java程序可分为（）和（）两大类。

2. 开发与运行Java程序需要经过的三个主要步骤为( )、( )和( )。

3. 如果一个Java源程序文件中定义有4个类，则使用Sun公司的JDK编译器javac编译该源程序文件将产生（）个文件名与类名相同而扩展名为（）的字节码文件。

【程序1】题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？1.程序分析：兔子的规律为数列1,1,2,3,5,8,13,21....【程序2】题目：判断101-200之间有多少个素数，并输出所有素数。

1.程序分析：判断素数的方法：用一个数分别去除2到sqrt(这个数)，如果能被整除，则表明此数不是素数，反之是素数。

【程序3】题目：打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。

例如：153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方。

1.程序分析：利用for循环控制100-999个数，每个数分解出个位，十位，百位。

【程序4】题目：将一个正整数分解质因数。

例如：输入90,打印出90=2*3*3*5。

程序分析：对n进行分解质因数，应先找到一个最小的质数k，然后按下述步骤完成：(1)如果这个质数恰等于n，则说明分解质因数的过程已经结束，打印出即可。

(2)如果n <> k，但n能被k整除，则应打印出k的值，并用n除以k的商,作为新的正整数你n,重复执行第一步。

(3)如果n不能被k整除，则用k+1作为k的值,重复执行第一步。

【程序5】题目：利用条件运算符的嵌套来完成此题：学习成绩> =90分的同学用A表示，60-89分之间的用B表示，60分以下的用C表示。

1.程序分析：(a> b)?a:b这是条件运算符的基本例子。

【程序6】题目：输入两个正整数m和n，求其最大公约数和最小公倍数。

1.程序分析：利用辗除法。

【程序7】题目：输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。

1.程序分析：利用while语句,条件为输入的字符不为'\n '.【程序8】题目：求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字。

java如何判断⼀个数是否是素数（质数）⽬录java判断⼀个数是否是素数(质数)质数（prime number）⼜称素数，有⽆限个思路java 求1-100之间的质数质数定义：1、质数实例⼀2、质数实例⼆3、质数实例三4、质数实例四5、质数实例五6、质数实例六java判断⼀个数是否是素数(质数)质数（prime number）⼜称素数，有⽆限个质数定义为在⼤于1的⾃然数中，除了1和它本⾝以外不再有其他因数，这样的数称为质数。

import java.util.Scanner;public class TestWork {public static void main(String[] args) {boolean isPrime = true;Scanner sc = new Scanner(System.in);System.out.println("请输⼊⼀个正整数");int num = sc.nextInt();if (num > 0) {int k = (int) Math.sqrt(num);//k为num的正平⽅根，取整数for (int i = 2; i <= k; i++) {if (num % i == 0) {isPrime = false;//不是素数break;}}}if (isPrime) {System.out.println(num + "是素数");} else {System.out.println(num + "不是素数");}}}输出1~1000之间的素数思路偶数肯定不是素数，所以递增的时候可以以奇数的形式递增，再在奇数中去掉⾮质数的数。

public class TestWork {public static void main(String[] args) {boolean isPrime = true;int PrimeCount=0;for (int i = 3; i <= 1000; i+=2) {int k = (int) Math.sqrt(i);//k为num的正平⽅根，取整数isPrime = true;for (int j = 2; j <= k; j++) {if (i % j == 0) {isPrime = false;//不是素数break;}}if (isPrime) {PrimeCount++;System.out.print(i+"\t");if(PrimeCount%5==0){System.out.println();}}}}}java 求1-100之间的质数质数定义：质数⼜称素数。

for循环输出素数探究【java】⼀、判断953是不是为素数（质数）。

代码：1/**2判断953是不是为素数（质数）3分析：4素数指整数在⼀个⼤于1的⾃然数中,除了1和此整数⾃⾝外,没法被其他⾃然数整除的数。

5假设953是素数，则：6 953 % 2 !== 07 953 % 3 !== 08 953 % 4 !== 09 ……10 953 % 952 !== 011反推得出，只要953被2~952之间的任何⼀个整数整除，则953不是素数。

1213除数从2开始到952按照整数依次递增，则⽤for循环表⽰为：14 for(int i=2;i<953;i++){15判断953能否被i整数16如果能被整除，则953不是素数，结束循环，跳出去输出“953不是素数”17如果不能被整除，则953是素数，结束循环，跳出去输出“953是素数”18 }19*/2021public class IsPrime22 {23public static void main(String[] args){2425int num = 953;26boolean isPrime = true; // 标记数字num默认为素数27for(int i=2;i<num;i++) {28if(num%i==0) { // num能够被2~num-1之间的⾃然数整数29 isPrime = false; // 标记数字num为⾮素数30break; // 结束循环31 }32 }3334 System.out.println(isPrime?num+"是素数":num+"不是素数");3536 }37 }代码结果显⽰：⼆、列出1~100之间的所有素数代码：1/**2列出1~100之间的所有素数3分析：4上⾯代码⽚段表⽰判断num为953的⾃然数是不是素数，5假设num为937，则判断937是不是素数，6假设num为933，则判断933是不是素数，78因此将num设置为⼀个变量，利⽤for循环进⾏从1~100进⾏递增，9将上门的代码⽚段放⼊该for循环中，判断为素数就打印出来。

参考答案第1章1．Java语言有哪些主要特点。

平台独立性安全性多线程网络化面向对象2．目前美国Sun公司提供的适用不同开发规模的JDK有哪些。

目前Sun共提供了三种不同的版本：微平台版J2ME（Java 2 Platform Micro Edition），标准版J2SE（Java 2 Platform Standard Edition）和企业版J2EE（Java 2 Platform Enterprise Edition），这三种版本分别适用于不同的开发规模和类型，对于普通Java开发人员和一般学习者来说，选用标准版J2SE就可以了，学会了J2SE，再学J2ME或J2EE就比较容易上手，因为它们之间虽有所侧重，但相似之处很多，尤其是语言本身是一样的，都是Java。

3．Java Application的开发步骤有哪些。

Java Application的开发步骤：（1）下载JDK软件并安装；（2）配置相应的环境变量（path和classpath）；（3）编写Java源程序（文本编辑器或集成开发环境IDE）；（4）编译Java源程序，得到字节码文件（javac *.java）；（5）执行字节码文件（java 字节码文件名）。

4．什么是环境变量，设置环境变量的主要目的是什么。

环境变量的配置主要是为了进行“寻径”，也即让程序能找到它需要的文件，所以设置的内容就是一些路径。

5．不参考书本，试着编写一个简单的Java Application程序，实现在Dos窗口输出“Welcome to Nanjing City!”字符串。

并对该程序进行编译和运行。

public class Hello {public static void main(String args[]){System.out.println("Welcome to Nanjing City!");}}6．编写一个Java Application程序，实现分行显示字符串“Welcome to Nanjing City”中的四个单词。

最经典java习题答案一、简单编程1.编写程序使用方法重载分别实现了两个和三个整数的相加。

public class ADD{int a;int b;int c;public int Add(int a,int b){return a+b;}public int Add(int a,int b,int c){return a+b+c;}}public class program_1 {public static void main(String[] args) {ADD x=new ADD();System.out.println(x.Add(13, 15));System.out.println(x.Add(13, 15,17));}}结果：2.编写程序使用冒泡法对一组数进行排序public class Sort {int a[];public void px(int b[]){a=b;}public void make(){int temp=0;for(int i=0;i<a.length-1;i++){for(int j=i+1;j<a.length;j++){if(a[j]>a[i]){temp=a[j];a[j]=a[i];a[i]=temp;}}}}public void printout(){for(int i=0;i<a.length;i++){System.out.print(a[i]+"\t");}}}public class program_2 {public static void main(String[] args) {Sort x=new Sort();int b[]={1,7,5,4,8,6,2,9,0};x.px(b);x.make();x.printout();}}结果：3．定义一个线程PrintThread，该线程打印输出1～1000之间所有3的倍数，每输出一个数休眠1500毫秒，在main方法中创建该线程的一个实例，并启动该线程。

Java,基础编程练习题-Java,基础编程练习题:1、编写程序实现对给定的 4 个整数从大到小的顺序排列。

package HomeWork01;import java.util.Scanner;public class HomeWork01 {static int number=4; //输入4个数存放在数组中static int[] t1 = new int[number];public static void main(String[] args) {HomeWork01 jiejie=new HomeWork01();jiejie.shunxun();}void shunxun(){System.out.println(“请输入4个数：”);Scanner in_t1 = new Scanner(System.in);//循环输入数组for(int i=0;i t1[i]=in_t1.nextInt();}for (int i = 0; i int pos = i;for (int j = i + 1; j if (t1[pos] > t1[j]) pos = j;}if (pos != i) {t1[i] = t1[i] + t1[pos];t1[pos] = t1[i] - t1[pos];t1[i] = t1[i] - t1[pos];}}for (int i = t1.length - 1; i >= 0; i--)System.out.print(t1[i] + “\t”);}}2、编写程序求一元二次方程的根。

package HomeWork02;import java.util.Scanner;public class HomeWork02//△=b-4ac的值,若△小于0,一元二次方程无根.若△等于0,一元二次方程有两个相等的根.若△大于0,一元二次方程有两个不相等的实数根{public static void main(String [] args){Scanner sc = new Scanner(System.in);System.out.println(“输入2次方的系数”);int a = sc.nextInt();System.out.println(“输入1次方的系数”);int b = sc.nextInt();System.out.println(“输入0次方的系数”);int c = sc.nextInt();if((b*b - 4*a*c) System.out.println(“方程无解！”);return;}else{System.out.println(“方程有解！”);}double x1 = (-b + Math.sqrt(b*b - 4*a*c))/2*a;double x2 = (-b - Math.sqrt(b*b - 4*a*c))/2*a;System.out.println(“根分别是“ + x1 + “\t” + x2);}}3、编写程序，输入一个字符，判断它是否为小写字母，如果是，将它转换成大写字母，否则，不转换。

Java 程序设计实验课安排[1] 高飞，陆佳炜等。

Java 程序设计实用教程。

北京：清华大学出版社，2013（ISBN ：978-7-302-31695-4)[2] 高飞，赵小敏等。

Java 程序设计实用教程习题集。

北京：清华大学出版社，2013（ISBN ：978-7-302-32051-7)第一次上机（2学时）1.1、编写一个程序，打印100～200之间的素数，要求每行按10个数(数与数之间有一个空格间隔)的形式对其输出。

1.2、编写一个编程，给定一个t 的值按下式计算y 值并输出，要求分别用if 和switch 语句来实现。

⎪⎪⎪⎩⎪⎪⎪⎨⎧−<≤+<≤⋅−<≤−−<≤−=其它175153)sin(3122101223t t t t t t t t t t t t y 提示：平方根：Math.sqrt(n) 计算sin(t)方法：Math.sin(t)第二次上机（2学时）编写一个Java 应用程序，要求用户从键盘输入一个1—99999这个数，然后判断是否是回文数。

回文数是指将该数含有的数字逆序排列后得到的数和原数相同，例如12121、3223都是回文数。

设有3个数组内容如下:String x[]={"zero","one","two", "three","four", "five","six","seven","eight","nine"} ;String y[]={"ten","eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","nineteen" };String z[]={"twenty","thirty","forty","fifty", "sixty","seventy", "eighty","ninety"};用Java命令行输入一个小于100的整数，将其翻成英文表示。

判断⼀个数是否是素数判断⼀个数是否是素数⼀、判断⼀个数是否是素数？public boolean isPrimeNumber(int num){if(num == 2) return true; //2特殊处理if(num < 2 || num % 2 == 0) return false; //识别⼩于2的数和偶数for(int i=3; i<=Math.sqrt(num); i+=2){if(num % i == 0){ //识别被奇数整除return false;}}return true;}质数的定义：质数（prime number）⼜称为素数，有⽆限多个。

质数定义在⼤于1的⾃然数中，除了1和它本⾝以外不会再有其它因数的数称为质数。

（1）从2开始，2是最⼩的质数。

（2）除了2之外的偶数全都不是质数，因为除了1和⾃⾝之外它们还能被2整除。

若为⼤于2的奇数，则进⼊下⼀步继续判断。

（3）将其开⽅，若从3到开⽅向下取整之间的所有奇数都不能将其整除，则说明该数为质数。

⾄于为什么只⽤除到其平⽅根？因为如果⼀个数不是素数是合数，那么⼀定可以由两个⾃然数相乘得到，其中⼀个⼤于或等于它的平⽅根，⼀个⼩于或等于它的平⽅根。

⼆、三种素数之间的⽐较？package Java基础;public class TestPrime {public static void main(String[] args) {long startTime1 = System.currentTimeMillis();for(int i=1;i<=100;i++){if(isPrime1(i)){System.out.print(i+" ");}}long endTime1 = System.currentTimeMillis();System.out.println("⽅式⼀消耗时间："+(endTime1-startTime1));long startTime2 = System.currentTimeMillis();for(int i=1;i<=100;i++){if(isPrime2(i)){System.out.print(i+" ");}}long endTime2 = System.currentTimeMillis();System.out.println("⽅式⼆消耗时间："+(endTime2-startTime2));long startTime3 = System.currentTimeMillis();for(int i=1;i<=100;i++){if(isPrime3(i)){System.out.print(i+" ");}}long endTime3 = System.currentTimeMillis();System.out.println("⽅式三消耗时间："+(endTime3-startTime3));}/** 1. 根据概念判断:如果⼀个正整数只有两个因⼦, 1和p，则称p为素数.时间复杂度O(n).*/public static boolean isPrime1(int n) {if (n < 2)return false;for (int i = 2; i < n; ++i)if (n % i == 0)return false;return true;}/** 2. 改进, 去掉偶数的判断时间复杂度O(n/2), 速度提⾼⼀倍.*/public static boolean isPrime2(int n) {if (n < 2)return false;if (n == 2)return true;if (n % 2 == 0)return false;for (int i = 3; i < n; i += 2)if (n % i == 0)return false;return true;}/** 3. 进⼀步减少判断的范围定理: 如果n不是素数, 则n有满⾜1< d<=sqrt(n)的⼀个因⼦d.证明: 如果n不是素数, 则由定义n有⼀个因⼦d满⾜1< d< n.如果d⼤于sqrt(n), 则n/d是满⾜1< n/d<=sqrt(n)的⼀个因⼦.时间复杂度O(Math.sqrt(n)/2), 速度提⾼O((n-Math.sqrt(n))/2).*/public static boolean isPrime3(int n) {if (n < 2)return false;if (n == 2)return true;if (n % 2 == 0)return false;for (int i = 3; i * i <= n; i += 2)if (n % i == 0)return false;return true;}}三、质数检测给出N个正整数，检测每个数是否为质数。

1．编写一个函数：int isPrime(int x)，判断x是否是素数，然后在main函数中调用该函数，判断100之内有哪些素数，并把这些素数输出。

#include <iostream>#include <cmath>using namespace std;int fan_isPrime(int fan_x){int k=int(sqrt(fan_x));for(int i=2;i<=k;i++)if(fan_x%i==0)break;if(i>k)cout<< fan_x<<' ';return fan_x;}int main(){cout<<"1～100之间的素数是："<<endl;int i;for(i=1;i<=100;i++)fan_isPrime(i);cout<<endl;return 0;}2．编写一个函数：int sum(int a[] int start, int end)，实现求数组a中的下标为start到end之间所有元素的和。

然后在main函数中调用该函数，求出给定数组中指定下标范围的值，数组元素的值在定义数组时给出。

#include <iostream>using namespace std;int fan_sum(int fan_a[],int fan_start, int fan_end){int k=0;for (int i=fan_start;i<=fan_end;i++)k+=fan_a[i];return k;}int main(){int fan_a[10]={0,1,2,3,4,5,6,7,8,9};int fan_start,fan_end;cout<<"Please input the start number and the end number:"<<endl;cin>>fan_start>>fan_end;cout<<fan_sum(fan_a,fan_start, fan_end)<<endl;return 0;}3．编写一个函数：void reverse( int a[], int n)，将数组a中n个元素反序排列，如将1,2,3,4,5变为5,4,3,2,1。