Java基础练习50个，附上源代码

Java基础练习50个，附上源代码

介绍

最近有点闲，找了50个Java基础题型过了一遍Java语法，发现原blog里有一些问题，故把自己的解答分享出来。题目都比较简单，初学者可以看一下,附上源文件链接,点这里

1 兔子数列

题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子， 小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子对数为多少？

/**
 * @ahthor keli
 * 题目：古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，
 * 小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子对数为多少？
 * 程序分析：兔子的规律为数列1,1,2,3,5,8,13,21….
 */
import java.util.Scanner;
public class JavaTest01 {
    public static void main(String[] args){
        System.out.println("请输入第多少月");
        Scanner cin=new  Scanner(System.in);
        int month=cin.nextInt();
        System.out.println("第"+month+"个月，兔子有"+f(month)+"对");
    }
    static int f(int n){
        //n时有多少对兔子
        if(n==1||n==2){
            return 1;
        }else{
            return f(n-1)+f(n-2);
        }

    }
}

2 判断101-200之间有多少个素数，并输出所有素数。

题目：判断101-200之间有多少个素数，并输出所有素数。

/**
 * @author keli
 * 题目：判断101-200之间有多少个素数，并输出所有素数。
 */
public class JavaTest02 {
    public static void main(String[] args){
        int count=0;
        for(int i=101;i<=200;++i){
            if(isPrime(i)){
                count++;
                System.out.print(i+"\t");
            }
        }
        System.out.println("\n101到200共有素数"+count+"个");
    }
    private static boolean isPrime(int n){
        //判断是否是素数
        if(n<=1){
            return false;
        }else if(n==2){
            return true;
        }else{
            for(int i=2;i<=Math.sqrt(n);++i){
                //除了1和本身外之外还有其他的因子
                if(n%i==0)
                    return false;
            }
            return true;
        }
    }
}

3 打印出所有的”水仙花数”

题目：打印出所有的”水仙花数”，所谓”水仙花数”是指一个三位数，其各位数字立方和等于该数本身。

/**
 * @author keli
 * 题目：打印出所有的”水仙花数”，所谓”水仙花数”是指一个三位数，
 * 其各位数字立方和等于该数本身。例如：153是一个”水仙花数”，
 * 因为153=1的三次方＋5的三次方＋3的三次方。
 * 程序分析：利用for循环控制100-999个数，每个数分解出个位，十位，百位。
 */
public class JavaTest03 {
    public static void  main(String[] args){
        System.out.println("水仙花数有：");
        int count=0;//计数
        for(int i=100;i<=999;++i){
            int hundred=i/100;//百位
            int ten=(i/10)%10;//十位
            int bite=i%10;//个位
            if(i==bite*bite*bite+ten*ten*ten+hundred*hundred*hundred){
                System.out.print(i+"\t");
                count++;
            }
        }
        System.out.println("\n水仙花数共有"+count+"个");
    }
}

4 将一个正整数分解质因数

题目：将一个正整数分解质因数。例如：输入90,打印出90=233*5。

/**
 * @author keli
 * 题目：将一个正整数分解质因数。例如：输入90,打印出90=2*3*3*5。
 * 例如输入90,打印出90=2*3*3*5。
 */
import  java.util.Scanner;
public class JavaTest04 {
    public static void main(String[] args){
        System.out.println("请输入正整数");
        Scanner cin=new Scanner(System.in);
        int n=cin.nextInt();
        System.out.print("\n"+n+"=");
        for(int i=2;i<=n;i++){
            while(n%i==0&&n!=i){
                n=n/i;
                System.out.print(i+"*");
            }
            if(n==i){
                //上面的都不能整除，说明这是个质数
                System.out.print(i);
            }
        }
        cin.close();
    }
}

5 利用条件运算符的嵌套区分成绩

题目：利用条件运算符的嵌套来完成此题：学习成绩>=90分的同学用A表示，60-89分之间的用B表示，60分以下的用C表示。

/**
 * @author keli
 * 题目：利用条件运算符的嵌套来完成此题：学习成绩>=90分的同学用A表示，60-89分之间的用B表示，60分以下的用C表示。
 */
import java.util.Scanner;
public class JavaTest05 {
    public static void main(String[] args){
        System.out.println("请输入你的分数");
        Scanner cin=new Scanner(System.in);
        double grade=cin.nextDouble();
        System.out.print(grade+"分数等级是");
        System.out.println((grade>=90?"A":((grade>=60)?"B":"C")));
    }
}

6 输入两个正整数m和n，求其最大公约数和最小公倍数。

题目：输入两个正整数m和n，求其最大公约数和最小公倍数。

/**
 * @author keli
 * 题目：输入两个正整数m和n，求其最大公约数和最小公倍数。
 * 程序分析：利用辗除法。
 */
import java.util.Scanner;
public class JavaTest06 {
    //先求出最大公约数greatestCommonDivisor
    //最小公倍数LeastCommonMultiple=a*b/greatestCommonDivisor
    public static void main(String[] args){
        System.out.println("请输入两个正整数");
        Scanner cin=new Scanner(System.in);
        int a=cin.nextInt();
        int b=cin.nextInt();
        int greatestCommonDivisor=f(a,b);
        int leastCommonMultiple=a*b/f(a,b);
        System.out.println(a+"和"+b+"的最大公约数为"+greatestCommonDivisor);
        System.out.println("最小公倍数为"+leastCommonMultiple);
    }
    public static int f(int a,int b){
        //辗转相除法求最大公约数
        int temp=1;
        if(a<b){
            //确定第一个数是大数
            temp=a;
            a=b;
            b=temp;
        }
        while(a%b!=0){
            temp=a%b;
            a=b;
            b=temp;
        }
        return b;
    }
}

