java基础编程题练习（一）

1.编程实现用户输入4个整数，按从大到小的顺序排列输出。

思路：将输入的数据存入数组，使用冒泡排序对数组数据进行排序后输出数组

冒泡排序的代码如下：

import java.util.Scanner;
import java.util.Arrays;
        /*
        import的作用是：
        在你写一个类的时候。里面用到了其他的类，而用到的这个类和你现在写的这个类不是同一个包里，
        就需要导入那个类的全名
        Scanner类:
        使用该类创建一个对象.
                Scanner　Sc=new Scanner(System.in);
        然后Sc对象调用下列方法(函数),读取用户在命令行输入的各种数据类型:
        next.Byte(),nextDouble(),nextFloat,nextInt(),nextLin(),nextLong(),nextShot() 。
        这些方法执行时都会造成堵塞，等待用户在命令行输入数据回车确认。
        */
public class sort001 {
        public static void main(String[] args) {
                System.out.println("请依次输入四个整数：");
                Scanner input = new Scanner(System.in);//对象为input
                int[] arr=new int[4];                  //数组名为arr
                int temp;
                for(int i=0;i<arr.length;i++){
                        arr[i]=input.nextInt();        //input对象循环使用nextInt()函数读取用户输入的数据
                }
                System.out.println("排序前数组为："+Arrays.toString(arr));
                for (int x=0;x<arr.length;x++){
                        /*
                                冒泡排序，相邻两个数依次对比，若前面的比后面的小，则二者交换
                         */
                        for(int y=x+1;y<arr.length;y++){
                                if (arr[x]<arr[y]){
                                        temp=arr[x];
                                        arr[x]=arr[y];
                                        arr[y]=temp;
                                }
                        }
                }
                System.out.print("排序后数组为："+Arrays.toString(arr));
        }
}

拓展思考：1：若用户输入的不是整数，是浮点型，双精度型，字符串等如何处理？

　　　　　2：若数据过大，超出整型变量范围如何处理？

　　　　　3：冒泡排序时间复杂度过高，可用更高效的排序算法替代。

改用插入排序后的代码如下：

import java.util.Arrays;
import java.util.Scanner;

public class sort001Optimized {
    public static void main(String[] args){
        System.out.println("请依次输入4个整数：");
        Scanner sc = new Scanner(System.in);
        long[] arr=new long[4];               //数组名为arr
                                              //Scanner是全部输入完才能抛出异常
            int count=0;                      //输入异常问题有待解决
            while(count<4&&sc.hasNextLong()){
                arr[count]=sc.nextLong();
                count++;
            }

        System.out.println("排序前数组为："+ Arrays.toString(arr)); //输出排序前数组

        //插入排序，排序的结果在数组中是按从小到大排列的
        for (int i=1;i<arr.length;i++){
            int k=i;
            for (int j=arr.length-1;j>i;j--){
                if (arr[j]<arr[k]){
                    k=j;
                }
            }
            long temp=arr[i];
            arr[i]=arr[k];
            arr[k]=temp;
        }

        for (int c=arr.length-1;c>=0;c--){      //根据输出要求，将数组元素逆序输出得到从大到小的排列
            System.out.print(arr[c]+"	");
        }

    }
}

改用快速排序后的代码如下：

2.编程实现求一元二次方程的解。

思路：二次项系数，一次项系数，常数项都需要用户输入，根据判别式b^2-4*a*c判断是否有解，若有解再讨论二次项系数和一次项系数是否都为0，若都为0则无解，二次项系数不为0时使用求根公式求解并输出。

需要注意的问题：条件逻辑关系要正确（网上很多代码实现都出现了逻辑漏洞）；数据定义最好采用double（网上很多代码实现都是定义为int型，测试数据时很容易出错），防止sqrt()函数求根时出现小数；编写代码的过程中为了熟悉数组的使用特意选择使用数组存放数据。

import java.util.Scanner;

