JAVA 基础编程练习题

1 【程序 1 不死神兔】

题目：古典问题：有一对兔子，从出生后第 3 个月起每个月都生一对兔子，小兔子长到第三个月后每个月
又生一对兔子，假如兔子都不死，问每个月的兔子对数为多少？
程序分析： 兔子的规律为数列 1,1,2,3,5,8,13,21....

package CountRabbit;

import java.io.*;
import java.util.Scanner;
public class CountRabbit {
    /**
     * 不死神兔算法，使用递归
     */
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        System.out.println("Please input mouth:");
        int mouth = input.nextInt();
        System.out.println("第"+mouth+"个月有"+getRabbitNum(mouth)+"只兔子");
        //  int mouth =3;
        // System.out.println("第"+mouth+"个月有"+getRabbitNum(mouth)+"只兔子");
    }
    private static int getRabbitNum(int mouth){
        if(mouth==1||mouth==2){
            return 1;
        }
        else
            return getRabbitNum(mouth-1)+getRabbitNum(mouth-2);
    }
}

2 【程序 2 输出素数】

题目：判断 101-200 之间有多少个素数，并输出所有素数。
程序分析：判断素数的方法：用一个数分别去除 2 到 sqrt(这个数)，如果能被整除，则表明此数不是素数，
反之是素数。

package FindPrimeNumber;

public class FindPrimeNumber {
    //判断 101-200 之间有多少个素数，并输出所有素数。
    public static void main(String[] args){
        int count=0;    //记录素数的个数
        int flag;       //flag为1则不是素数
        int i,j;        //用于for循环
        System.out.println("101-200 之间的素数为：");
        for(i=101;i<=200;i++){
            int max = (int) Math.sqrt(i);
            flag=0;
            for(j=2;j<=max;j++){
                if(i%j==0){
                    flag=1;
                    break;
                }
            }
            if(flag==0){
                System.out.println(i+" ");
                count++;
            }
        }
        System.out.println("共有"+count+"个素数");
    }
}

3 【程序 3 水仙花数】
题目：打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。例
如： 153 是一个"水仙花数"，因为 153=1 的三次方＋5 的三次方＋3 的三次方。
程序分析：利用 for 循环控制 100-999 个数，每个数分解出个位，十位，百位。

package NarcissisticNumber;

public class NarcissisticNumber {
    //题目：打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。
    public static void main(String[] args){
        int a,b,c;      //a,b,c分别为百位，十位，个位
        int sum;
        System.out.println("所有的\"水仙花数\"为：");
        for(int i=100;i<1000;i++){
            a=i/100;
            b=(i/10)%10;
            c=i%10;
            sum=(int)Math.pow(a,3)+(int)Math.pow(b,3)+(int)Math.pow(c,3);
            if(sum==i){
                System.out.println(i);
            }
        }
    }
}

4 【程序 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 的值,重复执行第一步。

package PrimeFactorization;

import java.util.Scanner;
public class PrimeFactorization {
    //题目：将一个正整数分解质因数。例如：输入 90,打印出 90=2*3*3*5。
    public  static void main(String[] args){
        Scanner input = new Scanner(System.in);
        System.out.println("Please input integer:");
        int n= input.nextInt();
        int flag;
        String str = n+"=";
        if(n==1){                   //输入1时特殊处理
            str = str+n+"*";
        }
        for(int i=2;i<=n;i++){
            int max = (int) Math.sqrt(i);
            flag=0;
            for(int j=2;j<=max;j++){
                if(i%j==0){
                    flag=1;
                    break;
                }
            }
            if(flag==0){            //找到质数
                if(n%i==0){         //该质数是n的因数
                    str=str+i+"*";  //字符修改
                    n=n/i;          //修改n为除以i之后的数
                    i=1;            //质数从2重新开始找
                }
            }
        }
        str = str.substring(0,str.length()-1);  //去掉字符串中最后一个*
        System.out.println(str);
    }
}

5 【程序 5 判断分数等级】
题目：利用条件运算符的嵌套来完成此题：学习成绩>=90 分的同学用 A 表示， 60-89 分之间的用 B 表示，
60 分以下的用 C 表示。
程序分析： (a>b)?a:b 这是条件运算符的基本例子。

package GradeLevel;

import java.util.Scanner;
public class GradeLevel {
    public static void main(String[] args){
        //题目：利用条件运算符的嵌套来完成此题：学习成绩>=90 分的同学用 A 表示， 60-89 分之间的用 B 表示，
        //60 分以下的用 C 表示。
        System.out.println("请输入同学的成绩:");
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        char level = n>=60?(n>89?'A':'B'):'C';
        System.out.println("该同学的成绩等级为:"+level);
    }
}

6 【程序 6 求最大公约数及最小公倍数】
题目：输入两个正整数 m 和 n，求其最大公约数和最小公倍数。
程序分析：利用辗除法。

package LCMandHCF6;

import java.util.Scanner;
public class LCMandHCF {
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        System.out.println("请输入第一个整数:");
        int A = input.nextInt();
        System.out.println("请输入第二个整数:");
        int B = input.nextInt();
        System.out.println("最大公约数为："+getLCM(A,B));
        System.out.println("最小公倍数为："+getHCF(A,B));
    }
    private static int getLCM(int A,int B){
        //求最大公约数，辗转相除法
        int max=A>B?A:B;    //得到A，B的较大值
        int min=A>B?B:A;    //得到A，B的较小值
        int k=max%min;      //余数
        while(k!=0){
            max=min;
            min=k;
            k=max%min;
        }
        return min;
    }
    private static int getHCF(int A,int B){
        //求最小公倍数(最大公约数*最小公倍数=A*B)
        return A*B/getLCM(A,B);
    }
}

7 【程序 7 处理字符串】
题目：输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。
程序分析：利用 while 语句,条件为输入的字符不为'\n'.

package CountString7;

import java.util.Scanner;
public class CountString {
    public static void main(String[] args){
        System.out.print("请输入一串字符：");
        Scanner input = new Scanner(System.in);
        String str = input.nextLine();
        input.close();
        count(str);
    }
    private static void count(String str){
        String E1 = "[\u4e00-\u9fa5]";//汉字
        String E2 = "[a-zA-Z]";
        String E3 = "[0-9]";
        String E4 = "\\s";//空格
        int countChinese = 0;
        int countEnglish = 0;
        int countNumber = 0;
        int countSpace = 0;
        int countOthers = 0;
        String[] s = str.split("");             //将字符串转化为字符串数组
        /*
        char[] array_Char = str.toCharArray();  //将字符串转化为字符数组
        for (int j=0;j<array_Char.length;j++){
            System.out.println(array_Char[j]);
        }*/
        for(int i=0;i<s.length;i++){
            if(s[i].matches(E1))
                countChinese++;
            else if(s[i].matches(E2))
                countEnglish++;
            else if(s[i].matches(E3))
                countNumber++;
            else if(s[i].matches(E4))
                countSpace++;
            else
                countOthers++;
        }
        System.out.println("输入的汉字个数："+countChinese);
        System.out.println("输入的字母个数："+countEnglish);
        System.out.println("输入的数字个数："+countNumber);
        System.out.println("输入的空格个数："+countSpace);
        System.out.println("输入的其它字符个数："+countOthers);
    }
}