7 输入一行字符，分别统计出其英文字母、空格、数字和其它字符的个数

输入一行字符，分别统计出其英文字母、空格、数字和其它字符的个数

/**
 * @author keli
 * 输入一行字符，分别统计出其英文字母、空格、数字和其它字符的个数
 * -按行输入字符串string=scanner.netxLine();
 * -把字符串赋值给一个字符数组 char[] arr=string.toCharArray();
 * -string.charAt(i)是返回字符串的第几个字符，从0开始，0=
public class JavaTest07 {
    public static void main(String[] args){
        java.util.Scanner scanner=new java.util.Scanner(System.in);
        String string=scanner.nextLine();//输入一行字符串
        char[] arr=string.toCharArray();//字符串复赋值给字符数组
        int number=0;//数字
        int letter=0;//字母
        int space=0;//空格
        int other=0;//其他字符
        for(int i=0;i<string.length();++i){
            if(string.charAt(i)>='0'&&string.charAt(i)<='9'){
                number++;
                continue;
            }else if((arr[i]>='a'&&arr[i]<='z')||(arr[i]>='A'&&arr[i]<='Z')){
                letter++;
                continue;
            }else if(arr[i]==' '){
                space++;
                continue;
            }else{
                other++;
            }
        }
        System.out.println("数字有"+number+"个");
        System.out.println("字母有"+letter+"个");
        System.out.println("空格有"+space+"个");
        System.out.println("其它字符有"+other+"个");
    }
}

8 求s=a+aa+aaa+aaaa+aa…a的值

题目：求s=a+aa+aaa+aaaa+aa…a的值，其中a是一个数字。

/**
 * @author keli
 * 题目：求s=a+aa+aaa+aaaa+aa…a的值，其中a是一个数字。
 * 例如2+22+222+2222+22222(此时共有5个数相加)，几个数相加有键盘控制。
 * 输出结果的形式如：2+22+222=246；
 */
import java.util.Scanner;
public class JavaTest08 {
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入a和n的值");
        int a=scanner.nextInt();
        int n=scanner.nextInt();
        int sum=0;
        int b=0;//b存储每次的数字
        for(int i=0;i<n-1;++i){
            //这里输出前n-1个数字和加号
            b+=Math.pow(10,i)*a;
            sum+=b;
            System.out.print(b+"+");
        }
        b+=Math.pow(10,n-1)*a;
        sum+=b;
        System.out.print(b+"="+sum);
    }
}

9 编程找出1000以内的所有完数

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

/**
 * @author keli
 * 题目：一个数如果恰好等于它的因子之和，这个数就称为”完数”。例如6=1＋2＋3.编程找出1000以内的所有完数。
 */
public class JavaTest09 {
    public static void main(String[] args){
        f(1000);
    }
    public static void f(int n){
        //输出n以内的所有完数
        for(int i=2;i<=n;i++){
            //第一层循环，n个数
            int sum=0;
            for(int j=1;j<i;++j){
                //第二层循环，遍历因子
               if(i%j==0){
                   sum+=j;
               }
            }
            if(sum==i)
                System.out.print(i+"\t");
        }
    }
}

10 球从h米高度自由落下，每次落地后反跳回原高度的一半

题目：一球从h米高度自由落下，每次落地后反跳回原高度的一半再落下，求它在 第n次落地时，共经过多少米？第n次反弹多高？

/**
 * @author keli
 * 题目：一球从h米高度自由落下，每次落地后反跳回原高度的一半再落下，
 * 求它在 第n次落地时，共经过多少米？第n次反弹多高？
 */
public class JavaTest10 {
    public static void main(String[] args){
        System.out.println("请输入落地高度h和次数n");
        java.util.Scanner scanner=new java.util.Scanner(System.in);
        double h=scanner.nextDouble();
        int n=scanner.nextInt();
        double sum=0;
        sum+=h;//第一次只有下落
        for(int i=1;i<n;++i){
            h*=0.5;
            sum+=h*2;
        }
        //求第n次反弹，还得再除以二
        System.out.print("第"+n+"次落地时，共经过"+sum+"米，第n次反弹"+h/2.0+"米");
    }
}

11 有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数

题目：有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？

/**
* @quthor keli
* 题目：有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？都是多少？
* 程序分析：可填在百位、十位、个位的数字都是1、2、3、4。这里要用3个for循环
*/
public class JavaTest11 {
   public static void main(String[] args){
       int count=0;
       for(int hundred=1;hundred<=4;++hundred){
           for(int ten=1;ten<=4;++ten){
               for(int bite=1;bite<=4;++bite){
                   if(bite!=ten&&ten!=hundred&&bite!=hundred){
                       count++;
                       int a=hundred*100+ten*10+bite*1;
                       System.out.print(a+"\t");
                   }
               }
           }
       }
       System.out.print("\n共有"+count+"个");
   }
}

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，求应发放奖金总数？

/**
 * @author keli
 * 题目：企业发放的奖金根据利润提成。
 * 利润(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，求应发放奖金总数？
 */
public class JavaTest12 {
    public static void main(String[] args){
        java.util.Scanner scanner=new java.util.Scanner(System.in);
        System.out.println("请输入当月利润总额");
        double i=scanner.nextDouble();
        System.out.println("当月利润为"+i+"万元时，应发放奖金总额为"+f(i)+"万元");
    }
    public static double f(double i){
        //形参是利润，返回奖金
        double bonus=0;
        if(i<=10){
            bonus=i*0.1;
        }else if(i>10&&i<=20){
            bonus=(i-10)*0.075+1;
        }else if(i>20&&i<=40){
            bonus=(i-20)*0.05+1+10*0.075;
        }else if(i>40&&i<=60){
            bonus=(i-40)*0.03+1+10*0.075+20*0.05;
        }else if(i>60&&i<=100){
            bonus=(i-60)*0.015+1+10*0.075+20*0.05+20*0.03;
        }else{
            bonus=(i-100)*0.01+1+10*0.075+20*0.05+20*0.03+40*0.015;
        }
        return bonus;
    }
}

