java经典小程序.docx
《java经典小程序.docx》由会员分享，可在线阅读，更多相关《java经典小程序.docx（42页珍藏版）》请在冰点文库上搜索。
java经典小程序
1，编写程序，判断给定的某个年份是否是闰年。
闰年的判断规则如下：
（1）若某个年份能被4整除但不能被100整除，则是闰年。
（2）若某个年份能被400整除，则也是闰年。
importjava.util.Scanner;
classBissextile{
publicstaticvoidmain（String[]arge）{
System.out.print（"请输入年份"）;
intyear;//定义输入的年份名字为“year”
Scannerscanner=newScanner（System.in）;
year=scanner.nextInt（）;
if（year<0||year>3000）{
System.out.println（"年份有误，程序退出！
"）;
System.exit（0）;
}
if（（year%4==0）&&（year%100!
=0）||（year%400==0））
System.out.println（year+"isbissextile"）;
else
System.out.println（year+"isnotbissextile"）;
}
}
2，给定一个百分制的分数，输出相应的等级。
90分以上A级
80~89B级
70~79C级
60~69D级
60分以下E级
importjava.util.Scanner;
classMark{
publicstaticvoidmain（String[]args）{
System.out.println（"请输入一个分数"）;
//定义输入的分数为“mark”，且分数会有小数
doublemark;
Scannerscanner=newScanner（System.in）;
mark=scanner.nextDouble（）;
//判断是否有输入错误。
if（mark<0||mark>100）{
System.out.println（"输入有误！
"）;
System.exit（0）;
}
/*判断分数的等级
90分以上者A级，80~89分者B级，70~79分者C级，60~69者D级，60分以下E级*/
if（mark>=90）System.out.println（"thismarkisgrade\'A\'"）;
elseif（mark>=80）System.out.println（"thismarkisgrade\'B\'"）;
elseif（mark>=70）System.out.println（"thismarkisgrade\'C\'"）;
elseif（mark>=60）System.out.println（"thismarkisgrade\'D\'"）;
elseSystem.out.println（"thismarkisgrade\'E\'"）;
}
}
3，编写程序求1+3+5+7+……+99的和值。
classhe{
publicstaticvoidmain（String[]args）{
intnumber=1;//初始值1，以后再+2递增上去
intsum=0;
for（;number<100;number+=2）{sum+=number;}
System.out.println（"1+3+5+7+……+99="+sum）;
}
}
4、利用for循环打印9*9表?
1*1=1
1*2=22*2=4
1*3=32*3=63*3=9
1*4=42*4=83*4=124*4=16
1*5=52*5=103*5=154*5=205*5=25
1*6=62*6=123*6=184*6=245*6=306*6=36
1*7=72*7=143*7=214*7=285*7=356*7=427*7=49
1*8=82*8=163*8=244*8=325*8=406*8=487*8=568*8=64
1*9=92*9=183*9=274*9=365*9=456*9=547*9=638*9=729*9=81
//循环嵌套，打印九九乘法表
publicclassNineNine{
publicstaticvoidmain（String[]args）{
System.out.println（）;
for（intj=1;j<10;j++）{
for（intk=1;k<10;k++）{//老师的做法，判断语句里的k<=j，省去下列的if语句。
if（k>j）break;//此处用continue也可以，只是效率低一点
System.out.print（""+k+"X"+j+"="+j*k）;
}
System.out.println（）;
}
}
}
6、输出所有的水仙花数，把谓水仙花数是指一个数3位数，其各各位数字立方和等于其本身，
例如：
153=1*1*1+3*3*3+5*5*5
classDafodilNumber{
publicstaticvoidmain（String[]args）{
System.out.println（"以下是所有的水仙花数"）;
intnumber=100;//由于水仙花数是三位数，故由100开始算起
inti,j,k;//ijk分别为number的百位、十位、个位
for（intsum;number<1000;number++）{
i=number/100;j=（number-i*100）/10;k=number-i*100-j*10;
sum=i*i*i+j*j*j+k*k*k;
if（sum==number）System.out.println（number+"isadafodilnumber!
"）;
}
}
}
7、求a+aa+aaa+.......+aaaaaaaaa=?
其中a为1至9之中的一个数，项数也要可以指定。
importjava.util.Scanner;
classMultinomial{
publicstaticvoidmain（String[]args）{
inta;//定义输入的a
inthowMany;//定义最后的一项有多少个数字
Scannerscanner=newScanner（System.in）;
System.out.println（"请输入一个1~9的a值"）;
a=scanner.nextInt（）;
System.out.println（"请问要相加多少项？
"）;
howMany=scanner.nextInt（）;
intsum=0;
inta1=a;//用来保存a的初始值
for（inti=1;i<=howMany;i++）{
sum+=a;
a=10*a+a1;//这表示a的下一项
//每次a的下一项都等于前一项*10，再加上刚输入时的a；注意，这时的a已经变化了。
}
System.out.println（"sum="+sum）;
}
}
8、求2/1+3/2+5/3+8/5+13/8.....前20项之和？
classSum{
publicstaticvoidmain（Sting[]args）{
doublesum=0;
doublefenZi=2.0,fenMu=1.0;//初始的分子（fenZi）＝2，分母（fenMu）＝1
for（inti=1;i<=20;i++）{
sum+=fenZi/fenMu;
fenMu=fenZi;//下一项的分母＝上一项的分子
fenZi+=fenMu;//下一项的分子＝上一项的分子加分母
}
System.out.println（"sum="sum）;
}
}
9、利用程序输出如下图形:
*
***
*****
*******
*****
***
*
classAsterisk{
publicstaticvoidmain（String[]args）{
for（inti=1;i<=13;i+=2）{
for（intj=1;j<=i&&i+j<=14;j++）{System.out.print（"*"）;}
System.out.println（）;//换行
}
}
}
11、计算圆周率
PI＝4－4/3+4/5-4/7.......
打印出第一个大于3.1415小于3.1416的值
classPi{
publicstaticvoidmain（String[]args）{
doublepi=0;//定义初始值
doublefenZi=4;//分子为4
doublefenMu=1;//第一个4，可看作分母为1的分式，以后的分母每次递增2
for（inti=0;i<1000000000;i++）{//运行老久，减少循环次数会快很多，只是精确度小些
pi+=（fenZi/fenMu）;
fenZi*=-1.0;//每项分子的变化是+4，－4，+4，－4....
fenMu+=2.0;//分母的变化是1，3，5，7，....每项递加2
}
System.out.println（pi）;
}
}
输出结果为pi=3.1415926525880504，应该不精确
12、输入一个数据n，计算斐波那契数列（Fibonacci）的第n个值
112358132134
规律：
一个数等于前两个数之和
//计算斐波那契数列（Fibonacci）的第n个值
publicclassFibonacci{
publicstaticvoidmain（Stringargs[]）{
intn=Integer.parseInt（args[0]）;
intn1=1;//第一个数
intn2=1;//第二个数
intsum=0;//和
if（n<=0）{
System.out.println（"参数错误!
"）;
return;
}
if（n<=2）{
sum=1;
}else{
for（inti=3;i<=n;i++）{
sum=n1+n2;
n1=n2;
n2=sum;
}
}
System.out.println（sum）;
}
}
//计算斐波那契数列（Fibonacci）的第n个值
//并把整个数列打印出来
publicclassFibonacciPrint{
publicstaticvoidmain（Stringargs[]）{
intn=Integer.parseInt（args[0]）;
FibonacciPrintt=newFibonacciPrint（）;
for（inti=1;i<=n;i++）{
t.print（i）;
}
}
publicvoidprint（intn）{
intn1=1;//第一个数
intn2=1;//第二个数
intsum=0;//和
if（n<=0）{
System.out.println（"参数错误!
"）;
return;
}
if（n<=2）{
sum=1;
}else{
for（inti=3;i<=n;i++）{
sum=n1+n2;
n1=n2;
n2=sum;
}
}
System.out.println（sum）;
}
}
13、求1-1/3+1/5-1/7+1/9......的值。
a,求出前50项和值。
b,求出最后一项绝对值小于1e-5的和值。
15、在屏幕上打印出n行的金字塔图案，如，若n=5,则图案如下：
*
***
*****
*******
*********
//打印金字塔图案
publicclassPrintStar{
publicstaticvoidmain（Stringargs[]）{
intcol=Integer.parseInt（args[0]）;
for（inti=1;i<=col;i++）{//i表示行数
//打印空格
for（intk=0;kSystem.out.print（""）;
}
//打印星星
for（intm=0;m<2*i-1;m++）{
System.out.print（"*"）;
}
System.out.println（）;
}
}
}
16、歌德巴赫猜想,任何一个大于六的偶数可以拆分成两个质数的和
打印出所有的可能
//任何一个大于六的偶数可以拆分成两个质数的和
//打印出所有的可能
publicclassGedebahe{
publicstaticvoidmain（Stringargs[]）{
intnum=Integer.parseInt（args[0]）;
if（num<=6）{
System.out.println（"参数错误!
"）;
return;
}
if（num%2!
=0）{
System.out.println（"参数错误!
"）;
return;
}
Gedebaheg=newGedebahe（）;
//1不是质数,2是偶数,因此从3开始循环
for（inti=3;i<=num/2;i++）{
if（i%2==0）{//如果为偶数,退出本次循环
continue;
}
//当i与num-i都为质数时,满足条件,打印
if（g.isPrime（i）&&g.isPrime（num-i））{
System.out.println（i+"+"+（num-i）+"="+num）;
}
}
}
第4章数组
1.定义一个int型的一维数组，包含10个元素，分别赋一些随机整数，然后求出所有元素的最大值，
最小值，平均值，和值，并输出出来。
classArrayNumber{
publicstaticvoidmain（String[]args）{
int[]arrayNumber;
arrayNumber=newint[10];
System.out.println（"以下是随机的10个整数：
"）;
//填入随机的10个整数
for（inti=0;iarrayNumber[i]=（int）（100*Math.random（））;
System.out.print（arrayNumber[i]+""）;
}
System.out.println（）;
intmax=arrayNumber[0];
intmin=arrayNumber[0];
intsum=0;
for（inti=0;iif（maxmax=arrayNumber[i];//求最大值
if（min>arrayNumber[i]）
min=arrayNumber[i];//求最小值
sum+=arrayNumber[i];
}
System.out.println（"其中Max="+max+",Min="+min+",Sum="+sum+",Avg="+sum/10.0）;
}
}
2.定义一个int型的一维数组，包含10个元素，分别赋值为1~10，然后将数组中的元素都向前移一个位置，
即，a[0]=a[1],a[1]=a[2],…最后一个元素的值是原来第一个元素的值，然后输出这个数组。
3.定义一个int型的一维数组，包含40个元素，用来存储每个学员的成绩，循环产生40个0~100之间的随机整数，
将它们存储到一维数组中，然后统计成绩低于平均分的学员的人数，并输出出来。
4.（选做）承上题，将这40个成绩按照从高到低的顺序输出出来。
5,（选做）编写程序，将一个数组中的元素倒排过来。
例如原数组为1，2，3，4，5；则倒排后数组中的值
为5，4，3，2，1。
6,要求定义一个int型数组a,包含100个元素,保存100个随机的4位数。
再定义一个
int型数组b，包含10个元素。
统计a数组中的元素对10求余等于0的个数，保存
到b[0]中；对10求余等于1的个数，保存到b[1]中，……依此类推。
classRemain{
publicstaticvoidmain（String[]args）{
int[]a=newint[100];
//保存100个随机4位数到a中
for（inti=0;ia[i]=（int）（1000*Math.random（））;
}
//统计a数组中的元素对10求余的各个的数目
int[]b=newint[10];
intk,sum;
for（intj=0;jfor（k=0,sum=0;kif（（a[k]%10）==j）sum++;
}
b[j]=sum;
System.out.printf（"b[%d]=%d\n",j,b[j]）;
}
}
}
7,定义一个20*5的二维数组，用来存储某班级20位学员的5门课的成绩；这5门课
按存储顺序依次为：
coreC++，coreJava，Servlet，JSP和EJB。
（1）循环给二维数组的每一个元素赋0~100之间的随机整数。
（2）按照列表的方式输出这些学员的每门课程的成绩。
（3）要求编写程序求每个学员的总分，将其保留在另外一个一维数组中。
（4）要求编写程序求所有学员的某门课程的平均分。
classStudent{
publicstaticvoidmain（String[]args）{
int[][]mark=newint[20][5];
//给学生赋分数值，随机生成
for（inti=0;）
}
}//未完成
8,完成九宫格程序
在井字形的格局中（只能是奇数格局），放入数字（数字由），使每行每列以及斜角线的和都相等
经验规则：
从1开始按顺序逐个填写；1放在第一行的中间位置；下一个数往右上角45度处填写；
如果单边越界则按头尾相接地填；如果有填写冲突，则填到刚才位置的底下一格；
如果有两边越界，则填到刚才位置的底下一格。
个人认为，可以先把最中间的数填到九宫格的最中间位置；再按上面的规则逐个填写，而且
填的时候还可以把头尾对应的数填到对应的格子中。
（第n个值跟倒数第n个值对应，格局上以最中
间格为轴心对应）
这样就可以同时填两个数，效率比之前更高；其正确性有待数学论证（但多次实验之后都没发现有错）。
九宫格的1至少还可以填在另外的三个位置，只是接下来的填写顺序需要相应改变；
再根据九宫格的对称性，至少可以有8种不同的填写方式
importjava.util.Scanner;
classNinePalace{
publicstaticvoidmain（String[]args）{
//定义N为九宫格的行列数，需要输入
System.out.println（"请输入九宫格的行列规模（只能是奇数的）"）;
Scannern=newScanner（System.in）;
intN;
//判断格局是否奇数（可判断出偶数、负数及小数）
doubled;
while（true）{
d=n.nextDouble（）;
N=（int）d;
if（（d-N）>1.0E-4||N%2==0||N<0）
{System.out.println（"输入出错,格局只能是正奇数。
请重新输入"）;}
elsebreak;
}
//老师的九宫格填写方法
int[][]result=newint[N][N];//定义保存九宫格的数组
introw=0;//行初始位置
intcol=N/2;//列初始位置,因为列由0开始，故N/2是中间位置
for（inti=1;i<=N*N;i++）{
result[row][col]=i;
row--;
col++;
if（row<0&&col>=N）{col--;row+=2;}//行列都越界
elseif（row<0）{row=N-1;}//行越界
elseif（col>=N）{col=0;}//列越界
elseif（result[row][col]!
=0）{col--;row+=2;}//有冲突
}
//打印出九宫格
for（inti=0;ifor（intj=0;jSystem.out.println（）;
}
//我个人的填格方式
int[][]result2=newint[N][N];//为免冲突，重新new一个数组
result2[N/2][N/2]=（N*N+1）/2;//先把中间值赋予中间位置
row=0;//定义行及列的初始赋值位置。
之前赋值的for对两个值有影响，故需重新定位
col=N/2;
for（inti=1;i<=N*N/2;i++）{
result2[row][col]=i;
//下面这句是把跟i对应的值放到格局对应的位置上
result2[N-row-1][N-col-1]=N*N+1-i;
row--;
col++;
if（row<0）{
升级会员 