public class equation {
    public static void main(String[] args){
        //定义系数数组coef和解的数组sol
        double[] coef=new double[3];
        double[] sol=new double[2];
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入不为0的二次项系数：");
        coef[0]=sc.nextDouble();
        System.out.println("请输入一次项系数：");
        coef[1]=sc.nextDouble();
        System.out.println("请输入常数项：");
        coef[2]=sc.nextDouble();
        double dist=coef[1]*coef[1]-4*coef[0]*coef[2];  //dist为判别式变量
        if(dist<0){
            System.out.println("方程无解！");           //判别式<0，方程无解
        } else{
            if (coef[0]==0){                            //二次项系数为0时判断以此向系数
                if (coef[1]==0){                        //一次项系数也为0时无解
                    System.out.println("方程无解！");
                }else{                                  //一次项系数不为0时
                    sol[0]=(-coef[2])/coef[1];
                    System.out.println("方程有一个解："+sol[0]);
                }
            }else {                                     //二次项系数不为0时求根并输出
                sol[0] = (-coef[1] + Math.sqrt(dist)) / (2 * coef[0]);
                sol[1] = (-coef[1] - Math.sqrt(dist)) / (2 * coef[0]);
                System.out.println("方程的两解为："+sol[0]+"	"+sol[1]);
            }
        }
    }
}

3.编写程序，输入一个字符，判断它是否为小写字母，如果是，将它转换成大写字母，否则，不转换。（将大写字母转化城小写的也完成）

思路：判断字符大小写的方法选择，使用ASCII码比较；使用Pattern和Matcher进行匹配判断，再用toUpperCase()和toLowerCase()进行转换；使用isUpperCase()判断是否大写字母。使用方法在代码注释中有注明。

public class zimu {
    public static void main(String[] args){

        Scanner input=new Scanner(System.in);
        char zm=input.next().charAt(0);
        if (zm>=97&&zm<=122){
            System.err.println("你输入的是小写字母："+zm);
            zm=(char)(zm-32);   //基本数据类型之间强制类型转换时后面的运算加上括号，否则会报int转char可能会有损失
            System.err.println("转换后的字母为："+zm);
        }else{
            System.err.println("你输入的不是小写字母。");
        }
    }
}

import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class practice {
    public static void main(String[] args){
        String str;
        System.out.println("请输入一个字母：");
        Scanner input=new Scanner(System.in);
        str=input.next();
        Pattern p1=Pattern.compile("[A-Z]");//定义用于大写字母A-Z的匹配模板
        Pattern p2=Pattern.compile("[a-z]");//定义用于小写字母a-z的匹配模板
        Matcher m1=p1.matcher(str);         //定义状态器m1
        Matcher m2=p2.matcher(str);         //定义状态器m2
        /*****
         Matcher类的构造方法也是private的所以也是通过调用方法来创建的.
         Matcher.matches()是必须全部匹配,待匹配的字符按串在目标模板里全都有
         Matcher.lookingAt()匹配的字符必须要在字符串的最前面
         Matcher.find()匹配的字符可以在字符串的任意的地方
         *****/
        if (m1.matches()){
            //m1调用matches()对str在A-Z之间匹配
            System.out.println("你输入的是大写字母："+str);
            str=str.toLowerCase();          //将大写字母转化为小写
        }else if(m2.matches()){
            //m2调用matches()对str在a-z之间匹配
            System.out.println("你输入的是小写字母："+str);
            str=str.toUpperCase();          //将小写字母转化为大写
        }else{
            System.out.println("你输入的既不是大写字母也不是小写字母！");
        }
        System.out.println("转化后的字母为："+str);
    }
}

4.输入 3 个正数，判断能否构成一个三角形

思路：任意两边之和大于第三边，使用&&

import java.util.Scanner;

public class triangle {
    public static void main(String[] args){
        System.out.println("请输入三个整数：");
        Scanner sc=new Scanner(System.in);
            int a=sc.nextInt(),b=sc.nextInt(),c=sc.nextInt();
            if (a<=0||b<=0||c<=0){
                System.out.println("请输入正整数：");
            }
            if ((a+b)>c&&(a+c)>b&&(b+c)>a){     //任意两边之和大于第三边
                System.out.println("可以构成三角形");
            }else{
                System.out.println("不能构成三角形！");
            }
    }
}

5.编写程序，对输入的年、月、日，给出该天是该年的第多少天

思路：需要根据月份将前面所有月的天数相加再加上该月天数得到结果，每年有12个月，数量较多，结构选择switch结构，需要注意的是平年与闰年的2月天数不同，需要根据年数对4和400取整是否为0确定。

import java.util.Scanner;