13 个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少

题目：一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？

/**
 * @ahthor keli
 * 题目：一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？
 * 程序分析：在10万以内判断，
 */
public class JavaTest13 {
    public static void main(String[] args){
        for(int i=1;i<10000;++i){
            if(isSquare(i+100)&&isSquare(i+168)){
                System.out.print("该数字是"+i);
            }
        }
    }
    public static boolean isSquare(int n){
        //判断一个一万以内的数是不是完全平方数
        for(int i=2;i<=100;++i){
            if(i*i==n)
                return true;
        }
        return false;
    }
}

14 输入某年某月某日，判断这一天是这一年的第几天？

题目：输入某年某月某日，判断这一天是这一年的第几天？

/**
 * @author keli
 * 题目：输入某年某月某日，判断这一天是这一年的第几天？
 */
public class JavaTest14 {
    public static void main(String[] args){
        int[] arr={0,31,28,31,30,31,30,31,31,30,31,30,31};
        System.out.println("请输入年月日，用空格隔开");
        java.util.Scanner scanner=new java.util.Scanner(System.in);
        int year=scanner.nextInt();
        int month=scanner.nextInt();
        int day=scanner.nextInt();
        int sum=0;//储存第多少天
        for(int i=1;i<month;i++)
            sum+=arr[i];
        if(isLeapYear(year)&&month>=3)
            sum+=28;//闰年二月有两个
        sum+=day;//加上当前月份的天数
        System.out.println(year+"年"+month+"月"+day+"日是这一年的第"+sum+"天");
    }
    public static boolean isLeapYear(int n){
        //判断是否为闰年
        //闰年的条件是年份能被400整除，或者是年份能被4整除但不能被100整除
        if(n%400==0||(n%4==0&&n%100!=0))
            return true;
        else
            return false;
    }
}

15 输入三个整数x,y,z，请把这三个数由小到大输出。

题目：输入三个整数x,y,z，请把这三个数由小到大输出。

/**
 * @author keli
 * 题目：输入三个整数x,y,z，请把这三个数由小到大输出。
 */
public class JavaTest15 {
    public static void main(String[] args){
        int x,y,z;
        java.util.Scanner scanner=new java.util.Scanner(System.in);
        System.out.println("请输入三个整数，以空格隔开");
        x=scanner.nextInt();
        y=scanner.nextInt();
        z=scanner.nextInt();
        if(x>y){
            int temp=x;
            x=y;
            y=temp;
        }
        if(y>z){
            int temp=y;
            y=z;
            z=temp;
        }
        if(x>y){
            int temp=x;
            x=y;
            y=temp;
        }
        System.out.println("从小到大的顺序为:"+x+" "+y+" "+z);
    }
}

16 输出9*9口诀。

题目：输出9*9口诀。

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

17 猴子吃桃问题

题目：猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个
第二天早上又将剩下的桃子吃掉一半，又多吃了一个。 以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。

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

18 两个乒乓球队进行比赛问题

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

/**
 * @author keli
 * 题目：两个乒乓球队进行比赛，各出三人。甲队为a,b,c三人，乙队为x,y,z三人。
 * 已抽签决定比赛名单。有人向队员打听比赛的名单。a说他不和x比，c说他不和x,z比，请编程序找出三队赛手的名单
 */
public class JavaTest18 {
    public static void main(String[] args){
        for(char i='x';i<='z';++i){
            for(char j='x';j<='z';++j){
                for(char k='x';k<='z';++k){
                    if(i!=j&&j!=k&&i!=k){//选手不能重复
                        if(i!='x'&&k!='x'&&k!='z'){//i代表a的对手，不能是x；k代表c的对手，不能是x和z
                            System.out.println("a的对手是"+i+" b的对手是"+j+" c的对手是"+k);
                        }
                    }
                }
            }
        }
    }
}

19 打印出如下图案（菱形）

题目：打印出如下图案（菱形） 1 3 5 7 5 3 1个星号居中

/**
 * @author keli
 * 题目：打印出如下图案（菱形）
 * 1 3 5 7 5 3 1个星号居中
 */
public class JavaTest19 {
    public static void main(String[] args){
        for(int i=0;i<=3;++i){//上半部分
            for(int j=3-i;j>0;--j){
                System.out.print(" ");
            }
            for(int k=2*(3-i)+1;k<=7;++k){
                System.out.print("*");
            }
            for(int j=3-i;j>0;--j){
                System.out.print(" ");
            }
            System.out.println();
        }
        for(int i=0;i<3;++i){//下半部分
            for(int j=3-i;j<=3;++j){
                System.out.print(" ");
            }
            for(int j=0;j<2*(3-i)-1;++j){
                System.out.print("*");
            }
            for(int j=3-i;j<=3;++j){
                System.out.print(" ");
            }
            System.out.println();
        }

    }
}

20 求出分数数列的前20项之和

题目：有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13…求出这个数列的前20项之和。

/**
 * @author keli
 * 题目：有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13…求出这个数列的前20项之和。
 */
