java经典基础练习题及参考答案doc.docx
《java经典基础练习题及参考答案doc.docx》由会员分享，可在线阅读，更多相关《java经典基础练习题及参考答案doc.docx（15页珍藏版）》请在冰豆网上搜索。
java经典基础练习题及参考答案doc
1.写一-个函数，计算一个整数数组的平均值
importjava.util.Random;
publicclassjavaSevenDayLianXi（
publicstaticvoidmain（String[]args）（intarr[]=newint[10];
Randomscore=newRandom（）;
floatsum=0.0f;
System,out.print（H这组数为:
;
for（inti=0;iSystem.out.print（arr[i]+""）;
}
System.out.println（）;
System.out.printIn（n数组的平均值为：
"+sum/arr.length）;}
}
2.自定义f个整数数组a,读入一个整数n,如果n在数组中存在，则输出n的下标；如果不存在，则输出-1。
Scannersea=newScanner（System.in）;
int[]a={0,1,2,3,4,5,6,7,8,9};
System.out.print（"请输入一个数:
"）;
intshuDu=sca.nextlnt（）;
booleanbool=true;
for（inti=0;iif（a[i]==shu3u）（
System.out.printIn（shuDu+"在数组a中的下标为：
"+i）；bool=false;
break;
}
}
if（bool）
System.out.printIn（-1）;
3.给定一个数组，输出数组中的最大值和最小值
int[]a={12,34,563,2,45,778,554,4421,4456,6786};
Arrays.sort（a）;
intmin=a[0];
intmax=a[a.length-1];
System.out.printin（n数组中最小的数为：
'+min+,',最大的数为：
u+max）;
4.*给定一•个数组，把这个数组中所有元素顺序进行颠倒。
importjava.util.Random;
publicclassjavaSevenDayLianXi（
publicstaticvoidmain（String[]args）（intarr[]=newint[10];intshu=0;
Randomscore=newRandom（）;
System,out.print（"颠倒前的arr组数值为:
”）；for（inti=0;i}
System.out.println（）;
System.out・print（"颠倒后的arr数组值为:
for（inti:
arr）
System・out・print（i+”"
）
}
5.*数组的扩容。
给定一-个数组，要求写--个expand函数，把原有数组的长度扩容一倍，并保留原有数组原有的内容。
例如，给定一个数组int[]a={l,2,3},则扩容之后，a数组为：
{1,2,3,0,0,0）publicclassjavaNineDay{
publicstaticvoidmain（String[]args）（int[]arr={1,2,3,4,5,6,7,8）；arr=setArrays（arr）;for（intterm:
arr）System.out.print（term+"”）;
}
publicstaticint[]setArrays（int[]arr）（int[]arrays=newint[arr.length*2];System.arraycopy（arr,0,arrays^Q,arr.length）;returnarrays;
}
）
6.*数组的插入和删除
写两个函数，一个函数为delete函数，声明如下：
publicstaticvoiddelete（intpos）
该函数表示删除数组pos位一置上的元素。
第二个函数为insert函数，声明如下：
publicstaticvoidinsert（intpos,intvalue）该函数表示在数组pos位置上插入value值。
为了能在多个函数中使用同一个数组，需要把这个数组写在函数的外而，类的里而，并使用static修饰。
为了方便，还应该定义一个index变量，用来保存数组的有效元素的个数。
例如下面的代码：
publicclassTestlnsertDelete{
staticint[]a={1,3,2,5,7};〃多个函数可以直接操作该数组
staticintindex=5;
publicstaticvoidmain（Stringargs[]）（
delete
（2）;//I357
inserts,4）;//I4357
insert（0,6）;//614357
）
publicstaticvoiddelete（intpos）（
•••
）
publicstaticvoidinsert（intpos,intvalue）（
•••
）
）
实现方式：
1.delete方法：
把数组pos位后的所有元素向前移动1位
2.insert方法:
把数组pos位以及之后的元素向后移动1位,然后设置value。
要注意的是,insert时有可能需要数组扩容。
有效元素的个数的含义：
对于a数组，调用一次delete之后，a数组的长度不变，
长度依然为5,然而有效元素的个数为4个。
Tips:
insert方法中，如何判断是否需要扩容：
比较有效元素的个数和数组的长度，如果这两者一致，则需要扩容。
publicclassjavaNineDay{
staticint[]arc={1,2,3,4>2,5,6,7,2,8,9};
staticintindex=arr.length;
publicstaticvoidmain（String[]args）（
System.out.print（n初始数组为：
”）；
for（intterm:
arr）
System.out.print（term+""）;
System.out.print（"\n删除2后的数组为：
deLete
（2）;
System.out.print（"\n插入100后的数组为
insert（S,100）;
}
publicstaticvoiddelete（intpos）{
intnum=index;
for（inti=0;iif（arr[i]==pos&&iSyster（\.arraycopy（arr,i+1,arr3i,index-1-i）;arr[--num]=0;
）elseif（arr[i]==pos&&i==index-1）（c?
rr[--num]=0;
）
}
index=num;
for（intterm:
am）{
if（term>0）（
SysterrieOut•print（term+””）；
}
}
}
publicstaticvoidinsert（intpos,intvalue）（intarraysf];
if（index==arr.length）{
arrays=newint[index+1];
System.arroycopy^arr,0,arrays^0,index）;
}else
arrays=am;
System.arraycopy（arraypos,arrays^pos+1,index-pos）;
arrays[pos]=value;
index++;
for（intterm:
arrays）（
if（term>0）（
System.out.print（term+""）;
}
）
）
}
7.*完成数组的冒泡排序算法:
给定一个数组:
int[]a={1,327,5},利用冒泡排序对其按照从小到大的顺序排序，然后输出结果。
publicclassjavaSevenDayLianXi（
publicstaticvoidmain（String[]args）（
int[]am={1,3,2,7,5};
intterm=0;
for（inti=0;ifor（intj=i+1;jarr[j]）（term=arr[j];
arr[j]=am[i];
arr[i]=term;
}
}
}
System,out・print（“按冒泡排序后的结果为;
for（inti:
arc）
System.out.print（i+""）;
}
）
8.*使用第二种算法对数组进行排序
importjava.util.Arrays;
publicclassjavaSevenDayLianXi（
publicstaticvoidmain（String[]args）（
int[]am={1,3,2,7,5）；
Arrays.sort（arr）;
System.out・print（”用第二种方法给数组排序后的结果为：
”）；for（inti:
am）
System.out.print（i+"
）
}
杨辉三角的特点：
1.第i行有i个元素
2.每一-行的第一个元素和最后一个元素都为1
3.除了1之外，每个元素的值，都等于上一行同位置的元素以及前一个元素的和。
例如：
14641的下一行
1ala2a3a41
al=4+l=5
a2=6+4=10
a3=4+6=10
a4=1+4=5
依次类推。
要求：
读入一•个整数n,输出杨辉三角的前n行
importjava.util.Scanner;
publicclassjavaSevenDayLianXi（
publicstaticvoidmain（String[]args）（
Scannersea=newScanner（System.in）;
System.out.print（H请输入杨辉三角的行数：
”）；
introw=sca.nextlnt（）;
intam[][]=getArrays（row）;
for（int[]a:
am）{
for（intterm:
a）
System.out.print（（term>0?
term:
""）+”"）;
System.out・println（）;
publicstaticint[][]getArrays（introw）（intarr[][]=newint[row][row];for（inti=0;i}
9.*数学黑洞6174
已知：
一个任意的四位正整数。
将数字重新组合成一个最大的数和最小的数相减，重复这个过程，最多七步，
必得6174o即：
7641-1467=6174o将永远出不来。
求证：
所有四位数数字（全相同的除外），均能得到6174,输出掉进黑洞的步数。
importjava.util.Arrays;
importjava.util.Scanner;
publicclassjavaSixDay（
publicstaticvoidmain（String[]args）（
Scannersea=newScanner（System.in）;
intshu,max=0,min=0,result=0,biaoShi=0;
int[]am=newint[4];
while（true）{
booleanbool=true;
intcount=0;
if（biaoShi==0）
System.out.print（n请输入一个四位数（全相同的除外）:
shu=sca.nextlnt（）;
if（shu>=1000&&shu<=9999）{result=shu;
do{
arr[0]=
arr[l]=
arr[2]=
arr[3]=if（am[0]==arr[l]&&arr[l]==arr[2]
&&arr[2]==arr[3]）（
System・out.print（”请重新输入一个四位数：
”）;bool=false;
biaoShi=l;
break;
）else
biaoShi=0;
max=setResuLt^arr,0）;
min=setResuLt（arr,1）;
result=max-min;
count++;
}while（result!
=6174）;
if（bool）
System.out.printIn（shu+”运行了"+count+'、'次
后,结果变为6174。
”）；
）else
biaoShi=0;
}
}
//计算最大值,最小值
publicstaticintsetResult（int[]shu,intbiaoshi）（
intresult=0,j；
Arrays.sort（shu）;
if（biaoshi==0）{
j=0；
for（inti:
shu）{
result+=（int）（i*Math.pow（10,j））;//获取最大值j++；
}
）
if（biaoshi==1）（
j=3；
for（inti:
shu）{
result+=（int）（i*Math.poiv（10^j））;//获取最小值j-s
）
}
returnresult;
）
}
10.*筛选法求质数：
输入一个整数n,求小于这个整数的所有质数。
算法：
定义一个长度为n的boolean数组,true表示是质数,false表示不是质数。
初始
均为trueo之后从2开始循环：
1.找到第一个值为true的下标i
2.把所有下标为i的倍数的值置为falseo
直到扫描完数组中的所有数值。
最后遍历数组，如果下标i的值为true,则说明i为质数。
importjava.util.Scanner;
publicclassjavaSevenDayLianXi（
publicstaticvoidmain（String[]args）（
Scannersea=newScanner（System.in）;
System.out.print（H请输入-个大于2的整数;
intn=sca.nextlnt（）;
intcount=0;
boolean[]bool=newboolean[n];
if（true）{
bool[2]=true;
for（inti=3;ibool[i]=false;
else
bool[i]=true;
if（j%i==0&&j!
=i）bool[j]=false;
}
System.out.print（H小于"+n+”的所有质数为：
”）;for（booleanlean:
bool）（
if（lean）
System.out.print（count+""）;
count++;
}
}else
System.out.printIn（"输入的数不大于2!
"）;
11.**定义一个奇数阶二维数组,把每个元素顺序填入不同的自然数，要求行列和对伯线元素相加的结果相等
算法：
1.第一-个数字填在第一行正中间
2.如果可以填在斜上方，则数字尽量填在斜上方
3.如果斜上方出了上边界，则数字填入下一列最下端
4.如果斜上方出了右边界，则数字填入上一•行最左端
5.如果既出了右边界，乂出了上边界，则数字填入上一个数字的下方的
6.如果斜上方巳经被填过，则数字填入上一•个数字的下方。
要求：
读入一个奇数n,按照上述规则，输出n*n的方阵。
importjava.util.Scanner;
publicclassjavaEightDayLianXi（
publicstaticvoidmain（String[]args）（
Scannersea=newScanner（System.in）;
intnum,count=0;
introwSub=0,listSub=0;
while（true）（
System.out.print（“请输入一个奇数;
num=sca.nextlnt（）;
if（num%2!
=0）break;
}
intarr[][]=newint[num][num];
listSub=num/2;
while（countcount++;
arr[rowSub][listSub]=count;
if（rowSub==0&&listSublistSub++;
）elseif（rowSub>0&&listSub&&arr[rowSub-1][listSub+1]==0）（rowSub--;
listSub++;
}elseif（rowSub>0&&listSub==num-1）（rowSub--;
listSub=0;
）elseif（rowSub>0&&listSub&&arr[rowSub-1][listSub+1]!
=0）{powSub++;
）elseif（rowSub==0&&listSub==num-1）（rowSub++;
）
）
for（int[]score:
am）（
for（intterm:
score）
System.out.print（term+u\t"）;
System.out.printIn（""）;
System.out.printIn;
12.**十五个猴子围成一•圈选大王，依次1-7循环报数，报到7的猴子被淘汰，直到最后一只猴子成为大王。
问，哪只猴子最后能成为大王？
总数要输入，从哪一只开始要输入，点到儿要输入
publicclassjavaSevenDay（
publicstaticvoidmain（String[]args）（intall=15,start=1,end=7,num;
System.out・print（”出局的猴子有:
”）；int[]monkey=newint[all+1];num=all+1;
monkey[0]=0;
for（inti=1;ifor（inti=1;i<=end;i++）（if（all==1）
break;
elseif（i==end）（all--;
i=0;
monkey[start]=0;
System.out.print（start+""）;
}
do{
start++;
start=start%num;
）while（monkey[start]!
=1）;
）
System.out.println（）;
System.out.print（H猴王为第”+start+“只猴子。
”）；
}
}
13.**螺旋填数
读入两个整数m,n,输出一个m行n列的矩阵，这个矩阵是l~m*n这些自然数按照右、下、左、上螺旋填入的结果。
例如：
读入4,5,
则输出
12345
141516176
132019187
12111098
importjava.util.Scanner;
publicclassjavaEightDay（
publicstaticvoidmain（String[]args）（
Scannersea=newScanner（System.in）;
System.out.print（H请输入矩阵的行数”）;
introw=sca.nextlnt（）;
System,out,print（"\n请输入矩阵的列数:
intlist=sca.nextlnt（）;
int[][]am=newint[row][list];
intcount=0;〃数组存储的值。
introwSub=0,listSub=0;//数组的行下标和列下
升级会员 