8 【程序 8 输入数字求和】

题目：求 s=a+aa+aaa+aaaa+aa...a 的值，其中 a 是一个数字。例如 2+22+222+2222+22222(此时共有 5 个
数相加)，几个数相加有键盘控制。
程序分析：关键是计算出每一项的值。

package Sum8;

import java.util.Scanner;
public class Sum {
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        System.out.println("请输入a数字：");
        int a = input.nextInt();
        System.out.println("请输入相加的个数：");
        int b = input.nextInt();
        System.out.println("和为："+Sum(a,b));
    }
    private static int Sum(int a,int b){
        int sum=0;
        for(int i=b,j=0;i>0;i--,j++){
            sum=sum+i*a*(int)Math.pow(10,j);
        }
        return sum;
    }
}

9 【程序 9 求完数】

题目：一个数如果恰好等于它的因子之和，这个数就称为"完数"。例如 6=1＋2＋3.编程找出 1000 以内的
所有完数。

package PerfectNumber9;

public class PerfectNumber {
    //题目：一个数如果恰好等于它的因子之和，这个数就称为"完数"。例如 6=1＋2＋3.编程找出 1000 以内的
    //所有完数。
    public static void main(String[] args){
        int sum;
        System.out.println("1000以内的完数有：");
        for(int i=2;i<=1000;i++){   //从2遍历到1000
            sum=0;
            for(int j=1;j<i;j++){   //j从1遍历到i-1
                if(i%j==0)          //若j是i的因数
                    sum=sum+j;
            }
            if(sum==i){             //i是完数
                System.out.println(i);
            }
        }
    }
}

10 【程序 10 *落体】
题目：一球从 100 米高度*落下，每次落地后反跳回原高度的一半；再落下，求它在 第 10 次落地时，
共经过多少米？第 10 次反弹多高？

package FreeFall10;

public class FreeFall {
    public static void main(String[] args){
        //题目：一球从 100 米高度*落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，
        //共经过多少米？第 10 次反弹多高？
        double h0=100;
        double sum=h0,high=0;     //sum为经过的长度，high为反弹的高度
        int n=10;                 //第n次
        for(int i=1;i<n;i++){
            sum=sum+h0*Math.pow(0.5,i)*2;
        }
        high=h0*Math.pow(0.5,n);
        System.out.println("第"+n+"次落地时共经过"+sum+"米");
        System.out.println("第"+n+"次的反弹高度"+high+"米");
    }
}

11 【程序 11 求不重复数字】
题目：有 1、 2、 3、 4 个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？
程序分析：可填在百位、十位、个位的数字都是 1、 2、 3、 4。组成所有的排列后再去 掉不满足条件的排
列。

package NoRepetitionNumber11;

public class NoRepetitionNumber {
    public static void main(String[] args){
        //题目：有 1、 2、 3、 4 个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？
        int i,j,k;      //i为百位,j为十位,k为个位
        int n=4;        //n为数字个数
        int count=0;
        for(i=1;i<=n;i++){
            for(j=1;j<=n;j++){
                for(k=1;k<=n;k++){
                    if(i!=j&&i!=k&&j!=k){
                        count++;
                        System.out.println(i*100+j*10+k);
                    }
                }
            }
        }
        System.out.println(n+"个数字共能组成"+count+"种互不相同且无重复数字的三位数");
    }
}

12 【程序 12 计算奖金】
题目：企业发放的奖金根据利润提成。利润(I)低于或等于 10 万元时，奖金可提 10%；利润高于 10 万元，
低于 20 万元时，低于 10 万元的部分按 10%提成，高于 10 万元的部分，可可提成 7.5%； 20 万到 40 万之间
时，高于 20 万元的部分，可提成 5%； 40 万到 60 万之间时高于 40 万元的部分，可提成 3%； 60 万到 100 万
之间时，高于 60 万元的部分，可提成 1.5%，高于 100 万元时，超过 100 万元的部分按 1%提成，从键盘输
入当月利润 I，求应发放奖金总数？
程序分析：请利用数轴来分界，定位。注意定义时需把奖金定义成长整型。

package CalculationBonus12;

import java.util.Scanner;
public class CalculationBonus {
    public static void main(String[] args){
        //题目：企业发放的奖金根据利润提成。利润(I)低于或等于 10 万元时，奖金可提 10%；利润高于 10 万元，
        //低于 20 万元时，低于 10 万元的部分按 10%提成，高于 10 万元的部分，可可提成 7.5%； 20 万到 40 万之间
        //时，高于 20 万元的部分，可提成 5%； 40 万到 60 万之间时高于 40 万元的部分，可提成 3%； 60 万到 100 万
        //之间时，高于 60 万元的部分，可提成 1.5%，高于 100 万元时，超过 100 万元的部分按 1%提成，从键盘输
        //入当月利润 I，求应发放奖金总数？
        System.out.println("请输入当月利润（万元）：");
        Scanner input = new Scanner(System.in);
        long n = input.nextLong();
        double sum=0;
        if(n<=10){
            sum = (n*0.1);
        }else if(n<=20){
            sum = (10*0.1+(n-10)*0.075);
        }else if(n<=40){
            sum = (10*0.1+10*0.075+(n-20)*0.05);
        }else if(n<=60){
            sum = (10*0.1+10*0.075+20*0.05+(n-40)*0.03);
        }else if(n<=100){
            sum = (10*0.1+10*0.075+20*0.05+20*0.03+(n-60)*0.015);
        }else{
            sum = (10*0.1+10*0.075+20*0.05+20*0.03+40*0.015+(n-100)*0.01);
        }
        System.out.println("奖金为："+sum+"万元");
    }

}

13 【程序 13 根据条件求数字】
题目：一个整数，它加上 100 后是一个完全平方数，再加上 168 又是一个完全平方数，请问该数是多少？
程序分析：在 10 万以内判断，先将该数加上 100 后再开方，再将该数加上 268 后再开方，如果开方后的结
果满足如下条件，即是结果。

package CalculateNumber13;

public class CalculateNumber {
    public static void main(String[] args){
        //题目：一个整数，它加上 100 后是一个完全平方数，再加上 168 又是一个完全平方数，请问该数是多少？
        double m,n;
        for(double i=0;i<=10000;i++){       //从0遍历到10000
            m = Math.sqrt(i+100);
            n = Math.sqrt(i+168);
            if((int)m==m && (int)n==n){     //若开方后的数字是整数
                System.out.println(i);
            }
        }
    }
}