public class JavaTest20 {
    public static void main(String[] args){
        int count=0;//计数，5个换一行
        for(int i=1;i<=20;i++){
            count++;
            System.out.print(f(i+1)+"/"+f(i)+"\t");
            if(count==5){
                count=0;
                System.out.println();
            }
        }
    }
    public static int f(int n){
        //返回斐波那契数列的第n项数
        int[] dp=new int[101];
        //将斐波那契数列储存在arr中，只储存前100项
        dp[1]=1;
        dp[2]=2;
        for(int i=3;i<=100;++i){
            dp[i]=dp[i-1]+dp[i-2];
        }
        return dp[n];
    }
}

21 求1+2!+3!+…+20!的和

题目：求1+2!+3!+…+20!的和

/**
 * @author keli
 * 题目：求1+2!+3!+…+20!的和
 */
public class JavaTest21 {
    public static void main(String[] args){
        System.out.print("和为"+f(20));
    }
    public static int f(int n){
        //返回前n项阶乘的和
        int sum=0;
        for(int i=1;i<=n;++i){
            int multiple=1;
            for(int j=i;j>1;--j){
                multiple*=j;
            }
            sum+=multiple;
        }
        return sum;
    }
}

22 利用递归方法求5!。

题目：利用递归方法求5!。

/**
 * @author keli
 * 题目：利用递归方法求5!。
 */
public class JavaTest22 {
    public static void main(String[] args){
        System.out.print("和为"+f(5));
    }
    public static int f(int n){
        //递归求n的阶乘
        if(n==1)
            return 1;
        else
            return n*f(n-1);
    }
}

23 有5个人坐在一起，问第五个人多少岁？

题目：有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。问第4个人岁数，他说比第3个人大2岁。 问第三个人，又说比第2人大两岁。问第2个人，说比第一个人大两岁. 最后问第一个人，他说是10岁。请问第五个人多大？

/**
 * @author keli
 * 题目：有5个人坐在一起，问第五个人多少岁？
 * 他说比第4个人大2岁。问第4个人岁数，他说比第3个人大2岁。
 * 问第三个人，又说比第2人大两岁。问第2个人，说比第一个人大两岁。
 * 最后问第一个人，他说是10岁。请问第五个人多大？
 */
public class JavaTest23 {
    public static void main(String[] args){
        System.out.println("第五个人年龄为"+getAge(5));
    }
    public static int getAge(int n){
        //返回第n个人的年龄，递归求解
        if(n==1)
            return 10;
        return getAge(n-1)+2;
    }
}

24 给一个不多于5位的正整数，要求：一、求它是几位数，二、逆序打印出各位数字

题目：给一个不多于5位的正整数，要求：一、求它是几位数，二、逆序打印出各位数字。

/**
 * @author keli
 * 题目：给一个不多于5位的正整数，要求：一、求它是几位数，二、逆序打印出各位数字。
 */
public class JavaTest24 {
    public static void main(String[] args){
        int n;
        java.util.Scanner scanner=new java.util.Scanner(System.in);
        System.out.println("请输入一个不多于五位的正整数");
        n=scanner.nextInt();
        int nn=n;//nn用来保存n的值，方便最后输出
        int[] arr=new int[6];//用来储存位数，12345分别代表个十百千万
        int i=1;
        while(n!=0){
            arr[i]=n%10;
            n/=10;
            ++i;
        }
        System.out.print(nn+"是"+(i-1)+"位数\n"+"逆序输出为");
        for(int j=1;j<i;++j)
            System.out.print(arr[j]);
    }
}

25 一个5位数，判断它是不是回文数

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

/**
 * @author keli
 * 题目：一个5位数，判断它是不是回文数。即12321是回文数，个位与万位相同，十位与千位相同。
 */
public class JavaTest25 {
    public static void main(String[] args){
        System.out.println("请输入一个五位整数");
        java.util.Scanner scanner=new java.util.Scanner(System.in);
        int n=scanner.nextInt();
        System.out.print(n);
        if(isHuiWenNumber(n)){
            System.out.print("是回文数");
        }else{
            System.out.print("不是回文数");
        }
    }
    public static boolean isHuiWenNumber(int n){
        //判断一个五位整数是不是回文数
        int[] arr=new int[6];//arr存储位数，12345分别是个十百千万位
        int i=1;
        while(n!=0){
            arr[i]=n%10;
            n/=10;
            ++i;
        }
        if(arr[1]==arr[5]&&arr[2]==arr[4])
            return true;
        return false;
    }
}

26 输入星期几的第一个字母来判断一下是星期几

题目：请输入星期几的第一个字母来判断一下是星期几，如果第一个字母一样，则继续判断第二个字母。

/**
 * @author keli
 * 题目：请输入星期几的第一个字母来判断一下是星期几，如果第一个字母一样，则继续判断第二个字母。
 * 使用case语句
 */
public class JavaTest26 {
    public static void main(String[] args){
        System.out.println("请输入第一个字母");
        java.util.Scanner scanner=new java.util.Scanner(System.in);
        String firstWord=scanner.next();
        String secondWord;
        switch(firstWord){
            case "m":
                System.out.println("Monday");
                break;
            case "w":
                System.out.println("Wednesday");
                break;
            case "f":
                System.out.println("Friday");
                break;
            case "t":
                System.out.println("请输入第二个字母");
                secondWord=scanner.next();
                switch(secondWord){
                    case "u":
                        System.out.println("Tuesday");
                        break;
                    case "h":
                        System.out.println("Thursday");
                        break;
                    default:
                        System.out.println("你输入的第二个字母有误");
                }
            case "s":
                System.out.print("请输入第二个字母");
                secondWord=scanner.next();
                switch(secondWord) {
                    case "a":
                        System.out.println("Saturday");
                        break;
                    case "u":
                        System.out.println("Sunday");
                        break;
                    default:
                        System.out.println("你输入的第二个字母有误");
                }
            default:
                System.out.println("你输入的第一个字母有误");
        }
    }
}

