50 道 JAVA 基础编程

                               50 道 JAVA 基础编程练习题解答
【程序 1】
题目：古典问题：有一对兔子，从出生后第 3 个月起每个月都生一对兔子，小兔子长到第
三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？
.程序分析： 兔子的规律为数列 1,1,2,3,5,8,13,21.... 
解答：
（方法一）
利用数学分析可得知：这个月的兔子数量为前两个月的兔子数量之和，推导过程如下：
X1，X2，X3 Y1，Y2，Y3 Z1，Z2，Z3
X1：表示一个月大的兔子；X2表示两个月大的兔子；X3表示三个月及三月以上的兔子。
有以下数学表达式：
Y1=X2+X3 ，Y2=X1 ，Y3=X2+X3
Z1=Y2+Y3 ，Z2=Y1 ，Z3=Y2+Y3
Z1+Z2+Z3= Y2+Y3+Y1+(Y2+Y3)=(Y2+Y3+Y1)+(X2+X3+X1)
因此上面每个月的兔子的数量满足斐波那契数列。编程实现较为简单，此处省略。
（方法二）
方法二利用编程实现，具有一般性（开始兔子个数和产仔周期可自行输入），程序设计如下：

import java.util.*;
import java.io.*;
class TuZi
{
int nianling=1;
}
public class Text1 {
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
int shuliang=1;
int zhouqi=4;
int yuefen=0;
Vector rongqi=new Vector();
System.out.print("输入兔子开始数量：");
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
shuliang=(new Integer(stdin.readLine()));
System.out.print("输入兔子生产周期：");
zhouqi=(new Integer(stdin.readLine()));
System.out.print("输入查询月份：");
yuefen=(new Integer(stdin.readLine()));
for(int i=1;i<=shuliang;i++)
{
rongqi.addElement(new TuZi());
}
for(int i=2;i<=yuefen;i++)
{
for(int j=0;j=zhouqi)
{
rongqi.addElement(new TuZi());
}
}
}
System.out.print("兔子数量为："+rongqi.size());
}
}
【程序 2】
题目：判断 101-200 之间有多少个素数，并输出所有素数。
1.程序分析：判断素数的方法：用一个数分别去除 2 到 sqrt(这个数)，如果能被整除，
则表明此数不是素数，反之是素数。
解答：
程序如下：
public class Text2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int sum=0;
System.out.print("101到200的素数是： ");
for(int i=101;i<=200;i++)
{
int flag=0;
for(int j=2;j<=Math.sqrt(i);j++)
{
float k=(float)i;
if(k%j==0)
{
flag=1;
break;
}
}
if(flag==0)
{
System.out.print(i+" ");
sum++;
}
}
System.out.println("");
System.out.print("素数个数为： ");
System.out.print(sum);
}
}
【程序 3】
题目：打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于
该数本身。例如：153 是一个"水仙花数"，因为 153=1 的三次方＋5 的三次方＋3 的三次方。
1.程序分析：利用 for 循环控制 100-999 个数，每个数分解出个位，十位，百位。
解答：
程序如下：
public class Text3 {
public static void main(String[] args)
{
int a=0;int b=0;int c=0;
System.out.println("100到999的水仙花数为：");
for(int i=100;i<=999;i++)
{
a=i/100;
b=i/10-a*10;
c=i-b*10-a*100;
if(i==a*a*a+b*b*b+c*c*c)
{
System.out.println(i);
}
}
}
}
【程序 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 的值,重复执行第一步。
这个题目很明显是要用递归算法来实现的，打印“*”有些技巧，但也很容易解决，程序如
下：
import java.io.*;
public class Text4 {
public static void chuLi(int n)
{
for(int i=2;i<=n;i++)
{
if(n==i)
{ 
System.out.print(i);
return;
}
if(n>i&&(n%i==0))
{
n=n/i;
System.out.print(i+"*");
chuLi(n);
break;//这句很重要
}
}
}
public static void main(String[] args) throws IOException
{int shu=0;
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
System.out.print("请输入正整数：");
shu=(new Integer(stdin.readLine()));
chuLi(shu);
}
}
【程序 5】
题目：利用条件运算符的嵌套来完成此题：学习成绩>=90 分的同学用 A 表示，60-89 分之
间的用 B 表示，60 分以下的用 C 表示。
解答：
此题较为简单，程序如下
import java.io.*;
public class Text5 {
public static void main(String[] agrs) throws IOException
{
System.out.print("请输入成绩：");
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
int chengji=new Integer(stdin.readLine());
char dengji=chengji<60?'C':(chengji>=90?'A':'B');
System.out.print(dengji);
} 
}
【程序 6】
题目：输入两个正整数 m 和 n，求其最大公约数和最小公倍数。
<求最大公约数>
算法（1）设计：
E0.[确保 m n] 若 m n，则 m n。
E1.[求余数] 以 n 除 m 并令 r 为所得余数。（我们将有 0 r n。）
E2.[余数为 0?] 若 r 为 0，算法结束，n 即为所求答案。
E3.[减少] 置 m n，n r，并返回步骤 E1。
数学证明：
(1) 若 m%n=0，则 n 为所求最大公因子
(2) 若 m%n 0，则只需证明下面命题成立
如果某数是 n 与 m%n 的最大公因子，则这个数也是 m 和 n 的最大公因子。(上面算
法可化为这句话)
证明：
假设 a 是 n 和 m%n 的最大公因子，则有：
因有(m%n)%a=0，故可设 m%n=k*a，k 为正整数。又 n%a=0，故可设 n=p*a，p 也为正
整数。
可得数学表达式：m=t*n+m%n，其中 t 为不小于 0 的整数。
因此有：m=t*p*a+k*a=(t*p+k)*a，因此可得 m%a=0
因此有如下两个表达式：
a 为 m 和 n 的公因子已经证毕。
如何确定 a 为 m 和 n 的最大公因子？（可用反证法证明）
证明：假设 m 和 n 存在公因子 b，且有 b>a。
则有:
可以仿照上面的推导过程得出：
则 b 也是 n 和 m%n 的公因子，又 b>a，与 a 是 n 和 m%n 的最大公因子矛盾。
综上，如果某数是 n 与 m%n 的最大公因子，则这个数也是 m 和 n 的最大公因子。
(3) 证毕。
对步骤 E0 的分析：
若 m
算法设计：
F1：求出 m 和 n 的较大者，令较大者为 m，较小者为 n。
F2：判断 m 能否被 n 整除，若能则 m 为两者最小公倍数。
F2：将 n 分解因式。
F3：将 m 依次乘以 n 的因子，判断乘积能否被 n 整除，若能则乘积为两者最小公倍数。
根据上面的算法，程序如下：
import java.io.*;
import java.util.*;
public class Text6 {
public static void fenJie(Vector m,int n)
{
for(int i=2;i<=n;i++)
{
if(n==i)
{ 
m.addElement(i);
return;
}
if(n>i&&(n%i==0))
{
n=n/i;
m.addElement(i);
fenJie(m,n);
break;
}
}
}
public static int gongBeiShu(Vector m,int a,int b)
{
int chengji=1;
if(a%b==0)
return a;for(int i=0;i pool=new Vector();
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
System.out.print("请输入第一个正整数：");
shu1=(new Integer(stdin.readLine()));
System.out.print("请输入第二个正整数：");
shu2=(new Integer(stdin.readLine()));
if(shu1=65&&bytes[i]<=90)||(bytes[i]>=97&&bytes[i]<=122))
zimu++;
else if(bytes[i]==32)
kongge++;
else if(bytes[i]>=48&&bytes[i]<=57)
shuzi++;
else if(bytes[i]<0)
hanzishu++;
else
qita++;
}
System.out.println("字符串所占字节个数为："+bytes.length);
System.out.println("汉字个数为："+hanzishu/2);
System.out.println("英文字母个数为："+zimu);
System.out.println("空格个数为："+kongge);
System.out.println("数字个数为："+shuzi);
System.out.println("其他字符个数为："+qita);
}
}
【程序 8】
题 目 ： 求 s=a+aa+aaa+aaaa+aa...a 的 值 ， 其 中 a 是 一 个 数 字 。 例 如
2+22+222+2222+22222(此时共有 5 个数相加)，几个数相加有键盘控制。
解答：
在此题中，利用进行字符串运算的“+”运算符，然后将字符串转为数字，实现了程序过程，
程序设计如下：
import java.io.*;
public class Text8 {
public static void main(String[] args) throws IOException
{
int s=0;int a=0;int sum=0;String p="";
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
System.out.print("请输入数字a：");
a=new Integer(stdin.readLine());
System.out.print("请输入数字个数s：");
s=new Integer(stdin.readLine());
for(int i=1;i<=s;i++)
{
Character c=(char)(a+'0');
p=c.toString();
for(int j=1;j m,int n)
{
for(int i=1;i<=n/2;i++)
if(n%i==0) 
m.addElement(i);
}
public static boolean panBie(Vector m,int n)
{
int sum=0;
for(int i=0;i pool=new Vector();
fenJie(pool,i);
zhenjia=panBie(pool,i);
if(zhenjia)
System.out.println(i);
}
}
}
【程序 10】
题目：一球从 100 米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在 第
10 次落地时，共经过多少米？第 10 次反弹多高？
解答：
此题较为简单，程序设计如下：
import java.io.*;public class Text10 {
public static void main(String[] args) throws IOException {
float heigh=100;int cishu=10;float sum=0;
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
System.out.print("输入初始下落高度：");
heigh=(new Float(stdin.readLine()));
sum=heigh;
System.out.print("输入落地碰撞次数：");
cishu=(new Integer(stdin.readLine()));
for(int i=1;i m,int n)
{
for(int i=1;i<=Math.sqrt(n);i++)
if(n%i==0) 
m.addElement(i);
}
public static void main(String[] args) throws IOException
{
Vector pool=new Vector();
int m=100;int n=168;int t=0;int flag=0;
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
System.out.print("输入第一个正整数：");
m=new Integer(stdin.readLine());
System.out.print("输入第二个正整数：");
n=new Integer(stdin.readLine());
if(m>n)
{
t=m;
m=n;
n=t;
}
fenJie(pool,n-m);
int a=0;int b=0;int N=0;int x=0;
for(int i=0;i0)
{
flag=1;System.out.println(x);
}
}
if(flag==0)
System.out.println("不存在这样的数字！");
}
}
【程序 14】
题目：输入某年某月某日，判断这一天是这一年的第几天？
解答：
闰年的判断，可根据以下三点进行判断。
1、普通年能被 4 整除且不能被 100 整除的为闰年。（如 2004 年就是闰年,1900 年不是
闰年）
2、世纪年能被 400 整除的是闰年。(如 2000 年是闰年，1900 年不是闰年)
3、对于数值很大的年份,这年如果能整除 3200,并且能整除 172800 则是闰年。如
172800 年是闰年，86400 年不是闰年(因为虽然能整除 3200，但不能整除 172800)
分析： 利用 Scanner 类中 nextInt()进行数据的读取，由于是连续输入而且输入中有汉字，
故这种方法不行。程序设计需要改进，现利用 Character.isDigit 方法进行程序设计，达到了
较为理想的结果，程序如下所示。（此程序中有一段代码是对字符串中的数字进行提取，如
211 年 8 月 8 日提取三个数字分别为：211、8、8）
import java.io.*;
import java.util.*;
public class Text14xin {
public static void main(String[] args) throws IOException
{
long year=0;long month=0;long day=0;
String m=new String("");
String n=new String("");
Vector s=new Vector();
long tianshu=0;
int[] monthday={31,28,31,30,31,30,31,31,30,31,30,31};
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
System.out.print("输入日期：");
m=stdin.readLine();
char[] mass = m.toCharArray();
for(int i=0;i=172800)
{
if(year%3200==0&&year%172800==0)
monthday[1]=29;
}
else
{
if(year%4==0&&year%100!=0)
monthday[1]=29;
if(year%400==0)
monthday[1]=29;
}
for(int j=0;j=1;i--)
{
a=(a+1)*2;
}
System.out.print(a);
}
}
【程序 18】
题目：两个乒乓球队进行比赛，各出三人。甲队为 a,b,c 三人，乙队为 x,y,z 三人。已抽签
决定比赛名单。有人向队员打听比赛的名单。a 说他不和 x 比，c 说他不和 x,z 比，请编程
序找出三队赛手的名单。
解答：
分析：
其实问题可转化为排列组合问题，a 可以选 x,y,z 中的一个，b 可以选剩下两个中的一个，
而 c 只能选最后剩下的一个，总共有 6 中可能。关于排列的实现可以参照程序 11，具体程
序如下：
public class Text18 {
public static void main(String[] args) {
Character[] b={'x','y','z'};
for(int j=0;j<3;j++)
{
for(int k=0;k<3;k++)
{
if(j==k)
continue;
for(int h=0;h<3;h++)
{
if(h==j||h==k)continue;
if(b[j]!='x'&&b[h]!='x'&&b[h]!='z')
{
String s1=b[j].toString();
String s2=b[k].toString();
String s3=b[h].toString();
System.out.println(" a"+"(vs)"+s1+" b"+"(vs)"+s2+" 
c"+"(vs)"+s3);
}
}
}
}
}
}
//output:
 a(vs)z b(vs)x c(vs)y
【程序 19】
题目：打印出如下图案（菱形）
* 
*** 
****** 
******** 
****** 
*** 
* 
解答：
1.先把图形分成两部分来看待，前四行一个规律，后三行一个规律，利用双重 for 循环，第
一层控制行，第二层控制列。问题比较简单，就不进行编程了。
2 为了使问题具有一般性，现在我们输入菱形的行数，编程实现菱形的绘制。
分析：
1、输入的列数必须为行数
2、假设输入的数字为 n，则第（n+1）/2 为中间一行，进行一些简单的数学推导，便能推
出具体某一行的打印情况，程序设计如下：
import java.io.*;
public class Text19 {
public static void main(String[] args) throws Exception{
int n=0;
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
System.out.print("请输入菱形行数：");
n=(new Integer(stdin.readLine()));
if(n%2!=0)
{
for(int i=1;i<=(n+1)/2;i++)
{
for(int j=1;j<=(n-1)/2+i;j++)
{
if(j<=(n+1)/2-i)
{
System.out.print(" ");
}
else
System.out.print("*");
}System.out.println("");
}
for(int i=(n+3)/2;i<=n;i++)
{
for(int j=1;j<=(3*n+1)/2-i;j++)
{
if(j<=i-(n+1)/2)
{
System.out.print(" ");
}
else
System.out.print("*");
}
System.out.println("");
}
}
else
System.out.print("请确保行数为奇数！");
}
}
//output:
请输入菱形行数：7
 *
 ***
*****
*******
*****
 ***
 *
【程序20】
题目：有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13...求出这个数列的前20项之和。
解答：
分析：请抓住分子与分母的变化规律。 分子分母都是斐波那契数列，递推公式的得出较为
简单，程序设计如下：
public class Text20 {
public static void main(String[] args) {
float fenmu=1;float fenzi=2;
float sum=fenzi/fenmu;
float t=0;
for(int i=1;i<20;i++)
{
t=fenmu+fenzi;
fenmu=fenzi;
fenzi=t;
sum=sum+fenzi/fenmu;
}
System.out.print(sum);
}
}
//output:
32.660263
【程序21】
题目：求1+2!+3!+...+20!的和
解答：注意：由于数据较大，应该将数据类型设为double，当所得数据超过double的最大值时，显
示为Infinity。而当数据类型设为int或者其他不是double类型的时候，超过该类型的
最大值时，溢出，先往符号位进一位，显示为负数，当再进位时，则进行窄化处理，显示这
个类型所占字节的大小。
public class Text21 {
public static void main(String[] args)
{
double sum=0;double jiecheng=1;
for(int i=1;i<=20;i++)
{
jiecheng=i*jiecheng;
sum=sum+jiecheng;
}
System.out.println(sum);
System.out.print(Double.MAX_VALUE);
}
}
//output:
2.5613274941118203E18
1.7976931348623157E308
【程序22】
题目：利用递归方法求5!。
解答：
此题较为简单，不进行编程，现将题目改为求200！。
分析：
200！大于Double类的最大值，所以如果用普通数据类型将200！进行存储，明显难以达到
要求。现构建一个容器，容器里面的存放变量，当该层的数为n且大于等于十时，往前一层
进(n-n%10)/10，自身保留n%10。这种程序设计下最大可求出292！（理论上能计算所有正
整数的阶乘，此处出现问题，但尚未分析出来，希望有人能指出来），而按照程序21中的
方法则只能计算到170！。
程序设计如下：
import java.util.*;
class ShuJu
{
double h;//设置成double将能进行更大数据的运算，至少比text21中的计算能力要大
ShuJu(double i)
{
h=i;
}
}
public class Text22 {
public static void jiecheng(Vector m,int a)
{
ShuJu n=new ShuJu(1);
m.addElement(n);
for(int i=1;i<=a;i++)
{
int g=m.size();
for(int j=0;j=10)
{
m.elementAt(j).h=k%10;
if(j+1>=g)
m.addElement(new ShuJu((k-m.elementAt(j).h)/10));
//注意要减去余数，数据类型是double的，不进行这项操作将会存储为小数。
else
m.elementAt(j+1).h=m.elementAt(j+1).h+(k-m.elementAt(j).h)/10;
}
else
m.elementAt(j).h=k;
}
}
int flag=m.size()-1;
while(m.elementAt(flag).h>=10)//这个while循环是使得最高位的值向前转化，存入容
器。
//不进行这个循环将会导致容器的最高位为一个很大的数
{
double ch=m.elementAt(flag).h;
m.elementAt(flag).h=ch%10;
m.addElement(new ShuJu(((ch-m.elementAt(flag).h)/10)));
flag=flag+1;
}
}
public static void main(String[] args)
{
Vector pool=new Vector();
int x=200;int zeros=0;int flag=0;
jiecheng(pool,x);
for(int i=0;pool.elementAt(i).h==0;i++)
{
zeros++;//确保后面连续的零不进行输出
}
System.out.print((int)pool.elementAt(pool.size()-1).h+".");
//需将数据转化为int型的，不进行转化将会导致输出为double型的，将会引进无用的小
数点
for(int i=pool.size()-2;i>=zeros;i--)
{
System.out.print((int)pool.elementAt(i).h);
flag++;
if(flag>=10)//小数点后保留多少位小数
break;
}
System.out.print("*E"+(pool.size()-1));//输出指数标志
}
}
//output:
7.8865786736*E374
【程序23】
题目：有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。问第4个人岁数，他说比第3个人大2岁。问第三个人，又说比第2人大两岁。问第2个人，说比第一个人大两岁。
最后问第一个人，他说是10岁。请问第五个人多大？
解答：
此题较为简单，此处省略。
【程序24】
题目：给一个不多于5位的正整数，要求：一、求它是几位数，二、逆序打印出各位数字。
解答：
1、 可先得到输入的字符串s，然后利用new Integer(s)将字符串转为数字，再进行除法运算，
则可得出相应答案，但这样做有些复杂。
2、 可先得到输入的字符串s，利用s.getBytes()可得到相应的Byte数组，再将数组处理一下，
逆序输出即可。程序设计如下：
//此程序对于任意位的正整数都行
import java.io.*;
public class Text24 {
public static void main(String[] args) throws Exception{
String s=new String("");
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
System.out.print("请输入一个正整数：");
s=stdin.readLine();
byte[]bytes=s.getBytes();
System.out.println("它是"+bytes.length+"位数");
for(int i=bytes.length-1;i>=0;i--)
{
System.out.print(bytes[i]-'0');
}
}
}
//output:
请输入一个正整数：123456
它是6位数
654321
【程序25】
题目：一个5位数，判断它是不是回文数。即12321是回文数，个位与万位相同，十位与千
位相同。
解答：
可按照程序24的思路对此题进行解答，程序设计如下：
//该程序不限制在5位数
import java.io.*;
public class Text25 {
public static void main(String[] args) throws Exception{
String s=new String("");
int flag=0;
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
System.out.print("请输入一个正整数：");
s=stdin.readLine();
byte[]bytes=s.getBytes();
System.out.println("它是"+bytes.length+"位数");
for(int i=0;i=2)
d=(char)bytes[1];
switch(c)
{
case 'M':
System.out.print("星期一");
break;
case 'm':
System.out.print("星期一");
break;
case 'T':
if(d=='u'||d=='U')
System.out.print("星期二");
if(d=='h'||d=='H')
System.out.print("星期四");
break;
case 't':
if(d=='u'||d=='U')
System.out.print("星期二");
if(d=='h'||d=='H')
System.out.print("星期四");
break;
case 'W':
System.out.print("星期三");
break;
case 'w':
System.out.print("星期三");break;
case 'F':
System.out.print("星期五");
break;
case 'f':
System.out.print("星期五");
break;
case 'S':
if(d=='a'||d=='A')
System.out.print("星期六");
if(d=='u'||d=='U')
System.out.print("星期天");
break;
case 's':
if(d=='a'||d=='A')
System.out.print("星期六");
if(d=='u'||d=='U')
System.out.print("星期天");
break;
}
}
}
【程序27】
题目：求100之内的素数
解答：和程序2一样
public class Text27 {
public static void main(String[] args) {
int sum=0;
System.out.print("100以内的素数是： ");
System.out.print(2+" ");
for(int i=3;i<100;i++)
{
int flag=0;
for(int j=2;j<=Math.sqrt(i);j++)
{
float k=(float)i;
if(k%j==0)
{
flag=1;
break;
}
}
if(flag==0)
{
System.out.print(i+" ");
sum++;
}
}
System.out.println("");
System.out.print("素数个数为： ");
System.out.print(sum+1);
}}
//output
100以内的素数是： 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 
71 73 79 83 89 97 
素数个数为： 25
【程序28】
题目：对10个数进行排序
1、利用Array.sort()方法进行排序，可参见程序15，程序设计较为简单，此处省略。
2、现将冒泡排序和选择的程序写出来。
冒泡排序
public class MaoPao {
public static void main(String[] args) {
int[] a={3,6,4,2,9,5,8,1,7,0};
int temp=0;int flag=0;
for(int i=0;i p=new ArrayList();for(int i=0;scan.hasNext();i++)
{
p.add(scan.nextLong());
}
Collections.sort(p); //建议在JDK多看看这个方法
System.out.print("排列后的顺序为：");
for(int i=0;i=p.get(i)) //等号是必要的，可以减少一个数据的后移
continue;
p.add(i,m);
break;
}
System.out.print("插入后的顺序为：");
for(int i=0;i>>1;}
System.out.println("");
}
public static void main(String[] args) throws Exception {
int x=0;
String s=new String("");
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
System.out.print("请输入正整数：");
s=stdin.readLine();
x=new Integer(s);
toBinary(x);
}
}
//output
请输入正整数：12
1100
请输入正整数：2047
11111111111
【程序32】
题目：取一个整数a从右端开始的5～8位。
解答：
(1)先使a右移4位。
(2)设置一个低4位全为1,其余全为0的数。可用~(~0<<4) 
(3)将上面二者进行&运算。
import java.io.*;
public class Text32 {
public static void main(String[] args) throws Exception{
int n=5;int m=8;
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
System.out.print("请输入一个正整数：");
int a=new Integer(stdin.readLine());
int b=~(~0<<(m-n+1));
int c=a>>>(m-n+1);
int d=c&b;
System.out.print("正整数的二进制形式为：");
System.out.println(Integer.toBinaryString(a));
System.out.print("正整数的从右端开始的5～8位为：");
int k=Integer.toBinaryString(d).length();
if(k vector1=new Vector();;
for(int i=1;i<=n;i++)
{
Vector vector=new Vector();
for(int j=1;j<=n-i;j++)
{
System.out.print(" ");//打印前面的空白
}
vector.addElement(1);
if(i>=3)
{
for(int k=2;k<=i-1;k++)
{
int m=vector1.elementAt(k-2)+vector1.elementAt(k-1);
vector.addElement(m);
}
}
if(i>=2)
vector.addElement(1);
vector1=vector;
for(int h=0;h p=new ArrayList();
for(int i=0;scan.hasNext();i++)
{
p.add(scan.nextLong());
}
int flag=0;
int flag1=p.size()-1;
long temp=0;
for(int i=1;i=0;i--)
{
if(p.get(flag1)>p.get(i))
flag1=i;
}
if(flag1!=p.size()-1)
{
temp=p.get(p.size()-1);
p.set(p.size()-1,p.get(flag1));
p.set(flag1,temp);
}
System.out.print("改变后的顺序为：");
for(int i=0;i p=new ArrayList();
for(int i=0;scan.hasNext();i++)
{
p.add(scan.nextLong());
}
System.out.print("请输入需要向后移动的位数：");
long m=new Long(stdin.readLine());
if(m<=p.size())
{
int n=p.size();
for(int i=1;i<=m;i++)
p.add(0,p.get(n-1));//插入一位，全部后移移位，故要移走的总是最后一个
System.out.print("移动后的顺序为：");
for(int i=0;i p=new ArrayList();int flag=1;
int flag1=0;
for(int i=0;ig)
k=g; //取较短字符串的长度范围进行比较
for(int i=0;it)
return 1; //大于则返回1
if(ug)
return 1;
return -1;
}
public static void main(String[] args) throws Exception{
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
System.out.print("请输入第一个字符串：");
String n=stdin.readLine();
System.out.print("请输入第二个字符串：");
String m=stdin.readLine();
int daxiao=compare(n,m);
if(daxiao==0)
System.out.print(n+"="+m);
if(daxiao==1)
System.out.print(n+">"+m);
if(daxiao==-1)
System.out.print(n+"<"+m);
}
}
//
请输入第一个字符串：aBcd
请输入第二个字符串：ABCD
aBcd=ABCD
请输入第一个字符串：abcd
请输入第二个字符串：accd
abcdabcd【程序41】
题目：海滩上有一堆桃子，五只猴子来分。第一只猴子把这堆桃子平均分为五份，多了一个，
这只猴子把多的一个扔入海中，拿走了一份。第二只猴子把剩下的桃子又平均分成五份，又
多了一个，它同样把多的一个扔入海中，拿走了一份，第三、第四、第五只猴子都是这样做
的，问海滩上原来最少有多少个桃子？
解答：
这题可以逆向思考得出答案，第五个猴子分的时候有m个桃子，根据分的逻辑关系可知第
四个猴子分的时候有m*5/4+1个桃子，根据此关系依次递推。假设第5个猴子得到了n个桃子，
则有m=5*n+1的数学关系。必须保证每次分的时候桃子的个数为整数，猴子得到的桃子数
也为整数。（要确保这一点，需要每次m都能被4整除）。
public class Text41 {
public static void main(String[] args) {
int n=1;
int m=0;
int flag=1;
int monkeyNum=5;
while(true)
{
flag=1;
m=monkeyNum*n+1;
for(int i=monkeyNum;i>=1;i--)
{
if(m%(monkeyNum-1)==0)
{
m=m/(monkeyNum-1)*monkeyNum+1;
flag++; //计算多少次的桃子数量被4整除
}
else
break;
}
if(flag==monkeyNum) //每次的桃子数量都能被4整除
break;
n++;
}
System.out.println("开始的桃子数至少是："+m);
System.out.print("此时第五个猴子得到的桃子数是："+n);
}
}
//output
开始的桃子数至少是：3121
此时第五个猴子得到的桃子数是：255
【程序42】
题目：809*??=800*??+9*??+1 其中??代表的两位数,8*??的结果为两位数，9*??的结果为
3位数。求??代表的两位数，及809*??后的结果。
解答：此题貌似有问题，不做解答。
【程序43】
题目：求0—7所能组成的奇数个数。
题目表述不清不做解答。
【程序44】
题目：一个偶数总能表示为两个素数之和。
不会，不明白这种证明要怎么去编程实现。
【程序45】题目：判断一个素数能被几个9整除
题目表述不清不做解答。
【程序46】
题目：两个字符串连接程序
解答：
1、直接使用“+”运算符即可。
2、 public String concat(String str) 方法，"cares".concat("s") returns "caress" ，
"to".concat("get").concat("her") returns "together"。
【程序47】
题目：读取7个数（1—50）的整数值，每读取一个值，程序打印出该值个数的＊。
解答：
程序较为简单，此处不做解答。（可参见程序29的输入方法）
【程序48】
题目：某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，加密
规则如下：每位数字都加上5,然后用和除以10的余数代替该数字，再将第一位和第四位交
换，第二位和第三位交换。
解答：
程序设计如下：
import java.io.*;
public class Text48 {
public static void main(String[] args) throws Exception {
System.out.print("请输入需要加密的四位数整数：");
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
String s=stdin.readLine();
char[] a=s.toCharArray();
int[] b=new int[a.length];
for(int i=0;i=0;i--)
{
System.out.print(b[i]);
}
}
}
//output
请输入需要加密的四位数整数：1234
加密后的数字为：9876
请输入需要加密的四位数整数：4567
加密后的数字为：2109
【程序49】
题目：计算字符串中子串出现的次数
解答：
import java.io.*;
public class Text49 {
public static void main(String[] args) throws Exception {
System.out.print("请输入字符串：");
BufferedReader stdin=new BufferedReader(new InputStreamReader(System.in));
String s=stdin.readLine();
System.out.print("请输入子字符串：");String s1=stdin.readLine();
char[] a=s.toCharArray();
char[] b=s1.toCharArray();
int num=0;
int flag=0;
for(int i=0;i vector=new Vector();
byte[] a=s.getBytes();
char[] mass = s.toCharArray();
for(int j=0;j