public class dateCount {
    public static void  main(String[] args){
        System.out.println("请依次输入年，月，日：");
        int year,month,day,count=0;
        Scanner sc=new Scanner(System.in);
        year=sc.nextInt();
        month=sc.nextInt();
        day=sc.nextInt();
        switch (month){         //switch语句后续符合条件的语句都会执行，所以要将月份倒着写
            case 12:count+=30;
            case 11:count+=31;
            case 10:count+=30;
            case 9:count+=31;
            case 8:count+=31;
            case 7:count+=30;
            case 6:count+=31;
            case 5:count+=30;
            case 4:count+=31;
            case 3:if (year%4==0||year%400==0){     //根据年数算出平年或闰年，得到2月的天数
                        count+=29;
                    }else{
                        count+=28;
                    }
            case 2:count+=31;
            case 1:count+=day;
        }
        System.out.println("这是该年第"+count+"天");
    }
}

6.编写程序，从键盘输入一个 0~99999 之间的任意数，判断输入的数是几位数？

思路一：使用if else条件结构嵌套根据数字对1000，100，10取整确定位数。

思路二：将输入的整数以字符串的形式存储，输出字符串长度。

import java.util.Scanner;

public class numberBits {
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个0~9999的整数：");
        int num=sc.nextInt();
        if (num/1000>=1){
            System.out.println("这是一个四位数,");
        }else if (num/100>=1){
            System.out.println("这是一个三位数。");
        }else if (num/10>=1){
            System.out.println("这是一个两位数。");
        }else{
            System.out.println("这是一个一位数。");
        }
    }
}

7.编写程序，给定一个学生成绩，给出相应等级：

90~100 优秀

80~89 良好

70~79 中等

60~69 及格

0~59 不及格

 思路：与上题类似，不再赘述。

8.编写程序，对输入的一个整数，按相反顺序输出该数。例如，输入为 3578，输出为 8753

思路：将输入的整数以字符串的形式存储，将每一位视作字符，以输入顺序的逆序输出。

import java.util.Scanner;

public class test {
    public static void main(String[] args){
        System.out.println("请输入一个整数：");
        Scanner sc=new Scanner(System.in);
        int num=sc.nextInt();
        String str=num+"";
        char zifu[]=str.toCharArray();  //将字符串str转为字符型数组
        String temp="";                 //将temp设为空字符串
        for(int i=zifu.length-1;i>=0;i--){
            temp=temp+zifu[i];          //将zifu[]数组中的字符逆序加到temp形成新的字符串
        }
        System.out.println(temp);
    }
}

更简单的方法：将输入的整数转化为字符串，使用reverse()将字符串顺序翻转。

import java.util.Scanner;

public class test {
    public static void main(String[] args){
        System.out.println("请输入一个整数：");
        Scanner sc=new Scanner(System.in);
        int num=sc.nextInt();
        StringBuilder sb=new StringBuilder(String.valueOf(num));
        System.out.println(sb.reverse());
    }
}

StringBuilder:
当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类.
StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象;
和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）;
由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类;
在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类;

String.valueOf():
将目标对象转换成字符串类型，本例中是将int型的read变量转换成String型。

9.用 while 循环，计算 1~200 之间所有 3 的倍数之和

思路：1~200的数依次判断能否被3整除，如果可以就相加，如果不行则自增。

第一次编写的错误代码及错误解析。

public class distAdd3 {
    public static void main(String[] args){
        int i=1,sum=0;
        while(i>=1&&i<=200){    //运行无结果，因为i>=1始终为true，应该去掉这个条件
            if (i/3==0){        //判断整除应该用取余是否为0，用%，不是取整
                sum+=i;
            }else {             //else语句是在if后的判定语句不成立的情况下才运行，而不管i能否被3整除i都应该自增要弄清单if和if else的区别
                i++;
            }
        }
        System.out.println("1~200中所有3的倍数之和为："+sum);
    }
}

修改过后的正确代码：

public class distAdd3 {
    public static void main(String[] args){
        int i=1,sum=0;
        while(i<=200){
            if (i%3==0){
                sum+=i;
            }            
            i++;
        }
        System.out.println("1~200中所有3的倍数之和为："+sum);
    }
}

10.编写程序，输出 200~500 之间的所有素数

思路：素数只能被1和它本身整除,判断一个数i是否为素数,可以用一个数j对它进行测试,如果 i%j == 0 ，而 j 又不是 1 或 它本身， 那么这个数就不是素数；如果 i%j != 0 ,那么 j 一直增加下去，看 j 能不能有一个值可以整除 i , 如果 j是一个素数，那么j可以一直增加到 i 为止，这样就可以看出它是不是素数了