27 求100之内的素数

题目：求100之内的素数

/**
 * @author keli
 * 题目：求100之内的素数
 */
public class JavaTest27 {
    public static void main(String[] args){
        int count=0;
        for(int i=1;i<=100;++i){
            if(isPrime(i)){
                count++;
                System.out.print(i+"\t");
            }
        }
        System.out.println("\n100之内共有素数"+count+"个");
    }
    private static boolean isPrime(int n){
        //判断是否是素数
        if(n<=1){
            return false;
        }else if(n==2){
            return true;
        }else{
            for(int i=2;i<=Math.sqrt(n);++i){
                //除了1和本身外之外还有其他的因子
                if(n%i==0)
                    return false;
            }
            return true;
        }
    }
}

28 对10个数进行排序

题目：对10个数进行排序

/**
 * @author keli
 * 题目：对10个数进行排序
 * 程序分析：可以利用选择法，即从后9个比较过程中，选择一个最小的与第一个元素交换，下次类推，即用第二个元素与后8个进行比较，并进行交换。
 */
public class JavaTest28 {
    public static void main(String[] args){
        java.util.Scanner scanner=new java.util.Scanner(System.in);
        int[] arr=new int[10];
        System.out.println("请输入十个数字，用空格分隔");
        for(int i=0;i<10;i++)
            arr[i]=scanner.nextInt();
        //选择排序
        for(int i=0;i<arr.length;++i){
            int min=arr[i];//默认第一个是最小的
            int index=i;//记录最小元素的下标
            for(int j=i+1;j<arr.length;++j){
                if(min>arr[j]){//寻找最小元素并记录下标
                    min=arr[j];
                    index=j;
                }
            }
            arr[index]=arr[i];
            arr[i]=min;//交换
        }
        //输出排序后的数组
        for(int i=0;i<arr.length;++i){
            System.out.print(arr[i]+"\t");
        }
    }
}

29 求一个3*3矩阵对角线元素之和

题目：求一个3*3矩阵对角线元素之和

/**
 * @author keli
 * 题目：求一个3*3矩阵对角线元素之和
 */
public class JavaTest29 {
    public static void main(String[] args){
        java.util.Scanner scanner=new java.util.Scanner(System.in);
        int[][] arr=new int[3][3];
        int sum1=0;//第一条对角线
        int sum2=0;//第二条对角线
        System.out.println("请输入3*3矩阵的元素");
        for(int i=0;i<3;++i)
            for(int j=0;j<3;++j){
                arr[i][j]=scanner.nextInt();
            }
        System.out.println("第一条对角线的元素之和为"+(arr[0][0]+arr[1][1]+arr[2][2]));
        System.out.println("第二条对角线的元素之和为"+(arr[2][0]+arr[1][1]+arr[0][2]));
    }
}

30 现输入一个数，要求按原来的规律将它插入顺序数组中

题目：有一个已经排好序的数组。现输入一个数，要求按原来的规律将它插入数组中。

/**
 * @author keli
 * 题目：有一个已经排好序的数组。现输入一个数，要求按原来的规律将它插入数组中。
 */
public class JavaTest30 {
    public static void main(String[] args){
        java.util.Scanner scanner=new java.util.Scanner(System.in);
        System.out.println("请输入排好序数组的长度");
        int length=scanner.nextInt();
        int[] arr1=new int[length];
        System.out.println("请从小到达输入排好序的数组的元素");
        for(int i=0;i<arr1.length;++i)
            arr1[i]=scanner.nextInt();
        System.out.println("请输入要插入的元素");
        int index=scanner.nextInt();
        int[] arr2=new int[arr1.length+1];
        if(index>arr1[length-1]){
            //比第一个数组的元素都要大
            for(int i=0;i<arr1.length;++i)
                arr2[i]=arr1[i];
            arr2[arr2.length-1]=index;
        }else{
            //这时候要考虑分为两部分，后半部分初次后移
            int i=0;
            while(arr1[i]<index){
                arr2[i]=arr1[i];
                ++i;
            }
            arr2[i]=index;
            for(;i<arr1.length;++i){
                arr2[i+1]=arr1[i];
            }
        }
        for(int j=0;j<arr2.length;++j){
            //输出插入元素后的数组
            System.out.print(arr2[j]+"\t");
        }
    }
}

31 将一个数组逆序输出。

题目：将一个数组逆序输出。

/**
 * @author keli
 * 题目：将一个数组逆序输出。
 */
public class JavaTest31 {
    public static void main(String[] args){
        java.util.Scanner scanner=new java.util.Scanner(System.in);
        System.out.println("请输入要逆序的数组的长度");
        int length=scanner.nextInt();
        int[] arr1=new int[length];
        System.out.println("请输入要逆序的数组的元素");
        for(int i=0;i<arr1.length;++i)
            arr1[i]=scanner.nextInt();
        int[] arr2=new int[arr1.length];
        for(int i=0;i<arr1.length;++i){
            arr2[arr1.length-1-i]=arr1[i];
        }
        for(int j=0;j<arr2.length;++j){
            //输出插入元素后的数组
            System.out.print(arr2[j]+"\t");
        }
    }
}

32 取一个整数a从右端开始的4～7位。

题目：取一个整数a从右端开始的4～7位。

/**
 * @author keli
 * 题目：取一个整数a从右端开始的4～7位。
 * String string=Long.toString(num);是把数字转换为字符串进行输出
 */
