Java精选十道程序题.docx

Java精选十道程序题.docx

《Java精选十道程序题.docx》由会员分享，可在线阅读，更多相关《Java精选十道程序题.docx（41页珍藏版）》请在冰点文库上搜索。

Java精选十道程序题

Java精选10道程序题

第一题、输入一个数字先判断是否是质数，在输出1到该数之间的所有质数

//代入包

importjava.util.*;

importjava.lang.*;

publicclassTest

{

//定义一个可以判断素数（质数）的方法，如果是素数，则返回true；否则，返回false

publicstaticbooleanIsPrimeNum（intnum）

{

//素数：

素数也叫做质数，就是除了1和它本身以外不再有其他的除数整除（不包括0和1）的数

//合数：

指自然数中除了能被1和本身整除外，还能被其他的数整除（不包括0和1）的数

//素数判定法则一：

一个整数不能整除它的算数平方根之内的所有整数就是素数

//素数判定法则二：

一个整数不能整除它的1/2之内的所有整数就是素数

//素数判定法则三：

一个整数不能整除它之内的所有整数就是素数

//特别提醒：

最小的素数为2

//首先过滤基本的不属于素数的数

if（num<2||（num/2!

=1&&num%2==0）||（num/3!

=1&&num%3==0）||（num/5!

=1&&num%5==0）||（num/7!

=1&&num%7==0））

returnfalse;

//注：

尽管不写以下两句代码，也能返回true，但出于考虑数学中的准确性

if（num==2||num==3）

returntrue;

//注：

（Math.sqrt（）表示开平方，返回的是开方后的数，为double类型）

for（inti=2;i<=Math.sqrt（num）;i++）

{

//如果num除以i的余数为0，就表示它不是素数，则需直接return

if（num%i==0）

returnfalse;

}

returntrue;

}

//程序的入口点

publicstaticvoidmain（String[]args）

{

//实例化一个扫描器

Scannersc=newScanner（System.in）;

System.out.print（"请输入一个大于1的数字：

"）;

//接收用户输入的数字

intnum;

//捕捉用户输入可能引发的异常

try

{

//提示用户输入数字

num=sc.nextInt（）;

}

catch（InputMismatchExceptione）

{

//抛出一个异常

thrownewInputMismatchException（"输入的字符串格式错误"）;

}

while（num<2）

{

//捕捉用户输入可能引发的异常

try

{

System.out.print（"你输入的数字过小，请重新输入一个大于1的数字：

"）;

num=sc.nextInt（）;

}

catch（InputMismatchExceptione）

{

//抛出一个异常

thrownewInputMismatchException（"输入的字符串格式错误"）;

}

}

//调用以上写的IsPrimeNum（）方法，根据返回的值判断是否是质数

System.out.print（num+（IsPrimeNum（num）?

"":

"不"）+"是质数\n1-"+num+"之间的质数是：

\n"）;

for（inti=2;i<=num;i++）

{

if（IsPrimeNum（i））

System.out.print（i+"\t"）;

}

//执行换行操作

System.out.println（）;

}

}

//运行结果如下

第二题、已知一个三位数，在其首位加1，则得到一个四位数，四位数是三位数的3倍，问三位数是多少

publicclassTest

{

//程序的入口点

publicstaticvoidmain（String[]args）

{

//法一：

for（inti=100;i<1000;i++）

{

//先判断商是否为3，由于两个int之间进行运算时，结果依然是int类型,即只会保留运算后的整数部分。

所以还得判断这个数加上1000后除以这个数的余数是否为0

if（（i+1000）/i==3&&（i+1000）%i==0）

System.out.print（i+"\t"）;

}

//法二：

/*for（doublei=100;i<1000;i++）

{

//由于两个类型都是double类型时，结果依然是double类型，所以不需再判断这个数加上1000后除以这个数的余数是否为0

if（（i+1000）/i==3）

System.out.print（（int）（i）+"\t"）;//由于结果是double类型，所以要将其强制转换成int类型

}*/

System.out.println（）;

}

}