14 【程序 14 求日期】
题目：输入某年某月某日，判断这一天是这一年的第几天？
程序分析：以 3 月 5 日为例，应该先把前两个月的加起来，然后再加上 5 天即本年的第几天，特殊情况，
闰年且输入月份大于 3 时需考虑多加一天。

package CalculateDate14;

import java.util.Scanner;
public class CalculateDate {
    //题目：输入某年某月某日，判断这一天是这一年的第几天？
    public static void main(String[] args){
        int sum=0,flag=0;
        Scanner input = new Scanner(System.in);
        System.out.println("请输入年份：");
        int y = input.nextInt();
        System.out.println("请输入月份：");
        int m = input.nextInt();
        System.out.println("请输入几号：");
        int d = input.nextInt();
        int[] mouth={0,31,28,31,30,31,30,31,31,30,31,30,31};
        for(int i=0;i<m;i++){       //加上之前所有月份的天数
            sum = sum+mouth[i];
        }
        sum += d;                   //加上当月的天数
        if(y%400==0 || (y%100!=0 && y%4==0))    //判断若是闰年
            flag=1;
        if(flag==1 && m>2)         //若该年是闰年且月份大于2月
            sum++;
        System.out.println(y+"年"+m+"月"+d+"日是这一年的第"+sum+"天");
    }
}

15 【程序 15 排序】
题目：输入三个整数 x,y,z，请把这三个数由小到大输出。
程序分析：我们想办法把最小的数放到 x 上，先将 x 与 y 进行比较，如果 x>y 则将 x 与 y 的值进行交换，
然后再用 x 与 z 进行比较，如果 x>z 则将 x 与 z 的值进行交换，这样能使 x 最小。

package Sort15;

import java.util.Scanner;
public class Sort {
    public static void main(String[] args){
        //题目：输入三个整数 x,y,z，请把这三个数由小到大输出。
        System.out.println("请输入三个整数：");
        Scanner input=new Scanner(System.in);
        int[] num =new int[3];
        for (int i = 0; i < num.length; i++) {
            num[i]=input.nextInt();
        }
        /*
        int num1,num2,num3;
        num1=input.nextInt();
        num2=input.nextInt();
        num3=input.nextInt();
        System.out.println(num1+" "+num2+" "+num3);
        */
        int temp;
        if(num[0]>num[1]){
            temp=num[0];
            num[0]=num[1];
            num[1]=temp;
        }
        if(num[0]>num[2]){
            temp=num[0];
            num[0]=num[2];
            num[2]=temp;
        }
        if(num[1]>num[2]){
            temp=num[1];
            num[1]=num[2];
            num[2]=temp;
        }
        for (int i = 0; i < num.length; i++) {
            System.out.println(num[i]);
        }
    }
}

16 【程序 16 输入 9*9 表】
题目：输出 9*9 口诀。
程序分析：分行与列考虑，共 9 行 9 列， i 控制行， j 控制列

package NineNineTasble16;

public class NineNineTasble {
    //题目：输出 9*9 口诀。
    public static void main(String[] args){
        for(int i=1;i<=9;i++){
            for(int j=1;j<=i;j++){
                System.out.print(j+"*"+i+"="+i*j+'\t');
            }
            System.out.println();
        }
    }
}

17 【 程序 17 猴子吃桃问题】
题目：猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个 第二天早上又
将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第 10 天早上想
再吃时，见只剩下一个桃子了。求第一天共摘了多少。
程序分析：采取逆向思维的方法，从后往前推断。

package MonkeyEatPeach17;

public class MonkeyEatPeach {
    //题目：猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个 第二天早上又
    //将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第 10 天早上想
    //再吃时，见只剩下一个桃子了。求第一天共摘了多少。
    public static void main(String[] args){
        int n=10;
        int sum=1;
        for(int i=1;i<n;i++){
            sum = (sum+1)*2;
        }
        System.out.println("第一天共摘了"+sum+"个桃子");
    }
}

18 【程序 18 乒乓球赛】
题目：两个乒乓球队进行比赛，各出三人。甲队为 a,b,c 三人，乙队为 x,y,z 三人。已抽签决定比赛名单。
有人向队员打听比赛的名单。 a 说他不和 x 比， c 说他不和 x,z 比，请编程序找出三队赛手的名单。

package PingPong18;

public class PingPong {
    //题目：两个乒乓球队进行比赛，各出三人。甲队为 a,b,c 三人，乙队为 x,y,z 三人。已抽签决定比赛名单。
    //有人向队员打听比赛的名单。 a 说他不和 x 比， c 说他不和 x,z 比，请编程序找出三队赛手的名单。
    public static void main(String[] args){
        char i,j,k;
        for(i='x';i<='z';i++){
            for(j='x';j<='z';j++){
                for(k='x';k<='z';k++){
                    if(i==j||j==k||i==k||i=='x'||k=='x'||k=='z')
                        continue;
                    else
                        System.out.println("Rivals of a,b,c are "+i+","+j+","+k);
                }
            }
        }
    }
}

19 【程序 19 打印菱形图案】
题目：打印出如下图案（菱形）
    *
   ***
 ******
********
 ******
   ***
     *
程序分析：先把图形分成两部分来看待，前四行一个规律，后三行一个规律，利用双重 for 循环，第一层
控制行，第二层控制列。

package PrintDiamond19;

public class PrintDiamond {
    //题目：打印出如下图案（菱形）
    public static void main(String[] args){
        int lay;
        lay = 7;//菱形的总长度
        for(int i=1;i<=(lay+1)/2;i++){          //输出上半部分
            for(int j=1;j<=(lay+1)/2-i;j++){    //输出空格
                System.out.print(" ");
            }
            for(int k=1;k<=2*i-1;k++){          //输出*
                System.out.print("*");
            }
            System.out.println();               //换行
        }
        for(int i=(lay+1)/2+1;i<=lay;i++){      //输出下半部分
            for(int j=1;j<=i-(lay+1)/2;j++){    //输出空格
                System.out.print(" ");
            }
            for(int k=1;k<=lay-(i-(lay+1)/2)*2;k++){          //输出*
                System.out.print("*");
            }
            System.out.println();               //换行
        }
    }
}

20 【程序 20 求前 20 项之和】
题目：有一分数序列： 2/1， 3/2， 5/3， 8/5， 13/8， 21/13...求出这个数列的前 20 项之和。
程序分析：请抓住分子与分母的变化规律。

package TopSum20;

public class TopSum {
    //题目：有一分数序列： 2/1， 3/2， 5/3， 8/5， 13/8， 21/13...求出这个数列的前 20 项之和。
    public static void main(String[] args){
        int n=20;       //前20项
        double sum=0;   //和
        for(int i=1;i<=n;i++){
            sum = sum + (double)fib(i+2)/fib(i+1);
        }
        System.out.print(sum);
    }
    private static int fib(int n){      //斐波那契数列
        if(n==1||n==2)
            return 1;
        else
            return fib(n-1)+fib(n-2);
    }
}