public class JavaTest32 {
    public static void main(String[] args){
        System.out.println("请输入整数a");
        java.util.Scanner scanner=new java.util.Scanner(System.in);
        long num=scanner.nextLong();
        String s=Long.toString(num);
        System.out.print("整数"+num+"从右端开始的4~7位是:");
        for(int i=4;i<=7;++i){
            System.out.print(s.charAt(s.length()-i));
        }
    }
}

33 打印出杨辉三角形

题目：打印出杨辉三角形（要求打印出10行如下图）

/**
 * @author keli
 * 题目：打印出杨辉三角形（要求打印出10行如下图）
 */
public class JavaTest33 {
    public static void main(String[] args){
        showYangHui(10);
    }
    public static void showYangHui(int n){
        //打印出杨辉三角的前n行
        int[][] arr=new int[n][n];
        for(int i=0;i<arr.length;i++){//赋初值
            arr[i][0]=1;
            arr[i][i]=1;
        }
        for(int i=1;i<arr.length;i++){//赋值
            for(int j=1;j<arr[0].length;j++){
                arr[i][j]=arr[i-1][j-1]+arr[i-1][j];//动态赋值
            }
        }
        for(int i=0;i<arr.length;++i){//输出三角
            for(int j=arr.length;j>i;--j)//输出空格
                System.out.print("  ");
            for(int j=0;j<=i;++j){//输出数值
                System.out.print(arr[i][j]+"   ");
            }
            for(int j=arr.length;j>i;--j)//输出空格
                System.out.print("  ");
            System.out.println();
        }
    }
}

34 3个数a,b,c，按大小顺序输出

题目：输入3个数a,b,c，按大小顺序输出。

/**
 * @author keli
 * 题目：输入3个数a,b,c，按大小顺序输出。
 */
public class JavaTest34 {
    public static void main(String[] args){
        int x,y,z;
        java.util.Scanner scanner=new java.util.Scanner(System.in);
        System.out.println("请输入三个整数，以空格隔开");
        x=scanner.nextInt();
        y=scanner.nextInt();
        z=scanner.nextInt();
        if(x>y){
            int temp=x;
            x=y;
            y=temp;
        }
        if(y>z){
            int temp=y;
            y=z;
            z=temp;
        }
        if(x>y){
            int temp=x;
            x=y;
            y=temp;
        }
        System.out.println("从小到大的顺序为:"+x+" "+y+" "+z);
    }
}

35 输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组

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

/**
 * @author keli
 * 题目：输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。
 */
public class JavaTest35 {
    public static void main(String[] args){
        java.util.Scanner scanner=new java.util.Scanner(System.in);
        System.out.println("请输入数组的长度");
        int length=scanner.nextInt();
        int[] arr=new int[length];
        System.out.println("请输入数组的元素");
        for(int i=0;i<arr.length;++i)
            arr[i]=scanner.nextInt();
        int maxIndex=0;//保存最大值的角标
        int minIndex=0;//保存最小值的角标
        for(int i=0;i<arr.length;++i){
            if(arr[maxIndex]<arr[i])
                maxIndex=i;
            if(arr[minIndex]>arr[i])
                minIndex=arr[i];
        }
        //最大值与第一个元素交换
        int temp=arr[maxIndex];
        arr[maxIndex]=arr[0];
        arr[0]=temp;
        //最小值与在最后一个元素交换
        temp=arr[minIndex];
        arr[minIndex]=arr[arr.length-1];
        arr[arr.length-1]=temp;
        for(int i=0;i<arr.length;++i){//输出数组
            System.out.print(arr[i]+"\t");
        }
    }
}

36 有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数

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

/**
 * @author keli
 * 题目：有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数
 */
public class JavaTest36 {
    public static void main(String[] args){
        java.util.Scanner scanner=new java.util.Scanner(System.in);
        System.out.println("请输入数组的长度");
        int length=scanner.nextInt();
        int[] arr1=new int[length];
        System.out.println("请输入数组的元素");
        for(int i=0;i<arr1.length;++i)
            arr1[i]=scanner.nextInt();
        int[] arr2=new int[arr1.length];
        System.out.println("请输入后移的距离m");
        int m=scanner.nextInt();
        for(int i=0;i<arr1.length-m;++i){//前面各数顺序向后移m个位置
            arr2[i+m]=arr1[i];
        }
        for(int i=0;i<m;++i){//最后m个数变成最前面的m个数
            arr2[i]=arr1[arr1.length-m+i];
        }
        for(int i=0;i<arr2.length;++i){//顺序移动后的数组
            System.out.print(arr2[i]+"\t");
        }
    }
}

37 厄运数问题

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

/**
 * @author keli
 * 题目：有n个人围成一圈，顺序排号。
 * 从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来第几号的那位。
 */
public class JavaTest37 {
    public static void main(String[] args){
        System.out.println("请输入人数n");
        java.util.Scanner scanner=new java.util.Scanner(System.in);
        int n=scanner.nextInt();
        System.out.print("最后留下的是原来的"+joseph(n,3)+"号");
    }
    public static int joseph(int count,int doom){//count是总人数，doom是厄运数，即数到哪个数淘汰
        int alive=count;//场上剩下的人数
        int number=0;//模拟数数，从1开始数
        int index=0;//人数的编号，从0开始,实际的人数是从1开始计数的
        int[] arr=new int[count];//用来存储某个人还在不在场上，在场为0，不在场为1
        while(alive>1){
            number+=1-arr[index];//模拟数数
            if(number==doom){//数到了灾厄数，该淘汰人了
                arr[index]=1;//不在场储存为1
                number=0;//重新数数
                alive--;//场上人数减一
            }
            index++;
            index=index%count;//取余用来模拟一圈结束后重新开始计数
        }
        for(int i=0;i<arr.length;++i)//寻找最后剩下的人的编号
            if(arr[i]!=1)
                index=i;
        return index+1;//返回实际的人编号
    }
}