//运行结果如下

第三题、肇事车辆逃逸了，有3个目击者。

甲：

车牌号是个四位数乙：

车牌号前两位相同，后两位相同丙：

车牌号是一个数的平方。

问车牌号是多少？

publicclassTest

{

//程序的入口点

publicstaticvoidmain（String[]args）

{

for（inti=1000;i<10000;i++）

{

//将数字转换为字符串,'+'连接两个表达式时，若其中一边是字符串类型,则'+'的作用是连接字符串

Strings=i+"";

//判断千位和百位，十位和个位各自是否相等，并且开方必须是整数

if（s.charAt（0）==s.charAt

（1）&&s.charAt

（2）==s.charAt（3）&&Math.sqrt（i）==（int）（Math.sqrt（i）））

System.out.print（i+"\t"）;

}

System.out.println（）;

}

}

//运行结果如下

第四题、定义一个整型数组，输入一个数，找出这个数在数组中的位置并删除。

importjava.util.*;

importjava.lang.*;

publicclassTest

{

//定义一个可以正着查找一个数在指定整型数组中的下标的方法，如果存在，则返回该数对应的下标；否则，返回-1

publicstaticintIndexOf（int[]arr,intnum）

{

for（inti=0;i

{

//找到指定元素后，则就直接返回该元素对应的下标

if（arr[i]==num）

returni;

}

//没找到指定元素时，返回-1

return-1;

}

//定义一个可以删除数组指定下标的方法，返回删除后的新数组

publicstaticint[]RemoveAt（int[]arr,intindex）

{

//索引超出范围时，抛出一个ArrayIndexOutOfBoundsException异常

if（index<0||index>=arr.length）

thrownewArrayIndexOutOfBoundsException（"索引超出范围，索引必须为非负值，并小于集合大小"）;

//定义一个与数组arr中的元素一样的中间变量数组

int[]tmp=arr;

for（inti=index;i

{

//将指定下标后的数组元素的所有下标均向前移一位

tmp[i]=tmp[i+1];

}

//重新定义一个长度比之前小1的数组

arr=newint[arr.length-1];

for（inti=0;i

{

//将其所有长度在arr之类的所有元素赋给arr

arr[i]=tmp[i];

}

//返回删除指定元素后的新数组

returnarr;

}

//程序的入口点

publicstaticvoidmain（String[]args）

{

//实例化一个扫描器

Scannersc=newScanner（System.in）;

int[]arr={1,3,8,9,10,6,2,4,5,7};

System.out.println（"现有数组：

"）;

for（inti=0;i

{

System.out.print（arr[i]+"\t"）;

}

//提示用户输入数字

System.out.print（"请输入一个数字：

"）;

intnum;

//捕捉用户输入可能引发的异常

try

{

num=sc.nextInt（）;

}

catch（InputMismatchExceptione）

{

//抛出一个异常

thrownewInputMismatchException（"输入的字符串格式错误"）;

}

//查找用户输入数字的下标

intindex=IndexOf（arr,num）;

if（index<0）

System.out.println（"没找到数组元素为"+num+"的位置"）;

else

{

System.out.printf（"数组元素为%d的位置是%d，删除元素为%d后的数组是\n",num,index,num）;

//删除用户输入的指定数字

arr=RemoveAt（arr,index）;

for（inti=0;i

{

System.out.print（arr[i]+"\t"）;

}

}

System.out.println（）;

}

}

//运行结果如下

第五题、定义一个长度为10整型数组，要求从键盘输入，然后对这10个数中最大值，最小值和与平均值，最后用冒泡排序对其进行排序

importjava.util.*;

importjava.lang.*;

publicclassTest