21 【程序 21 求阶乘】
题目：求 1+2!+3!+...+20!的和
程序分析：此程序只是把累加变成了累乘。

package Factorial21;

public class Factorial {
    //题目：求 1+2!+3!+...+20!的和
    public static void main(String[] args){
        int n=20;       //n个阶乘和
        int sum=0,fac;  //fac为阶乘，sum为总和
        for(int i=1;i<=n;i++){
            fac=1;
            for(int j=1;j<=i;j++){
               fac=j*fac;
            }
            sum += fac;
        }
        System.out.println(sum);
    }
}

22 【程序 22 递归求阶乘】
题目：利用递归方法求 5!。
程序分析：递归公式： fn=fn_1*4!

package Factorial22;

public class Factorial {
    //题目：利用递归方法求 5!。
    public static void main(String[] args){
        int n=5;
        System.out.println(Fac(n));
    }
    private static int Fac(int n){
        if(n>0)
            return Fac(n-1)*n;
        else
            return 1;
    }
}

23 【程序 23 求岁数】
题目：有 5 个人坐在一起，问第五个人多少岁？他说比第 4 个人大 2 岁。问第 4 个人岁数，他说比第 3 个
人大 2 岁。问第三个人，又说比第 2 人大两岁。问第 2 个人，说比第一个人大两岁。最后问第一个人，他
说是 10 岁。请问第五个人多大？
程序分析：利用递归的方法，递归分为回推和递推两个阶段。要想知道第五个人岁数，需知道第四人的岁
数，依次类推，推到第一人（ 10 岁） ，再往回推。

package GetAge23;

public class GetAge {
    //题目：有 5 个人坐在一起，问第五个人多少岁？他说比第 4 个人大 2 岁。问第 4 个人岁数，他说比第 3 个
    //人大 2 岁。问第三个人，又说比第 2 人大两岁。问第 2 个人，说比第一个人大两岁。最后问第一个人，他
    //说是 10 岁。请问第五个人多大？
    public static void main(String[] args){
        int n=5;    //n为第几个人
        System.out.print(Age(n));
    }
    private static int Age(int n){
        if(n==1)
            return 10;
        else
            return Age(n-1)+2;
    }
}

24 【程序 24 根据输入求输出】
题目：给一个不多于 5 位的正整数，要求：一、求它是几位数，二、逆序打印出各位数字。

package GetInToOut24;

import java.util.Scanner;
public class GerInToOut {
    //题目：给一个不多于 5 位的正整数，要求：一、求它是几位数，二、逆序打印出各位数字。
    public static void main(String[] args){
        System.out.println("请输入一个不多于5位的正整数：");
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        System.out.println("它是"+GetBit(n)+"位数");
        System.out.println("逆序为"+GetInvert(n));
    }
    private static int GetBit(int n){   //得到n的位数
        if(n/10000>0){
            return 5;
        }else if(n/1000>0){
            return 4;
        }else if(n/100>0){
            return 3;
        }else if(n/10>0){
            return 2;
        }else{
            return 1;
        }
    }
    private static int GetInvert(int n){    //得到n的逆序
        int b = GetBit(n);
        int out=0;
        if(b==1){
            out=n;
        }else if(b==2){
            out=(n%10)*10+n/10;
        }else if(b==3){
            out=(n%10)*100+(n/10%10)*10+n/100;
        }else if(b==4){
            out=(n%10)*1000+(n%100/10)*100+(n/100%10)*10+n/1000;
        }else{
            out=(n%10)*10000+(n%100/10)*1000+(n/100%10)*100+(n/1000%10)*10+n/10000;
        }
        return out;
    }
}

25 【程序 25 求回文数】
题目：一个 5 位数，判断它是不是回文数。即 12321 是回文数，个位与万位相同，十位与千位相同。

package PalindromeNumber25;

import java.util.Scanner;
public class PalindromeNumber {
    //题目：一个 5 位数，判断它是不是回文数。即 12321 是回文数，个位与万位相同，十位与千位相同。
    public static void main(String[] args){
        System.out.println("请输入一个5位数：");
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        if(IsPalindrome(n))
            System.out.println(n+"是一个回文数");
        else
            System.out.println(n+"不是一个回文数");
    }
    private static boolean IsPalindrome(int n){
        if(n/10000==n%10 && (n/1000%10)==(n%100/10))    //万位=个位，千位=十位
            return true;
        else
            return false;
    }
}

26 【程序 26 求星期】
题目：请输入星期几的第一个字母来判断一下是星期几，如果第一个字母一样，则继续 判断第二个字母。
程序分析：用情况语句比较好，如果第一个字母一样，则判断用情况语句或 if 语句判断第二个字母。

方法一：利用map

import java.util.Scanner;
public class GetWeek {
    //题目：请输入星期几的第一个字母来判断一下是星期几，如果第一个字母一样，则继续 判断第二个字母。
    public static void main(String[] args){
        Map<String,String> map = new HashMap<String,String>();
        map.put("m","星期一");
        map.put("tu","星期二");
        map.put("w","星期三");
        map.put("th","星期四");
        map.put("f","星期五");
        map.put("sa","星期六");
        map.put("su","星期日");
        Scanner input = new Scanner(System.in);
        System.out.println("请输入星期几第一个字母：");
        String str= input.next();
        //方法二
        if(map.get(str)==null){
            System.out.println("目前无法判断，请输入第二个字母：");
            str= str + input.next();
            if(map.get(str)==null){
                System.out.println("输入字母匹配不到任意天，请检查。");
            }else
                System.out.println(map.get(str));
        }else
            System.out.println(map.get(str));

    }

　　

package GetWeek26;

import java.io.IOException;
import java.util.Scanner;
public class GetWeek {
    //题目：请输入星期几的第一个字母来判断一下是星期几，如果第一个字母一样，则继续 判断第二个字母。
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        System.out.println("请输入星期几第一个字母：");
        String str= input.next();
        char a = str.charAt(0);
        /*
        char a=' ';
        try{
            a = (char)System.in.read();
        }catch (IOException e){}
        */
        if(a=='M'||a=='m'){
            System.out.println("星期一");
        }else if(a=='W'||a=='w'){
            System.out.println("星期三");
        }else if(a=='F'||a=='f'){
            System.out.println("星期五");
        }else if(a=='T'||a=='t'||a=='S'||a=='s'){
            System.out.println("目前无法判断，请输入第二个字母：");
            String str1= input.next();
            char b= str1.charAt(0);
            /*
            char b=' ';
            try{
                b = (char)System.in.read();
            }catch (IOException e){}
            */
            if(a=='T'||a=='t'){
                if(b=='U'||b=='u'){
                    System.out.println("星期二");
                }else if(b=='H'||b=='h'){
                    System.out.println("星期四");
                }else{
                    System.out.println("输入字母匹配不到任意天，请检查。");
                }
            }
            if(a=='S'||a=='s'){
                if(b=='U'||b=='u'){
                    System.out.println("星期日");
                }else if(b=='A'||b=='a'){
                    System.out.println("星期六");
                }else{
                    System.out.println("输入字母匹配不到任意天，请检查。");
                }
            }
        }else{
            System.out.println("输入字母匹配不到任意天，请检查。");
        }
    }
}