38 写一个函数，求一个字符串的长度

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

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

39 编写一个函数，输入n为偶数时，调用函数求1/2+1/4+…+1/n,当输入n为奇数时，调用函数1/1+1/3+…+1/n(利用指针函数)

题目：编写一个函数，输入n为偶数时，调用函数求1/2+1/4+…+1/n,当输入n为奇数时，调用函数1/1+1/3+…+1/n(利用指针函数)

/**
 * @author keli
 * 题目：编写一个函数，输入n为偶数时，调用函数求1/2+1/4+…+1/n,当输入n为奇数时，调用函数1/1+1/3+…+1/n(利用指针函数)
 */
public class JavaTest39 {
    public static void main(String[] args){
        java.util.Scanner scanner=new java.util.Scanner(System.in);
        System.out.println("请输入n");
        int n=scanner.nextInt();
        System.out.print("="+f(n));
    }
    public static double f(int n){
        //求值的函数，顺便输出计算过程
        double sum=0;
        if(n%2==0){
            //n为偶数时
            System.out.print("1/2");
            sum+=1.0/2.0;
            for(int i=4;i<=n;i+=2){
                System.out.print("+1/"+i);
                sum+=1.0/i;
            }
        }else{
            //n为奇数时
            System.out.print("1/1");
            sum+=1.0/1.0;
            for(int i=3;i<=n;i+=2){
                System.out.print("+1/"+i);
                sum+=1.0/i;
            }
        }
        return sum;
    }
}

40 字符串排序。

题目：字符串排序。

/**
 * @author keli
 * 题目：字符串排序。
 * string1.compareTo(string2)是封装的字符串比较函数，第一个大返回值是正数，否则是负数
 */