{

//定义一个得到指定整型数组最大值的方法

publicstaticintGetMax（int[]arr）

{

intmax=arr[0];

for（inti=1;i

{

//比较每个元素是否比max的值大，若比max的值大时，则将其值赋给max

max=max>arr[i]?

max:

arr[i];

}

//返回指定数组中的最大值

returnmax;

}

//定义一个得到指定整型数组最小值的方法

publicstaticintGetMin（int[]arr）

{

intmin=arr[0];

for（inti=1;i

{

//比较每个元素是否比min的值小，若比min的值小时，则将其值赋给min

min=min

min:

arr[i];

}

//返回指定数组中的最小值

returnmin;

}

//定义一个得到指定整型数组之和的方法

publicstaticintGetSum（int[]arr）

{

intsum=arr[0];

for（inti=1;i

{

//将每个元素的值相加赋给sum

sum+=arr[i];

}

//返回指定数组每个元素相加的总和

returnsum;

}

//定义一个得到指定整型数组平均值的方法

//注：

也可将GetMax（）、GetMin（）、GetSum和GetAvg写到一个方法，用一个长度为4的double数组形式返回

publicstaticdoubleGetAvg（int[]arr）

{

//先得到指定数组每个元素相加的总和

doubleavg=GetSum（arr）;

//先将得到的总和除以指定数组的长度，得到其平均值，再返回平均值

returnavg/arr.length;

}

//定义一个对指定整型数组进行升序的方法

publicstaticvoidSort（int[]arr）

{

SortByAsc（arr）;

}

//定义一个对指定整型数组进行降序的方法

publicstaticvoidSortByAsc（int[]arr）

{

for（inti=0;i

{

//法一：

最先得到数组中的最大值

for（intj=i;j

{

if（arr[i]>arr[j+1]）

{

inttmp=arr[i];

arr[i]=arr[j+1];

arr[j+1]=tmp;

}

}

//法二：

最先得到数组中的最小值

/*for（intj=0;j

{

if（arr[j]>arr[j+1]）

{

inttmp=arr[j];

arr[j]=arr[j+1];

arr[j+1]=tmp;

}

}*/

}

}

//程序的入口点

publicstaticvoidmain（String[]args）

{

//实例化一个扫描器

Scannersc=newScanner（System.in）;

int[]arrNum=newint[10];

for（inti=1;i<=arrNum.length;i++）

{

//提示用户输入数字

System.out.print（"请输入第"+i+"个数：

"）;

//捕捉用户输入可能引发的异常

try

{

arrNum[i-1]=sc.nextInt（）;

}

catch（InputMismatchExceptione）

{

//抛出一个异常

thrownewInputMismatchException（"输入的字符串格式错误"）;

}

}

System.out.printf（"最大值为：

%d，最小值为：

%d，平均值为：

%.1f\n排序后为：

\n",GetMax（arrNum）,GetMin（arrNum）,GetAvg（arrNum））;

//对指定数组进行降序排序

Sort（arrNum）;

for（inti=0;i

{

System.out.print（arrNum[i]+"\t"）;

}

System.out.println（）;

}

}

//运行结果如下

第六题、两个乒乓球队进行比赛，各出三人。

甲队为a,b,c三人，乙队为x,y,z三人。

已抽签决定比赛名单。

有人向队员打听比赛的名单。

a说他不和x比，c说他不和x,z比。

请在一个方法中编程序找出三队赛手的名单。

publicclassTest

{

//定义一个得到指定比赛名单的方法

publicstaticvoidGetList（）

{

//法一

/*x是a的对手，y是b的对手，z是c的对手*/

for（charx='x';x<='z';x++）

{

for（chary='x';y<='z';y++）

{

if（x!

=y）

{

for（charz='x';z<='z';z++）

{

if（x!

=z&&y!

=z&&x!

='x'&&z!

='x'&&z!

='z'）

System.out.printf（"a-%c\nb-%c\nc-%c\n",x,y,z）;

}

}

}

}

//法二

//注：

由于c条件最多，故最好找出，所以定义c最前面

/*char[]ch={'c','a','b','x','y','z'};

//m是a的对手，n是b的对手，k是c的对手

charm='0',n='0',k='0';

for（inti=0;i

{

for（intj=ch.length/2;j

{

if（ch[i]=='a'&&ch[j]!

='x'&&ch[j]!

=k）

m=ch[j];

elseif（ch[i]=='b'&&ch[j]!

=m&&ch[j]!

=k）

n=ch[j];

elseif（ch[i]=='c'&&ch[j]!

='x'&&ch[j]!

='z'）

k=ch[j];

}

}

System.out.printf（"a-%c\nb-%c\nc-%c\n",m,n,k）;*/

}

//程序的入口点

publicstaticvoidmain（String[]args）

{

GetList（）;

System.out.println（）;

}

}