public class prime {
    public static void main(String[] args){
        int count=0;                //素数个数标记
        for (int i=200;i<=500;i++){
            boolean flag=true;      //素数判定标记
            for (int j=2;(3*j)<i;j++){  //检验i从能否被从2到i/3中的某个数整除
                if (i%j==0){            //一旦出现整除则i不是质数，跳出j自增的循环，进入i自增的循环，检验i+1
                    flag=false;
                    break;
                }
            }
            if (flag){
                count++;        
                System.out.println("第"+count+"个素数为："+i);
            }
        }
    }
}

11.编写程序解决“百钱买百鸡”问题。公鸡五钱一只，母鸡三钱一只，小鸡一钱三只，现有百钱欲买百鸡，共有多少种买法？

思路：公鸡，母鸡，小鸡数量为a，b，c，a+b+c=100,5a+3b+(c/3)=100，因为a<20,b<33可以缩小范围

public class buychicken {
    public static void main(String[] args){
        for (int a=0;a<20;a++){         //公鸡5元一只，5*a<100
            for (int b=0;b<33;b++){     //母鸡3元一只，3*b<100
                int c=100-a-b;
                    if (c % 3 == 0 &&5*a+3*b+c/3==100) {        //小鸡1元3只，c必定是3的倍数，且三种鸡的价格之和为100
                        System.out.println("公鸡"+a+"只母鸡"+b+"只小鸡"+c+"只");
                    }
                }
            }
        }
    }

12.使用循环语句输出下面的图形。

#

# # #

# # # # #

# # # # # # #

# # # # # # # # #

思路：循环嵌套，一个循环控制换行，一个 循环控制每一行输出#的个数

public class printTarget {
    public static void main(String[] args){
        int count=-1;
        for (int i=0;i<5;i++){      //该层循环控制换行
            count+=2;               //每一行多打两个#
            for (int b=0;b<count;b++){  //控制每一行输出#的个数
                System.out.print("#"+"	");
            }
            System.out.println();
        }
    }
}

13.验证“鬼谷猜想”：对任意自然数，若是奇数，就对它乘以 3 再加 1；若是偶数，就对它除以 2，这样得到一个新数，再按上述计算规则进行计算，一直进行下去，最终必然得到 1

思路：使用while循环控制算法进行直到得到1为止，使用if else结构控制为奇数和偶数的运算。

import java.util.Scanner;

public class guiguGuess {
    public static void main(String[] args){
        System.out.println("请输入一个正整数：");    //根据题意，0是自然数但是不符合鬼谷猜想。
        Scanner sc=new Scanner(System.in);
        int num=sc.nextInt();
        while(num!=1){              //直到得到1时循环结束
            if (num%2==0){
                num=num/2;          //为偶数时除以2
            }else{
                num=num*3+1;        //为奇数时乘3加1
            }
        }
        System.out.print("该数经过鬼谷猜想运算得到的结果为："+num);
    }
}

14.编程求 1~10000 之间的所有“完全数”，完全数是该数的所有因子之和等于该数的数。例如，6 的因子有 1、2、3，且 6=1+2+3，所以 6 是完全数

思路：将功能分开写，分解因数并判定的功能写在函数里，在主函数中调用

public class perfectNumber {
    public static boolean yinzi(int num){   //定义函数yinzi()，作用是求一个数所有因子的和并判断是否与该数相等
        int sum=0;
        for (int y = 1; y < num; y++) {     //一个正整数的所有因子都在1和其完全平方根间
            if (num % y == 0) {                          //循环检验该数能否被改区间的所有数整除
                sum += y;                             //可以整除的因子进行求和
            }
        }
        return sum==num;        //函数中的结果是boolen型，返回值是判别式sum==num的结果，相等则为true，反之false
    }

    public static void main(String[] args){
        for (int a=1;a<=10000;a++) {    //在1-10000内循环
            int num=a;
            if (yinzi(num)) {   //调用函数yinzi()判断num的所有因子之和是否与num相等
                System.out.println(num + "是一个完全数。");
            }
        }
    }
}

15.一个整数的各位数字之和能被 9 整除，则该数也能被 9 整除。编程验证给定的整数能否被 9 整除。

思路：将输入的数字以字符串存储，将字符串转换成整型数组，将数组求和再对9取余

import java.util.Scanner;