其中注释部分写法有问题，无法正确读入b。原因是b会读入第一次敲得的回车导致结果出错。不知如何解决？

27 【程序 27 求素数】
题目：求 100 之内的素数

package FindPrimeNumber27;

public class FindPrimeNumber {
    //并输出100以内所有素数。
    public static void main(String[] args){
        int count=0;    //记录素数的个数
        int flag;       //flag为1则不是素数
        int i,j;        //用于for循环
        System.out.println("100以内的素数为：");
        for(i=2;i<=100;i++){
            int max = (int) Math.sqrt(i);
            flag=0;
            for(j=2;j<=max;j++){
                if(i%j==0){
                    flag=1;
                    break;
                }
            }
            if(flag==0){
                System.out.print(i+" ");
                count++;
            }
        }
        System.out.println("共有"+count+"个素数");
    }
}

28 【程序 28 排序算法】
题目：对 10 个数进行排序
程序分析：可以利用选择法，即从后 9 个比较过程中，选择一个最小的与第一个元素交换， 下次类推，即
用第二个元素与后 8 个进行比较，并进行交换。

package SelectSort28;
import java.util.Scanner;
public class SelectSort {
    //题目：对 10 个数进行排序(选择排序)
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        System.out.println("请输入10个数");
        int[] n = new int[10];
        for(int i=0;i<n.length;i++){       //读入10个数
            n[i] = input.nextInt();
        }
        int min,p=0,temp;     //min记录每趟最小的值，p记录最小值下表，temp用于交换
        for(int j=0;j<n.length-1;j++){        //循环n-1次
            min=n[j];
            for(int k=j+1;k<n.length;k++){     //从j+1开始遍历寻找最小值
                if(n[k]<min){
                    min=n[k];
                    p=k;
                }
            }
            if(p>j){                        //存在n[j]后的数比它小，则交换两者
                temp=n[j];
                n[j]=n[p];
                n[p]=temp;
                p=0;
            }
        }
        for(int i=0;i<n.length;i++){       //输出10个数
            System.out.print(n[i]+" ");
        }
    }
}

29 【程序 29 求矩阵对角线之和】
题目：求一个 3*3 矩阵对角线元素之和
程序分析：利用双重 for 循环控制输入二维数组，再将 a[i][i]累加后输出。

package RectangleMatrix29;

import java.util.Scanner;
public class RectangleMatrix {
    //题目：求一个 3*3 矩阵对角线元素之和
    public static void main(String[] args){
        System.out.println("请输入一个 3*3 矩阵(行优先)");
        Scanner input = new Scanner(System.in);
        int[][] n = new int[3][3];
        for(int i=0;i<3;i++){
            for(int j=0;j<3;j++){
                n[i][j] = input.nextInt();
            }
        }
        int sum=0;
        for(int k=0;k<3;k++){
            sum += n[k][k];
        }
        System.out.println("该矩阵对角线元素之和为："+sum);
    }
}

30 【程序 30 插入数字】
题目：有一个已经排好序的数组。现输入一个数，要求按原来的规律将它插入数组中。
程序分析：首先判断此数是否大于最后一个数，然后再考虑插入中间的数的情况，插入后此元素之后的数，
依次后移一个位置。

package InsertNumber30;

import java.util.ArrayList;
import java.util.Scanner;
public class InsertNumber {
    //题目：有一个已经排好序的数组。现输入一个数，要求按原来的规律将它插入数组中。(递增)
    public static void main(String[] args){
        ArrayList List = new ArrayList();
       // add()是添加一个新的元素, remove()删除一个元素, size()获得ArrayList的长度。
        for(int i=0;i<10;i++){      //初始化数组
            List.add(i);
        }
        System.out.println("初始数组为"+List);
        System.out.println("请输入一个数：");
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        int length=List.size();
//        if(n>= (int) List.get(length-1)){
//            List.add(n);
//        }
        for(int j=length-1;j>=0;j--){
            if(n < (int) List.get(j))
                continue;
            else{
                List.add(j+1,n);
                break;
            }
        }
        System.out.println("插入"+n+"后数组为"+List);
    }
}

31 【程序 31 数组逆序】
题目：将一个数组逆序输出。
程序分析：用第一个与最后一个交换。

package InvertedSequence31;

public class InvertedSequence {
    //题目：将一个数组逆序输出。
    public static void main(String[] args) {
        int lengh=10;
        int[] n = new int[lengh];
        System.out.print("原数组为：");
        for(int i=0,j=0;j<lengh;i+=2,j++){  //初始化数组
            n[j]=i;
            System.out.print(n[j]+" ");
        }
        int temp;
        for(int k=0;k<=(n.length-1)/2;k++){
            //交换前后两值
            temp = n[k];
            n[k] = n[n.length-1-k];
            n[n.length-1-k] = temp;
        }
        System.out.println();
        System.out.print("逆序数组为：");
        for(int j=0;j<n.length;j++){
            System.out.print(n[j]+" ");     //输出数组
        }
    }
}

32 【程序 32 左移右移】
题目：取一个整数 a 从右端开始的 4～7 位。
程序分析：可以这样考虑：
(1)先使 a 右移 4 位。
(2)设置一个低 4 位全为 1,其余全为 0 的数。可用~(~0<<4)
(3)将上面二者进行&运算。

package LMoveRMove32;

import java.util.Scanner;
public class LMoveRMove {
    //题目：取一个整数 a 从右端开始的 4～7 位。
    public static void main(String[] args){
        System.out.println("请输入一个不小于7位的数：");
        Scanner input = new Scanner(System.in);
        long a = input.nextLong();          //读入a
        String str = Long.toString(a);      //转换成String
        char[] n = str.toCharArray();       //转换成char数组
        int i = n.length;
        if(i<7){
            System.out.println("输入错误！");
        }else{
            for(int j=3;j>=0;j--)
            System.out.print(n[i-j-4]);
        }

    }
}

33 【程序 33 杨辉三角】
题目：打印出杨辉三角形（要求打印出 10 行如下图）
程序分析：
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1

package YangHuiTriangle33;