//运行结果如下

第七题、将一个正整数分解质因数。

例如：

输入96打印出90=2*2*2*2*2*3。

importjava.util.*;

importjava.lang.*;

publicclassTest

{

//定义一个可以判断素数（质数）的方法，如果是素数，则返回true；否则，返回false

publicstaticbooleanIsPrimeNum（intnum）

{

//素数：

素数也叫做质数，就是除了1和它本身以外不再有其他的除数整除（不包括0和1）的数

//合数：

指自然数中除了能被1和本身整除外，还能被其他的数整除（不包括0和1）的数

//素数判定法则一：

一个整数不能整除它的算数平方根之内的所有整数就是素数

//素数判定法则二：

一个整数不能整除它的1/2之内的所有整数就是素数

//素数判定法则三：

一个整数不能整除它之内的所有整数就是素数

//特别提醒：

最小的素数为2

//首先过滤基本的不属于素数的数

if（num<2||（num/2!

=1&&num%2==0）||（num/3!

=1&&num%3==0）||（num/5!

=1&&num%5==0）||（num/7!

=1&&num%7==0））

returnfalse;

//注：

（Math.sqrt（）表示开平方，返回的是开方后的数，为double类型）

for（inti=2;i<=Math.sqrt（num）;i++）

{

//如果num除以i的余数为0，就表示它不是素数，则需直接return

if（num%i==0）

returnfalse;

}

returntrue;

}

//定义一个分解质因数的方法

publicstaticStringPrimeFactorization（intnum）throwsException

{

//参数为小于2时，抛出一个参数无效的异常

if（num<2）

thrownewException（"参数无效，参数必须为非负数"）;

Strings="";

//如果是质数返回本身

if（IsPrimeNum（num））

returns+num;

for（inti=2;num>1;i++）

{

//保证每个因数都是质数

while（IsPrimeNum（i）&&num%i==0）

{

num/=i;

s+=i+（num<=1?

"":

"*"）;

}

}

returns;

}

//程序的入口点

publicstaticvoidmain（String[]args）

{

//实例化一个扫描器

Scannersc=newScanner（System.in）;

//提示用户输入一个大于1的数字

System.out.print（"请输入一个大于1的整数：

"）;

intnum;

//捕捉用户输入可能引发的异常

try

{

num=sc.nextInt（）;

}

catch（InputMismatchExceptione）

{

//抛出一个异常

thrownewInputMismatchException（"输入的字符串格式错误"）;

}

//当用户输入的数字小于2时，提示用户循环重新输入

while（num<2）

{

//捕捉用户输入可能引发的异常

try

{

System.out.print（"输入的数字过小，无法分解质因数，请重新输入一个大于1的整数：

"）;

num=sc.nextInt（）;

}

catch（InputMismatchExceptione）

{

thrownewInputMismatchException（"输入的字符串格式错误"）;

}

}

//当用户输入的是质数时，再次提示用户重新输入

while（IsPrimeNum（num））

{

System.out.print（"因"+num+"是质数，所以无法再次分解质因数，请重新输入一个大于1的整数：

"）;

num=sc.nextInt（）;

while（num<2）

{

//捕捉用户输入可能引发的异常

try

{System.out.print（"输入的数字过小，无法分解质因数，请重新输入一个大于1的