public class JavaTest40 {
    public static void main(String[] args){
        java.util.Scanner scanner=new java.util.Scanner(System.in);
        System.out.println("请输入字符串的数量");
        int length=scanner.nextInt();
        String[] arr=new String[length];
        System.out.println("请输入字符串，用空格分隔开");
        for(int i=0;i<arr.length;++i)
            arr[i]=scanner.next();
        sortString(arr);
        for(int i=0;i<arr.length;++i){
            System.out.print(arr[i]+" ");
        }
    }
    public static void sortString(String[] arr){
        //使用冒泡排序法对字符串数组进行排序,由首字母从小到大的顺序
        for(int i=0;i<arr.length;++i){
            for(int j=0;j<arr.length-1-i;++j){
                if(arr[j].compareTo(arr[j+1])>0){
                    String temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
    }
}

41 猴子分桃问题

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

/**
 * @author keli
 * 题目：海滩上有一堆桃子，五只猴子来分。
 * 第一只猴子把这堆桃子凭据分为五份，多了一个，这只猴子把多的一个扔入海中，拿走了一份。
 * 第二只猴子把剩下的桃子又平均分成五份，又多了一个，它同样把多的一个扔入海中，拿走了一份，
 * 第三、第四、第五只猴子都是这样做的，问海滩上原来最少有多少个桃子？
 */
public class JavaTest41 {
    public static void main(String[] args){
        java.util.Scanner scanner=new java.util.Scanner(System.in);
        int sum=f(5);// 倒数第五只猴子份桃子前的数量就是桃子总量
        System.out.println("海滩上原来最少有"+sum+"个桃子");
    }
    public static int f(int n){
        //返回值是倒数第n只猴子分桃子前桃子的数量
        if(n==1)
            return 5*1+1;//手里只有一个是最少的
        return f(n-1)*5+1;
    }
}

42 809*??=800*??+9*??+1

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

/**
 * @author keli
 * 题目：809*??=800*??+9*??+1
 * 其中??代表的两位数,8*??的结果为两位数，9*??的结果为3位数。求??代表的两位数，及809*??后的结果。
 */
public class JavaTest42 {
    public static void main(String[] args){
        int flag=0;
        for(int i=10;i<=99;++i){
            if(isCorrect(i)){
                flag=1;
                System.out.print("??代表"+i+",809*??的结果为"+(809*i));
            }
        }
        if(flag==0)
            System.out.println("\n没有符合要求的数");
    }
    public static boolean isCorrect(int n){
        if(8*n<10||8*n>=100)//8*n是两位数
            return false;
        if(9*n<100||9*n>=1000)//9*n是三位数
            return false;
        if(809*n!=800*n+9*n+1)
            return false;
        return true;
    }
}

43 求0—7所能组成的奇数个数。

题目：求0—7所能组成的奇数个数。

/**
 * @author keli
 * 题目：求0—7所能组成的奇数个数。
 */
public class JavaTest43 {
    public static void main(String[] args){
        int sum=0;//要求就是第一位不能是0，最后一位是1 3 5 7
        int n=8;
        sum+=n/2;//一位数
        sum+=(n-1)*n/2;//二位数
        for(int i=1;i<=6;++i){
            sum+=(n-1)*Math.pow(n,i)*n/2;//34567位数
        }
        System.out.println("0~7能组成的奇数个数为"+sum);
    }
}

44 将一个偶数表示为两个素数之和。

题目：一个偶数总能表示为两个素数之和。

/**
 * @author keli
 * 题目：一个偶数总能表示为两个素数之和。
 */
public class JavaTest44 {
    public static void main(String[] args){
        java.util.Scanner scanner=new java.util.Scanner(System.in);
        System.out.println("请输入一个偶数");
        int input=scanner.nextInt();
        while(input%2!=0){
            System.out.println("请重新输入");
            input=scanner.nextInt();
        }
        for(int i=2;i<input;++i)
            for(int j=2;j<input;j++){
                if(isPrime(i)&&isPrime(j)&&(i+j==input))
                    System.out.println(input+"="+i+"+"+j);
            }
    }
    private static boolean isPrime(int n){
        //判断是否是素数
        if(n<=1){
            return false;
        }else if(n==2){
            return true;
        }else{
            for(int i=2;i<=Math.sqrt(n);++i){
                //除了1和本身外之外还有其他的因子
                if(n%i==0)
                    return false;
            }
            return true;
        }
    }
}

45 判断一个素数能被几个9整除

判断一个素数能被几个9整除,这个题目的意思是多少个9组成的数能整除这个素数

/**
 * @autor keli
 * 判断一个素数能被几个9整除
 * 这个题目的意思是多少个9组成的数能整除这个素数
 */
public class JavaTest45 {
    public static void main(String[] args){
        System.out.println("请输入一个素数");
        java.util.Scanner scanner=new java.util.Scanner(System.in);
        int input=scanner.nextInt();
        while(!isPrime(input)){
            System.out.println("你输入的不是素数，请重新输入");
            input=scanner.nextInt();
        }
        long sum=9;
        int i=1;//多少个9组成的数
        while(sum%input!=0){
            sum=sum*10+9;
            i++;
        }
        System.out.print(input+"能被"+sum+"整除，即能被"+i+"个9整除");
    }
    private static boolean isPrime(int n){
        //判断是否是素数
        if(n<=1){
            return false;
        }else if(n==2){
            return true;
        }else{
            for(int i=2;i<=Math.sqrt(n);++i){
                //除了1和本身外之外还有其他的因子
                if(n%i==0)
                    return false;
            }
            return true;
        }
    }
}

46 两个字符串连接程序

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

/**
 * @author keli
 * 题目：两个字符串连接程序
 */
import java.util.Scanner;
public class JavaTest46 {
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入两个字符串，空格或者换行分隔");
        String s1=scanner.next();
        String s2=scanner.next();
        System.out.println(s1+"+"+s2+"="+(s1+s2));
    }
}

47 读取7个数（1—50）的整数值，每读取一个值，程序打印出该值个数的＊

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

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

48 四位整数解密

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

/**
 * @author keli
 * 题目：某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，加密规则如下：
 * 每位数字都加上5,然后用和除以10的余数代替该数字，再将第一位和第四位交换，第二位和第三位交换。
 */
public class JavaTest48 {
    public static void main(String[] args){
        System.out.println("请输入四位整数");
        java.util.Scanner scanner=new java.util.Scanner(System.in);
        int input=scanner.nextInt();
        System.out.print(input+"解密后是"+decode(input));
    }
    public static int decode(int n){
        int bite=n%10;//个位
        int ten=(n/10)%10;//十位
        int hundred=(n/100)%10;//百位
        int thousand=n/1000;//千位
        bite=(bite+5)%10;
        ten=(ten+5)%10;
        hundred=(hundred+5)%10;
        thousand=(thousand+5)%10;
        //第一位和第四位交换
        int temp=thousand;
        thousand=bite;
        bite=temp;
        //第二位和第三位交换
        temp=hundred;
        hundred=ten;
        ten=temp;
        return 1000*thousand+100*hundred+10*ten+bite;
    }
}

49 计算字符串中子串出现的次数

计算字符串中子串出现的次数

/**
 * @author keli
 *计算字符串中子串出现的次数
 * 运用了String中封装的string.substring(a,b)的字串函数
 * 和判断字符串相等的string.equals(string1)函数
 */
public class JavaTest49 {
    public static void main(String[] args){
        java.util.Scanner scanner=new java.util.Scanner(System.in);
        System.out.println("请输入父字符串和子字符串，空格或者回车分隔");
        String s=scanner.next();
        String s1=scanner.next();
        System.out.println(s+"中"+s1+"出现了"+f(s,s1)+"次");
    }
    public static int f(String s,String s1){
        //统计字符串s1再s中出现的次数
        int count=0;
        for(int i=0;i<=s.length()-s1.length();++i){
            if(s1.equals(s.substring(i,s1.length()+i)))
                count++;
        }
        return count;
    }
}

50 输入学生成绩信息存入磁盘文件

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

/**
 * @author keli
 * 题目：有五个学生，每个学生有3门课的成绩，从键盘输入以上数据（包括学生号，姓名，三门课成绩），
 * 计算出平均成绩，将原有的数据和计算出的平均分数存放在磁盘文件”stud”中。
 */
import java.io.*;//文件存储，输入输出流
public class JavaTest50 {
    //定义学生模型
    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) throws Exception{
        JavaTest50 stud = new JavaTest50();
        stud.input();
        stud.output();
    }
    //输入学号、姓名、成绩
    void input() throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        //录入状态标识
        boolean isRecord = true;
        while(isRecord){
            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];
                }
                isRecord = false;
            }catch(NumberFormatException e){
                System.out.println("请输入一个数字！");
            }
        }
    }
    //输出文件
    void output() throws IOException{
        FileWriter fw = new FileWriter("E://source");
        BufferedWriter bw = new BufferedWriter(fw);
        bw.write("No.  "+"Name  "+"grade1  "+"grade2  "+"grade3  "+"average");
        bw.newLine();
        for(int i=0;i<5;i++){
            bw.write(number[i]);
            bw.write("  "+name[i]);
            for(int j=0;j<3;j++)
                bw.write("  "+grade[i][j]);
            bw.write("  "+(sum[i]/5));
            bw.newLine();
        }
        bw.close();
    }
}