public class dist9{
    public  static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        String str=sc.next();               //将输入的数字以字符串的形式存储
        int[] num=new int[str.length()];    //得到字符串长度并定义相同长度的整型数组
        int sum=0;
        for (int i=0;i<str.length();i++){
            num[i]=Integer.parseInt(str.substring(i,i+1));//将字符串转化成整型数组
            /*
            substring(i,i+1)表示截取字符串从第i各到第i+1各字符，包含起始位置不包含结束位置
             */
            System.out.print(num[i]);
            sum+=num[i];                    //各位求和
        }
        if (sum%9==0){
            System.out.println("该数可以被9整除。");
        }else{
            System.out.println("该数不能被9整除。");
        }
    }
}

16.猴子吃桃问题。猴子第一天摘下若干个桃子，当时就吃了一半，还不过瘾，就又吃了一个。第二天又将剩下的桃子吃掉一半，又多吃了一个。以后每天都吃前一天剩下的一半零一个。到第 10 天在想吃的时候就剩一个桃子了,求第一天共摘下来多少个桃子？

思路：找到数列规律，n2=2*(1+n1)

public class monkePeach {
    public static void main(String[] args){
        int p=1;
        for (int i=1;i<10;i++){
            p=2*(p+1);
        }
        System.out.print("第一天一共摘了"+p+"个桃子。");
    }
}

17.水仙花数是指一个 n 位数 ( n≥3 )，它的每个位上的数字的 n 次幂之和等于它本身。（例如：1^3 + 5^3 + 3^3 = 153）。编程求出所有三位的水仙花数。

import java.util.Scanner;

public class shuixianhua {
    public static void main(String[] args){
        int a, b, c, sum;
        for (int num=100;num<1000;num++) {
            a = num / 100;
            b = num % 100 / 10;
            c = num % 10;
            sum = a * a * a + b * b * b + c * c * c;
            if (num == sum) {
                System.out.println(num + "是一个水仙花数。");
            }
        }
    }
}

18.已知 XYZ+YZZ=532，其中，X、Y、Z 为数字，编程求出 X、Y 和 Z 的值。

public class solEquation {
    public static void main(String[] args){
        int sum;
        for(int x=0;x<=9;x++){
            for (int y=0;y<=9;y++){
                for (int z=0;z<=9;z++){
                    sum=100*x+110*y+12*z;
                    if(sum==532){
                        System.out.println("X:"+x+"	Y:"+y+"	Z:"+z);
                    }
                }
            }
        }
    }
}

19.古典问题：有一对兔子，从出生后第 3 个月起每个月都生一对兔子，小兔

子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数

为多少？

思路：第一个月，第二个月兔子总数为2，第三个月为4，第四个月为6，这是一个斐波那契（Fibonacci）数列，某一项等于相邻前两项的和（n3=n2+n1），可以使用递归和非递归的思路实现。

import java.util.Scanner;

public class fibonacci {
    public static int f(int x){     //定义函数f，功能为求第x个月的总数
        if (x==1||x==2){            //第一第二月都是2
            return 2;
        }else{
            return f(x-1)+f(x-2);       //第x月等于前两月之和
        }
    }

public static void main(String[] args){
        System.out.println("请输入月份：");
        Scanner sc=new Scanner(System.in);
        int month=sc.nextInt();
        for (int i=1;i<=month;i++) {    //  将month月之前的每个月兔子总数输出
            System.out.println("第"+ i + "月的兔子总数为：" + f(i));
        }
    }
}

import java.util.Scanner;

public class fibonacci {
        public static void main(String[] args){
        System.out.println("请输入月份：");
        Scanner sc=new Scanner(System.in);
        int month=sc.nextInt();
        int num1=1,num2=1,temp;
        if (month==1||month==2){
            System.out.println("兔子总数为："+2*num2);
        }
        for (int i=3;i<=month;i++){
            temp=num2;          //第i月等于前两月之和
            num2=num1+num2;
            num1=temp;
            System.out.println(month+"月兔子的总数为："+2*num2);
        }
    }
}

20.将一个正整数分解质因数。例如：输入 90，打印出 90=2*3*3*5

思路：从2开始到num，找num的因数，若找到一个就一直除，除到无法再被该因数整除时就往后找新的因数直到没有因数。

import java.util.Scanner;

public class resolve {
    public static void main(String[] args){
        System.out.println("请输入一个整数：");
        Scanner sc=new Scanner(System.in);
        int num=sc.nextInt();
        System.out.print(num+"=");
        for (int i=2;i<num;i++){    //从2开始找因数
            while(num%i==0){        //若num能被i整除则一直除到无法被i整除为止
                num/=i;
                System.out.print(i+"*");
            }
        }
        System.out.print(num);
    }
}