public class YangHuiTriangle {
    //题目：打印出杨辉三角形（要求打印出 10 行如下图）
    public static void main(String[] args){
        int n=10;
        int[][] HY= new int[n][n];
        for(int i=0;i<n;i++){
            //将杨辉三角存入HY二维数组
            for(int j=0;j<=i;j++){
                if(j==0){
                    HY[i][j]=1; //第一列的值均为1
                }else{
                    HY[i][j]=HY[i-1][j]+HY[i-1][j-1];   //每一个值均为上一行同一列的值+上一行左一列的值
                }
            }
        }
        for(int i=0;i<n;i++){
            //输出杨辉三角
            for(int j=1 ;j<n-i;j++){
                System.out.print(" ");
            }
            for(int k=0;k<n;k++){
                if(HY[i][k]>0){
                    System.out.print(HY[i][k]+" ");
                }
            }
            System.out.println();
        }
    }
}

34 【程序 34 三个数排序】
题目：输入 3 个数 a,b,c，按大小顺序输出。
程序分析：利用指针方法。

package Sort34;

import java.util.Scanner;
public class Sort {
    //题目：输入 3 个数 a,b,c，按大小顺序输出。
    public static void main(String[] args){
        System.out.println("请输入三个整数：");
        Scanner input=new Scanner(System.in);
        int a = input.nextInt();
        int b = input.nextInt();
        int c = input.nextInt();
        int max=a>b?(a>c?a:c):(b>c?b:c);
        int medium=a>b?(a<c?a:c):(b<c?b:c);
        int min=a<b?(a<c?a:c):(b<c?b:c);
        System.out.print(max+" "+medium+" "+min);
    }
}

35 【程序 35 最大最小交换】
题目：输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。

package ChangeMaxMin35;

import java.util.Scanner;
public class ChangeMaxMin {
    //题目：输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。
    public static void main(String[] args){
        //读入一个不确定长度的一维数组
        System.out.println("请输入一个数组：");
        Scanner input = new Scanner(System.in);
        String str = input.nextLine();      //读入一行string
        String[] s = str.split("\\s");      //根据空格进行分割
        int[] n = new int[s.length];
        for(int i=0;i<n.length;i++){
            n[i] = Integer.parseInt(s[i]);   //将string转为int型
        }

        int max=0,min=0;    //记录最大值和最小值得下标
        for(int j=0;j<n.length;j++){    //遍历数组，找到最大值和最小值下标
            if(n[j]>n[max]){
                max=j;
            }
            if(n[j]<n[min]){
                min=j;
            }
        }
        int temp;
        //交换时，注意最大最小值出现在两端的情况
        if(max>0){      //若最大值不是第一个，则交换
            temp=n[0];
            n[0]=n[max];
            n[max]=temp;
        }
        if(min==0){     //若最小值是第一个值，则需更新min值，因为最大值已经与第一个值交换。
            min=max;
        }
        if(min<n.length-1){ //若最小值不是最后一个，则交换
            temp=n[n.length-1];
            n[n.length-1]=n[min];
            n[min]=temp;
        }
        for(int i=0;i<n.length;i++){    //输出交换后的数组
            System.out.print(n[i]+" ");
        }
    }
}

36 【程序 36 移动位置】
题目：有 n 个整数，使其前面各数顺序向后移 m 个位置，最后 m 个数变成最前面的 m 个数

package MoveNumber36;

import java.util.Scanner;
public class MoveNumber {
    //题目：有 n 个整数，使其前面各数顺序向后移 m 个位置，最后 m 个数变成最前面的 m 个数
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        System.out.println("请输入若干个整数：");
        String str = input.nextLine();
        String[] s = str.split("\\s");
        int n = s.length;
        int[] arr = new int[n];
        for(int i=0;i<n;i++){
            arr[i] = Integer.parseInt(s[i]);
        }
        System.out.println("请输入移动的位数：");
        int m = input.nextInt();

        if(m>n){
            System.out.println("移动的位数过大超过数组长度！");
        }
        //辅助数组b,将数组arr的前n-m为存入b中
        int[] b = new int[n-m];
        for(int j=0;j<n-m;j++){
            b[j] = arr[j];
        }

        for(int k=0;k<m;k++){   //后m位数字前移
            arr[k]=arr[k+n-m];
        }
        for(int p=0;p<n-m;p++){ //前n-m位从b中移回arr中
            arr[p+m]=b[p];
        }

        for(int i=0;i<n;i++){   //输出移动后的数组
            System.out.print(arr[i]+" ");
        }
    }
}

37 【程序 37 报数】
题目：有 n 个人围成一圈，顺序排号。从第一个人开始报数（从 1 到 3 报数），凡报到 3 的人退出圈子，
问最后留下的是原来第几号的那位。

package CountOff37;

import java.util.ArrayList;
import java.util.Scanner;
public class CountOff {
    //题目：有 n 个人围成一圈，顺序排号。从第一个人开始报数（从 1 到 3 报数），凡报到 3 的人退出圈子，
    //问最后留下的是原来第几号的那位。
    public static void main(String[] args){
        System.out.println("请输入人数：");
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        ArrayList list= new ArrayList();    //定义动态数组
        for(int i=1;i<=n;i++){      //将号码存入动态数组list
            list.add(i);
        }
        System.out.println("初始编号为："+list);
        int length=list.size();
        for(int i=1,j=0;length>1;i++,j=(j+1)%length){
            //i从1-3循环计数，j为动态数组的下标，同步从0一直增加
            if(i==3){                   //数到3时，移除对应的人，同时从1重新数。
                list.remove(j);
                length = list.size();
                i=1;
            }
        }
        System.out.println("最后剩下的人是"+list.get(0));
    }
}

38 【程序 38 求字符串长度】
题目：写一个函数，求一个字符串的长度，在 main 函数中输入字符串，并输出其长度。

package LengthOfString38;

import java.util.Scanner;
public class LengthOfString {
    //题目：写一个函数，求一个字符串的长度，在 main 函数中输入字符串，并输出其长度。
    public static void main(String[] args){
        System.out.println("请输入一个字符串");
        Scanner input = new Scanner(System.in);
        String str = input.nextLine();
        System.out.println("该字符串的长度为"+getLength(str));
    }
    private static int getLength(String str){
        return str.length();
    }
}

39 【程序 39 分数累加】
题目：编写一个函数，输入 n 为偶数时，调用函数求 1/2+1/4+...+1/n,当输入 n 为奇数时，调用函数
1/1+1/3+...+1/n

package SumOfFraction39;

import java.util.Scanner;
public class SumOfFraction {
    //题目：编写一个函数，输入 n 为偶数时，调用函数求 1/2+1/4+...+1/n,当输入 n 为奇数时，调用函数
    //1/1+1/3+...+1/n
    public static void main(String[] args){
        System.out.print("请输入n：");
        Scanner input = new Scanner(System.in);
        double n = input.nextDouble();
        System.out.print("分数之和为：");
        if(n%2==0){ //n为偶数
            System.out.println(even(n));
        }else{      //n为奇数
            System.out.println(odd(n));
        }
    }
    private static double even(double n){
        double sum = 0;
        for(double i=2;i<=n;i+=2){
            sum += 1/i;
        }
        return sum;
    }
    private static double odd(double n){
        double sum = 0;
        for(double i=1;i<=n;i+=2){
            sum += 1/i;
        }
        return sum;
    }
}

40 【程序 40 字符串排序】
题目：字符串排序。

package SortOfString40;

import java.util.Scanner;
public class SortOfString {
    //题目：字符串排序。
    public static void main(String[] args) {
        System.out.print("请输入一个字符串:");
        Scanner input = new Scanner(System.in);
        String str = input.nextLine();
        System.out.println("排序后的字符串为："+sort(str));
    }
    private static String sort(String str){
        char[] c = str.toCharArray();
        int L =c.length;
        //采用冒泡排序
        boolean flag;
        char temp;
        for(int i=0;i<L-1;i++){
            flag=false;
            for(int j=L-1;j>0;j--){
                if(c[j-1]>c[j]){
                    temp=c[j];
                    c[j]=c[j-1];
                    c[j-1]=temp;
                    flag=true;
                }
            }
            if(flag==false){
                break;
            }
        }
        //再次将字符数组转换为字符串，也可以直接利用String.valueOf(c)转换
        String str1 = new String(c);
        return str1;
//        String str2 = String.valueOf(c);
//        return str2;
    }
}

41 【程序 41 猴子分桃】
题目：海滩上有一堆桃子，五只猴子来分。第一只猴子把这堆桃子凭据分为五份，多了一个，这只猴子把
多的一个扔入海中，拿走了一份。第二只猴子把剩下的桃子又平均分成五份，又多了一个，它同样把多的
一个扔入海中，拿走了一份，第三、第四、第五只猴子都是这样做的，问海滩上原来最少有多少个桃子？

package MonkeySplitPeach40;

public class MonkeySplitPeach {
    //题目：海滩上有一堆桃子，五只猴子来分。第一只猴子把这堆桃子凭据分为五份，多了一个，这只猴子把
    //多的一个扔入海中，拿走了一份。第二只猴子把剩下的桃子又平均分成五份，又多了一个，它同样把多的
    //一个扔入海中，拿走了一份，第三、第四、第五只猴子都是这样做的，问海滩上原来最少有多少个桃子？
    public static void main(String[] args) {
        int n=5;            //总共5只猴子
        int i;              //用于for循环
        int x;              //最后一个猴子分到的数目
        double sum;         //每一轮分配前的数目
        for(x=1;;x++){                  //x为最后一个猴子分到的数量，从1开始遍历
            sum = 5*x+1;                //最后一只猴子分配前的总数
            for(i=1;i<n;i++){
                sum = (5.0/4.0)*sum+1;  //上一轮分配前的总数
                if((int)sum != sum){    //若该数不是整数
                    i=1;
                    break;
                }
            }
            if(i==n)
                break;
        }
        System.out.println("最后一个猴子分到的数目:"+x);
        System.out.println("海滩上原来最少有"+(int)sum+"个桃子");
    }
}

42 【程序 42 求数字】
题目： 809*??=800*??+9*??+1
其中??代表的两位数,8*??的结果为两位数， 9*??的结果为 3 位数。求??代表的两位数，及 809*??后的结
果。

package FindNumber42;

public class FindNumber {
    //题目： 809*??=800*??+9*??+1
    public static void main(String[] args) {
        int x=0,i;
        boolean flag=false;
        for(i=10;i<100;i++){
            if(8*i<100 && 9*i>99 ){
                if(809*i==800*i+9*i+1){
                    x=i;
                    flag=true;
                    break;
                }
            }
        }
        if (flag){
            System.out.println("??是"+x);
            System.out.println("809*??="+809*x);
        }else{
            System.out.println("无解");
        }

    }
}

疑问：这个等式显然无解。

43 【程序 43 求奇数个数】
题目：求 0—7 所能组成的奇数个数。

package OddNumber43;

public class OddNumber {
    //题目：求 0—7 所能组成的奇数个数。
    public static void main(String[] args) {
        sum1(8);
        sum2(8);
    }
    private static void sum1(int n){
        //可重复
        int sum = 0,total = 0;
        for(int i=1; i<=n; i++){ //最大位数为8位
            //4*7*8*8*8*8*8*8
            if(i == 1 ){
                total = 4;  // 1,3,5,7
            }else if(i ==2){
                total = total*7;
            }else{
                total *= 8;
            }
            System.out.println("0~7组成" + i + "位数，有：" + total + "个");
            sum += total;
        }
        System.out.println("总计为：" + sum);
    }
    private static void sum2(int n){
        //不可重复
        int sum = 0,total = 0;
        for(int i=1; i<=n; i++){ //最大位数为8位
            //4*6*6*5*4*3*2*1
            if(i == 1 ){
                total = 4;  // 1,3,5,7
            }else if(i ==2){
                total = total*6;
            }else{
                total *= (n+1-i);
            }
            System.out.println("0~7组成" + i + "位数，有：" + total + "个");
            sum += total;
        }
        System.out.println("总计为：" + sum);
    }
}

疑问：不是很懂题目意思？？

44 【程序 44 偶数的素数和】
题目：一个偶数总能表示为两个素数之和。

package EvenEqualSumOfPrime44;

import java.util.Scanner;
import java.util.ArrayList;
public class EvenEqualSumOfPrime {
    //题目：一个偶数总能表示为两个素数之和。
    public static void main(String[] args) {
        System.out.print("请输入一个偶数:");
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        //用动态数组x,y记录分解的素数，因为有多种可能
        ArrayList x = new ArrayList();
        ArrayList y = new ArrayList();
        for(int i=2;i<=n/2;i++){
            if(IsPrime(i)){
                int j=n-i;
                if(IsPrime(j)){     //符合条件则加入数组x，y；
                    x.add(i);
                    y.add(j);
                }
            }
        }
        for(int k=0;k<x.size();k++){    //输出结果
            System.out.println(n+"="+x.get(k)+"+"+y.get(k));
        }
    }

    private static boolean IsPrime(int n){  //判断n是否是素数
            int max = (int) Math.sqrt(n);
            int flag=0;
            for(int j=2;j<=max;j++){
                if(n%j==0){
                    flag=1;
                    break;
                }
            }
            if(flag==0){
                return true;
            }
            return false;
    }
}

45 【程序 45 被 9 整除】
题目：判断一个素数能被几个 9 整除

package DivideByNine45;

import java.util.Scanner;
public class DivideByNine {
    public static void main(String[] args) {
        System.out.print("请输入一个素数:");
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        if(IsPrime(n)==false){
            System.out.println("您输入的数不是素数，请重新输入");
        }else{
            if(count(n)==0){
                System.out.println(n+"不能被9整除");
            }else{
                System.out.println(n+"能被"+count(n)+"个9整除");
            }
        }
    }
    private static boolean IsPrime(int n){  //判断n是否是素数
        int max = (int) Math.sqrt(n);
        int flag=0;
        for(int j=2;j<=max;j++){
            if(n%j==0){
                flag=1;
                break;
            }
        }
        if(flag==0){
            return true;
        }
        return false;
    }

    private static int count(int n){    //被9整除的个数
        int count=0;
        while(n%9==0){
            n=n/9;
            count++;
        }
        return count;
    }
}　

疑问：素数怎么可能被9整除？？

46 【程序 46 字符串连接】
题目：两个字符串连接程序

package ConnectTwoString46;

import java.util.Scanner;
public class ConnectTwoString {
    //题目：两个字符串连接程序
    public static void main(String[] args) {
        System.out.println("请输入两个字符串:");
        Scanner input = new Scanner(System.in);
        //读入两个字符串
        String str1 = input.nextLine();
        String str2 = input.nextLine();
        //字符串转换为字符数组
        char[] c1 = str1.toCharArray();
        char[] c2 = str2.toCharArray();
        char[] c = new char[c1.length+c2.length];   //用于存放连接的字符数组
        for(int i=0;i<c1.length;i++){
            c[i]=c1[i];
        }
        for(int j=0;j<c2.length;j++){
            c[j+c1.length]=c2[j];
        }
        //将连接后的新字符数组转换成字符串，输出
        String str = new String(c);
        System.out.println("连接后的字符串为:"+str);
    }
}

47 【程序 47 打印星号】
题目：读取 7 个数（ 1—50）的整数值，每读取一个值，程序打印出该值个数的＊。

package PrintStar47;

import java.util.Scanner;
public class PrintStar {
    //题目：读取 7 个数（ 1—50）的整数值，每读取一个值，程序打印出该值个数的＊。
    public static void main(String[] args) {
        System.out.println("请输入七个(1--50)整数:");
        Scanner input = new Scanner(System.in);
        int n;
        for(int i=0;i<7;i++){
            n = input.nextInt();
            for(int j=0;j<n;j++){
                System.out.print("*");
            }
            System.out.println();
        }
    }

}

48 【程序 48 加密】
题目：某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，加密
规则如下：每位数字都加上 5,然后用和除以 10 的余数代替该数字，再将第一位和第四位交
换，第二位和第三位交换。

package Encryption48;

import java.util.Scanner;
public class Encryption {
    //题目：某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，加密
    //规则如下：每位数字都加上 5,然后用和除以 10 的余数代替该数字，再将第一位和第四位交
    //换，第二位和第三位交换。
    public static void main(String[] args) {
        System.out.println("请要传递的四位整数:");
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        int[] a = {n/1000,n/100%10,n%100/10,n%100}; //将n的各位存入a数组
        for(int i=0;i<a.length;i++){
            //加密
            a[i] = (a[i]+5)%10;
        }
        //交换一四位，二三位
        int temp;
        temp=a[0];
        a[0]=a[3];
        a[3]=temp;
        temp=a[1];
        a[1]=a[2];
        a[2]=temp;
        //输出加密后的数字
        System.out.print("加密后的数字为");
        //int n1=0;
        for(int j=0;j<a.length;j++){
            //n1 =  n1 + a[j]*(int)Math.pow(10,a.length-1-j);
            System.out.print(a[j]);
        }
        //System.out.println(n1);
    }
}

49 【程序 49 子串出现的个数】
题目：计算字符串中子串出现的次数

package SubstringNumber49;

import java.util.Scanner;
public class SubstringNumber {
    //题目：计算字符串中子串出现的次数
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入一个整串：");
        String str1= input.nextLine();
        System.out.println("请输入一个子串：");
        String str2= input.nextLine();
        System.out.println("字符串中子串出现的次数为："+count(str1,str2));
        System.out.println("字符串中子串出现的次数为："+count2(str1,str2));
    }
    //方法一：采用split
    private static int count(String str1,String str2){  //str1为整串，str2位子串
        str1 = " "+str1+" ";        //母串两端补空格，防止子串出现在两端时计数出错。
        String[] c = str1.split(str2);
        return c.length-1;
    }
    //方法二：利用indexOf
    private static int count2(String str1,String str2){  //str1为整串，str2位子串
        int count=0;
        int d=0;
        if(str1.contains(str2)==false){
            count=0;
        }else{
            while((d=str1.indexOf(str2,d))!=-1){        //匹配到子串
                str1 = str1.substring(d+str2.length()); //得到匹配子串位置后面的字符串
                count++;
            }
        }
        return count;
    }
}

50 【程序 50 文件 IO】
题目：有五个学生，每个学生有 3 门课的成绩，从键盘输入以上数据（包括学生号，姓名，三门课成绩），
计算出平均成绩， 将原有的数据和计算出的平均分数存放在磁盘文件"stud"中。

package FileIO50;

import java.io.*;
public class FileIO {
    //题目：有五个学生，每个学生有 3 门课的成绩，从键盘输入以上数据（包括学生号，姓名，三门课成绩），
    //计算出平均成绩， 将原有的数据和计算出的平均分数存放在磁盘文件"stud"中。
    //定义学生模型
    String[] number = new String[5];
    String[] name = new String[5];
    float[][] grade = new float[5][3];
    float[] sum = new float[5];
    public static void main(String[] args) {
        FileIO stud = new FileIO();
        try {
            stud.input();
            stud.output();
        }catch(IOException e){}
    }

    //输入学号、姓名、成绩
    void input() throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        try{
            for(int i=0;i<5;i++){
                System.out.print("请输入学号：");
                number[i] = br.readLine();
                System.out.print("请输入姓名：");
                name[i] = br.readLine();
                for(int j=0;j<3;j++){
                    System.out.print("请输入第"+(j+1)+"门课成绩：");
                    grade[i][j] = Integer.parseInt(br.readLine());
                }
                System.out.println();
                sum[i] = grade[i][0]+grade[i][1]+grade[i][2];
            }
        }catch(NumberFormatException e){
            System.out.println("请输入一个数字！");
        }
    }

    //输出文件
    void output() throws IOException{
        FileWriter fw = new FileWriter("stud.txt");
        BufferedWriter bw = new BufferedWriter(fw);
        bw.write("学号"+"\t"+"姓名"+"\t"+"成绩1"+"\t"+"成绩2 "+"\t"+"成绩3 "+"\t"+"平均成绩");
        bw.newLine();
        for(int i=0;i<5;i++){
            bw.write(number[i]+"\t");
            bw.write("  "+name[i]+"\t");
            for(int j=0;j<3;j++)
                bw.write("  "+grade[i][j]+"\t");
            bw.write("  "+(sum[i]/3)+"\t");
            bw.newLine();
        }
        bw.close();
    }
}

　　

}