JAVA小白 编程练习500题 超详细!!!带答案!!!持续更新中~

JAVA小白编程题练习

可能有很多刚入门的小白不知道自己如何能快速提升编程技巧与熟练度
其实大佬进阶之路只有一个~ 那就是疯狂码代码!!!实践出真知!!!
所以为了大家能够想练习的时候有素材,泡泡给大家整理了一些练习题
由于平时比较忙,所以我在不定时努力更新中,欢迎监督~
500是立的Flag啊哈哈哈哈,我们共同努力吧,先出个100道,希望能给大家带来帮助~

😃😃😃

练习题:通过代码编写,输出一句话:“我要开始学习JAVA了,今天又是知识量满满的一天~”

package cn.cxy.exec;

public class TestPrint {
    public static void main(String[] args) {
        System.out.println("我要开始学习JAVA了,今天又是知识量满满的一天~");
    }
}

练习题:打印个人信息案例,将一个人的一些个人信息打印输出

package cn.cxy.exec;

public class TestPrint2 {
    public static void main(String[] args) {
        System.out.println("海绵宝宝");//字符串类型,我是海绵宝宝
        System.out.println(3);//整数类型,今年3岁了
        System.out.println("海底");//字符串类型,我的家在海底
        System.out.println(true);//布尔类型,吃饭了吗?吃啦,吃的蟹黄堡
        System.out.println(10.99);//浮点类型,今天还收到了10.99的红包
    }
}

练习题:拼接打印:输出:XXX:这是我学习JAVA的第X年,我的期望薪资是XXX

package cn.cxy.exec;

public class TestPrint3 {
    public static void main(String[] args) {
        //1.定义变量保存姓名
        String name = "派大星";
        //2.定义变量保存年份
        int year = 1;
        //3.定义变量保存期望薪资
        double salary = 10000.0;
        //4.拼接打印目标结果
        System.out.println(name+":这是我学习JAVA的第"+year+"年,我的期望薪资是"+salary);
    }
}

练习题:定义两个整数,计算这两个整数加减乘除运算的结果,并把结果打印到控制台

package cn.cxy.exec;

public class TestPrint4 {
    public static void main(String[] args) {
        //1.定义变量保存要计算的第一个数
        int number1 = 1;
        //2.定义变量保存要计算的第二个数
        int number2 = 2;
        //3.打印输出这两个数计算的结果
        System.out.println(number1+number2);
    }
}

练习题:预测身高案例:

其实我们可以通过父母的身高大致推断出子女的身高,假定父母与子女的身高遗传关系如下:
​ 儿子身高(厘米)=(父亲身高+母亲身高) ×1.08÷2
​ 女儿身高(厘米)=(父亲身高×0.923+母亲身高) ÷2
那已知:现有父亲身高175CM,母亲身高160CM。
请将预测的子女身高打印输出

package cn.cxy.exec;

public class TestPrint5 {
    public static void main(String[] args) {
        //1.定义变量保存父亲的身高
        double fatherHeight = 175;
        //2.定义变量保存母亲的身高
        double motherHeight = 160;
        //3.计算儿子身高
        double sonHeight = (fatherHeight + motherHeight) * 1.08 / 2;
        //4.计算女儿身高
        double daughterHeight = (fatherHeight * 0.923 + motherHeight) / 2;
        //5.打印输出最终计算的结果
        System.out.println("儿子预计身高" + sonHeight + "厘米");
        System.out.println("女儿预计身高" + daughterHeight + "厘米");
    }
}

练习题:逻辑判断

已知小红同学有25元,她攒了几天钱之后发现自己的现在的钱比原来的2倍还多出10块。而小蓝同学有30元,他攒了几天钱之后发现自己的钱正好是原来的2倍。于是小胖说:小红和小蓝现在的钱一样多,请问,他说的对吗?

package cn.cxy.exec;

public class TestPrint4 {
    public static void main(String[] args) {
        //1.定义变量保存小红原来的钱数
        int red = 25;
        //2.定义变量保存小蓝原来的钱数
        int blue = 30;
        //3.求小红同学现在的钱数
        red = red * 2 + 10;
        //4.求小蓝同学现在的钱数
        blue *= 2; //这是一种简写形式,等同于blue = blue *2;
        //5.判断并输出两个人的钱是否相等
        System.out.println(red == blue);
    }
}

练习题:最优选择

某小伙想定一份外卖,商家的优惠方式如下:鱼香肉丝单点24元,油炸花生米单点8元,米饭单点3元。订单满30元8折优惠。鱼香肉丝优惠价16元,但是优惠价和折扣不能同时使用。那么这个小伙要点这三样东西,最少要花多少钱?

public class Demo3 {
    public static void main(String[] args) {
        //1.求不使用优惠时的总价
        double money1 = 24 + 8 + 3;
        //2.判断折后总价
        money1 = (money1 <= 30 ? money1 : money1 * 0.8);
        //3.求使用优惠时的总价
        double money2 = 16 + 8 + 3;
        //4.判断两种花费哪个更少
        double money = money1 < money2 ? money1 : money2;
        //5.打印最终花费
        System.out.println(money);
    }
}

练习题:接收用户输入的3个整数,并将它们的最大值作为结果输出

package cn.cxy.exec;

import java.util.Scanner;

public class GetMaxNumber {
    public static void main(String[] args) {
        //1.提示并接收用户输入的三个整数,并交由变量a b c来保存
        System.out.println("请输入第一个整数:");
        int a = new Scanner(System.in).nextInt();
        System.out.println("请输入第二个整数:");
        int b = new Scanner(System.in).nextInt();
        System.out.println("请输入第三个整数:");
        int c = new Scanner(System.in).nextInt();

        //2.对接收到的三个值进行比较
        /**三元运算符 1 ? 2 : 3
         * 如果1号位置的表达式结果为true,结果就取2号位置的值,反之,就取3号位置的值*/
        //2.1定义变量max来保存a和b中的最大值
        int max = a>b ? a : b;
        //2.2比较max与c谁最大,并将最大值交由max来保存
        max = max>c ? max : c;
        /**解决方案二:*/
        //int max = a>b?(a>c?a:c):(b>c?b:c);
        //3.输出结果
        System.out.println("三个数的最大值是:"+max);
    }
}

练习题: BMI 指数测试 BMI = 体重 (kg) / 身高² (m)

接收用户输入的身高和体重,将判断结果输出
过轻:低于18.5
正常:18.5 ~ 22.9
偏胖:23 ~ 24.9
肥胖:25 ~ 29.9
重度肥胖:高于30
极度肥胖:高于40

package cn.cxy.exec;

import java.util.Scanner;

public class TestBMI {
    public static void main(String[] args) {
        //1.提示并接收用户输入的身高与体重信息
        System.out.print("请输入您的身高(单位为m):");
        double height = new Scanner(System.in).nextDouble();
        System.out.print("请输入您的体重(单位为kg):");
        double weight = new Scanner(System.in).nextDouble();

        //2.调用getBMI()方法,根据身高和体重信息,输出结果
        getBMI(height, weight);
    }

    public static void getBMI(double h, double w) {
        //求出BMI指数
        double bmi = w / (h * h);
        //定义一个变量r来保存最终结果
        String r = "";

        //根据 bmi 指数范围,来给r重新赋值
        if (bmi < 18.5) {
            r = "过轻";
        } else if (bmi <= 22.9) {
            r = "正常";
        } else if (bmi <= 24.9) {
            r = "偏胖";
        } else if (bmi <= 29.9) {
            r = "肥胖";
        } else if (bmi <= 40) {
            r = "重度肥胖";
        } else {
            r = "极度肥胖";
        }
        //打印最终结果
        System.out.println("您的BMI指数:" + bmi);

        System.out.println("您的体重属于:" + r);
    }
}

练习题: 最优选择2

小蓝同学想买一个价值8888元的新手机,她的旧手机在二手市场能卖1880元,而手机专卖店推出以旧换新的优惠,把她的旧手机交给店家,新手机就能够打7.5折优惠。为了更省钱,小蓝要不要以旧换新?

public class TestChoice {
    public static void main(String[] args) {
        //1.计算不使用以旧换新的花费
        int plan1 = 8888 - 1880;
        //2.计算以旧换新的花费
        double plan2 = 8888 * 0.75;
        //3.判断两种方式
        if(plan1 > plan2){
            System.out.println("使用以旧换新更省钱");
        }else{
            System.out.println("不使用以旧换新更省钱");
        }
    }
}

练习题:求数字的绝对值

绝对值是指一个数在数轴上所对应点到原点的距离,用“| |”来表示。负数的绝对值是他去掉负号以后的值,而非负数(0和正数)的绝对值是他本身。请定义一个方法,接收用户输入的数字,输出绝对值结果。

package cn.cxy.exec;

import java.util.Scanner;

public class TestNum {
    public static void main(String[] args) {
        //1.接收用户输入的要测试的数字
        System.out.println("请输入你要判断的数字:");
        double input = new Scanner(System.in).nextDouble();
        //2.调用求绝对值的方法并拿到方法执行后的结果(返回值)
        double result = getAbsNum(input);
        //3.打印求出的结果
        System.out.println(input+"的绝对值是:"+result);
    }

    private static double getAbsNum(double input) {
        if(input >=0){//如果是非负数
            return input;//返回本身的值
        }else{//如果是负数
            return -input;//则值取反
        }
    }

}

练习题:银行收入计算

某银行推出了整存整取定期储蓄业务,其存期分为一年、两年、三年、五年,到期凭存单支取本息。存款年利率表如下:
​ 存期 年利率(%)
​ 一年 2.25
​ 两年 2.7
​ 三年 3.25
​ 五年 3.6
请存入一定金额(1000起存),存一定年限(四选一),计算到期后得到的本息总额。
提示:
​ 存入金额和存入年限均由键盘录入
​ 本息计算方式:本金+本金×年利率×年限

import java.util.Scanner;
public class BankDemo {
    public static void main(String[] args) {
        //1.提示并接收用户输入的存款金额
        System.out.println("请输入存款金额:");
        int money = new Scanner(System.in).nextInt();
        //2.提示并接收用户输入的存款年限
        System.out.println("请输入存款年限:");
        int year = new Scanner(System.in).nextInt();
        //3.定义变量用来保存本金和利息之和
        double outMoney = 0;
        //4.根据利率和年限计算本息和
        if (year == 1) {
            outMoney = money + money * 2.25 / 100 * 1;
        } else if (year == 2) {
            outMoney = money + money * 2.7 / 100 * 2;
        } else if (year == 3) {
            outMoney = money + money * 3.25 / 100 * 3;
        } else if (year == 5) {
            outMoney = money + money * 3.6 / 100 * 5;
        } else {
            System.out.println("输入的年限有误");
        }
        //5.打印输出
        System.out.println("存款" + year + "年后的本息是:" + outMoney);
    }
}

练习题:求税后工资问题

2019年1月1日起,国家推出新的个人所得税政策,起征点上调值5000元。也就是说税前工资扣除三险一金(三险一金数额假设是税前工资的10%)后如果不足5000元,则不交税。如果大于5000元,那么大于5000元的部分按梯度交税,具体梯度比例如下:
​ 0 ~ 3000元的部分,交税3%
​ 3000 ~ 12000元的部分,交税10%
​ 12000 ~ 25000的部分 , 交税20%
​ 25000 ~ 35000的部分,交税25%
​ 35000 ~ 55000的部分,交税30%
​ 55000 ~ 80000的部分,交税35%
​ 超过80000的部分,交税45%
比如:小蓝入职一家企业后,税前工资是18000,则他每月该交个税的部分是18000-1800-5000=11200元,个税缴纳数额是3000×3%+8200×10%=910元。税后工资15290元。
请完成一个个税计算程序,在用户输入税前工资后,计算出他对应的纳税数额,以及税后工资为多少?

import java.util.Scanner;
public class Demo5 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您的税前工资:");
        //2.键盘录入税前工资
        int money = sc.nextInt();
        //3.计算应纳税部分的工资
        double before = money - (money*0.1) - 5000;
        //4.定义个税变量
        double shui = 0;
        //5.按照梯度范围计算个税数值
        if(before > 0 && before <=3000){
            shui = before * 0.03;
        }else if(before > 3000 && before <=12000){
            shui = 3000*0.03 + (before-3000) * 0.1;
        }else if(before > 12000 && before <=25000){
            shui = 3000*0.03 + 9000*0.1 +  (before-12000)*0.2;
        }else if(before > 25000 && before <=35000){
            shui = 3000*0.03 + 9000*0.1 + 13000*0.2 + (before-25000)*0.25;
        }else if(before > 35000 && before <=55000){
            shui = 3000*0.03 + 9000*0.1 + 13000*0.2 + 10000*0.25 + (before-35000)*0.3;
        }else if(before > 55000 && before <=80000){
            shui = 3000*0.03 + 9000*0.1 + 13000*0.2 + 10000*0.25 + 20000*0.3 + (before-55000)*0.35;
        }else if(before > 80000){
            shui = 3000*0.03 + 9000*0.1 + 13000*0.2 + 10000*0.25 + 20000*0.3 + 25000*0.35 + (before-80000)*0.45;
        }
        //6.计算税后工资
        double after = money - (money*0.1) - shui;
        //7.打印个税和税后工资
        System.out.println("个人所得税" + shui + "元");
        System.out.println("税后工资" + after + "元");
    }
}

练习题: 手机选号:根据用户输入的手机号来确认用户实际支付的价格

如果尾数为8,需支付办卡费50元
如果尾数为4,需支付办卡费用0元
如果是其他尾号,需支付办卡费用20元

package cn.cxy.exec;

import java.util.Scanner;

public class PayCard {
    public static void main(String[] args) {
        //1.提示并接收用户输入的手机号
        System.out.println("请输入您预选的手机号:");
        String tel = new Scanner(System.in).nextLine();//注意String类型数据一般用nextLine()

        //2.调用getPrice()方法,来计算价格,注意需要把手机号tel作为参数传入方法中
        getPrice(tel);
    }

    //3.创建getPrice()
    public static void getPrice(String tel) {
        //3.1 手机号tel的长度,必须是11位的正确手机号--提前校验,提高程序健壮性
        if(tel.length() != 11) {
            System.out.println("号码格式错误");
            return;//结束方法,返回到调用位置再继续执行
        }

        /*比如我们拿到的手机号是tel="2313123123",想要拿到尾数,也就是最后一个字符
         * 需要用到 char c = tel.charAt(10)
         * 注意:由于下标也是从0开始,所以取第11个字符,它的下标位置是10
         */
        //3.2获取手机号的尾数
        char c = tel.charAt(10);

        //3.2定义用来保存最终结果的变量price,初始值为0
        int price = 0;

        //3.3根据c字符的值,来为price重新赋值
        switch(c) {
            case '8': price=50; break;//尾数为8支付50
            case '4': price=0; break;//尾数为4免费
            default: price=20;//其他情况需支付20
        }
        //3.4显示结果
        System.out.println("您实际应支付的价格为:"+price);
    }
}

练习题 : 分别通过for循环/While循环/do-While循环写一个死循环

package cn.cxy.exec;

public class DeadCycle {
    public static void main(String[] args) {
        //for循环的死循环
//        for (int i = 1; ; i++){
//            System.out.println("欢迎学习泡泡的分享,继续加油哦~");
//        }
        //while循环的死循环
//        while(true){
//            System.out.println("都到这里啦?奥利给~");
//        }
        //do-while循环的死循环
        do{
            System.out.println("相信我们可以的~");
        }while(true);
    }
}

练习题:鸡兔同笼问题(穷举法)

已知:鸡兔共35,94只脚,那么鸡和兔各几只?
package cn.cxy.exec;
//穷举法
//鸡    兔
//0     35
//1     34
//2     33
//3     32
//...
//23    12
//...
//35    0
public class SameCage {
    public static void main(String[] args) {
        //循环变量j,控制小鸡的个数: 0到35递增
        //循环变量t,控制兔子的个数: 35到0递减
        for(int j=0,t=35; j<=35; j++,t--) {//如果有多个小条件,用逗号隔开
            //保证脚的数量是94
            if(j*2 + t*4 == 94) {
                System.out.println("鸡:"+j+", 兔:"+t);
            }
        }
    }
}

练习题:求数字阶乘(for循环版)

需求:接收用户输入的数字,计算该数字的阶乘结果
已知:负数不可以有阶乘,0的阶乘结果是1,
5 ! = 5 x 4 x 3 x 2 x 1

package cn.cxy.exec;

import java.util.Scanner;

public class Factorial {
    public static void main(String[] args) {
        System.out.print("输入整数,求阶乘:");
        int n = new Scanner(System.in).nextInt();
        //调用f()方法,把n的值传递到f()方法,求阶乘
        f(n);
    }

    public static void f(int n) {
        if(n<0) {
            System.out.println("负数不可以求阶乘");
            return;//方法结束,返回到调用位置继续执行
        }
        if(n == 0) {
            System.out.println("0的阶乘是1");
            return;
        }
        /*
         * r = 5
         * i
         * 4, r=r*i
         * 3, r=r*i
         * 2, r=r*i
         * 1, r=r*i
         */
        long r = n;
        for(int i=n-1; i>=1; i--) {
            r *= i;
        }
        System.out.println(n+"的阶乘:"+r);
    }
}
/**其实我们还可以通过递归思想解决这个问题,感兴趣的可以研究一下~*/

练习题:多次生成随机数,并打印第一次出现大于0.999 时的次数与生成的随机数

package cn.cxy.exec;

public class ForBreak {
    public static void main(String[] args) {
        // Math.random()可以产生[0,1)的随机浮点数
        // >0.999
        //写一个死循环, i变量用来计次
        for(int i=1; ;i++) {
            double d = Math.random();
            if(d>0.999) {
                System.out.println("第"+i+"次产生了目标值,值为:"+d);
                break;
            }
        }
    }
}

练习题:打印100以内除了尾数为3,5,7的所有数

package cn.cxy.exec;

public class ForContinue {
    public static void main(String[] args) {
        for(int i=1;i<=100;i++) {
            int y = i%10;//100以内的数,通过取余求出尾数
            if(y==3 || y==5 || y==7) {
                continue;//如果尾数为3 5 7 ,则跳过后面的打印,进行下一轮循环
            }
            System.out.println(i);
        }
    }
}

练习题:求质数:接收用户输入的数字,判断是否为质数

质数的概念:一个大于1的自然数,除了1和它自身外,不能被其他自然数整除的数叫做质数,也称为素数
规定:1既不是质数,也不是合数

package cn.cxy.exec;

import java.util.Scanner;

public class PrimeNumber {
    public static void main(String[] args) {
        System.out.print("请输入要判断的自然数:");
        int n = new Scanner(System.in).nextInt();
        //调用getPrimeNumber()方法,判断n是否为质数
        getPrimeNumber(n);
    }
    public static void getPrimeNumber(int n) {
        if(n<2) {//此范围内的数均不为质数
            System.out.println(n+"不是质数");
            return;//结束程序
        }
        if(n == 2) {
            System.out.println("2是质数");
            return;
        }
        //在 2到 1+n开方范围(数学理论),找能把n整除的值(这个值也称作因子)
        //如果找到可以把n整除的第三个数,那n就不是质数,反之,n为质数
        double max = 1+ Math.sqrt(n);//max保存的是查找因子的范围

        //依次遍历范围内的所有数,验证是否存在n的因子
        for(int i=2; i<max; i++) {
            //判断n能不能被i整除,如果有,说明不是质数
            if(n%i == 0) {
                System.out.println(n+"不是质数");
                return;
            }
        }
        //如果判断了范围内的所有值,没有能整除的,则说明n是质数
        System.out.println(n+"是质数");
    }
}

练习题:接收用户输入的数字,判断在此范围内质数的个数

package cn.cxy.exec;

import java.util.Scanner;

public class CountPrimeNumber {
    public static void main(String[] args) {
        System.out.println("输入整数n,求n内质数的数量");
        int n = new Scanner(System.in).nextInt();

        count(n);
    }

    public static void count(int n) {
        if(n<2) {
            System.out.println("没有质数");
            return;
        }
        if(n==2) {
            System.out.println("有1个质数");
            return;
        }
        //定义计数变量
        int count = 1;//已知有一个质数
        outer:   //从3到n寻找质数
        for(int i=3; i<=n ;i++) {
            //判断i是否是质数
            double max = 1+ Math.sqrt(i);
            for(int j=2; j<max; j++) {//在2到<max,找能把i整除的数
                if(i%j == 0) {//i被j整除,i不是质数
                    //跳到i++,继续判断下一个i值
                    continue outer;//跳到外部outer的位置
                }
            }
            //内层j循环结束,i是质数
            count++;
        }
        System.out.println(n+"内质数的数量:"+count);
    }
}

练习题:生成一个顺序数组,将这个数组的元素打乱顺序后输出

package cn.cxy.exec;

import java.util.Arrays;
import java.util.Random;

public class ShuffleArray {
    public static void main(String[] args) {
        //调用f()方法,从方法获取一个int[]数组
        int[] a = f();
        //遍历打印数组数据
        for(int i=0; i<a.length; i++) {
            System.out.println(a[i]);
        }
        System.out.println("\n\n----------------");

        //把a数组,传递到 shuffle() 方法打乱顺序
        shuffle(a);
        //打印乱序后的数组
        System.out.println(Arrays.toString(a));
    }

    public static int[] f() {
        //新建int[]数组,长度5
        //再把它的内存地址存到变量 a
        int[] a = new int[5];
        //遍历访问5个位置,填入1,2,3,4,5
        for(int i=0; i<a.length; i++) {
            a[i] = i+1;
        }
        //返回数组,把数组返回到调用位置
        //本质是把数组地址返回去
        return a;
    }

    public static void shuffle(int[] a) {
        /*
         *        j
         * [4, 2, 3, 1, 5]
         *     i
         *
         * *) i循环遍历数组
         * *) 随机定位下标j与i交换
         */
        for (int i = 0; i < a.length; i++) {
            //随机下标j,范围:[0, a.length)
            int j = new Random().nextInt(a.length);
            int t = a[i];
            a[i] = a[j];
            a[j] = t;
        }
    }
}

练习题:求数字阶乘(递归解法版)

需求:接收用户输入的数字,计算该数字的阶乘结果
已知:负数不可以有阶乘,0的阶乘结果是1,
5 ! = 5 x 4 x 3 x 2 x 1

package cn.cxy.design;
//需求:求用户输入数字的阶乘结果
//f(int n)--用来求阶乘
//规律:
//f(n)= n*f(n-1)
//f(5)= 5*4*3*2*1 = 5*f(4) 
//f(4)= 4*3*2*1 = 4*f(3)
//f(3)= 3*2*1 = 3*f(2)
//f(2)= 2*1 = 2*f(1)
//f(1)= 1
//
//5!=5*4*3*2*1=120
//4!=4*3*2*1
//3!=3*2*1
//2!=2*1
//1!=1

public class TestRecursion {
	public static void main(String[] args) {
		int result = f(15);//调用f()用来求阶乘
		System.out.println(result);
	}
	/**递归的两要素 1.总结规律 2.最简问题*/
	public static int f(int n) {
		if(n == 1) {//最简问题
			return 1;
		}else {//其他情况 n*f(n-1)
			//递归:再方法内部自己调用自己
			return n*f(n-1);
		}
	}
}

在这里插入图片描述

练习题13:打印全三角形

需求:接收用户输入的行数,打印对应的全三角形,如图所示:
在这里插入图片描述
在这里插入图片描述

package cn.cxy.exec;

import java.util.Scanner;

public class PrintTraingle {
	public static void main(String[] args) {
		//1.提示并接收用户输入的行数:
		System.out.println("请输入您要打印星星的行数:");
		int n = new Scanner(System.in).nextInt();

		//2.开始打印图形
		//2.1外层循环控制打印的行数 i的取值范围:[1,n],一共n行
		for(int i=1;i<=n;i++){
			//2.2内层循环1
			//控制每行打印空格的个数 j的取值范围:[0,n-i),即1 2 3...
			for(int j=0;j<n-i;j++){
				System.out.print(" ");
			}
			//2.3内层循环2
			//控制每行打印星星的个数 k的取值范围:[1,2*i-1],即1 3 5 ...
			for(int k=1;k<=2*i-1;k++){
				System.out.print("*");
			}
			//2.4打印完本行所有内容后添加换行
			System.out.println();
		}
	}
}

练习题:求任意自然数各位数之和

接收用户输入的任意自然数,累计所有位数数字之和
需求:接收用户输入的行数,

package cn.cxy.exec;

import java.util.Scanner;

public class SumNum {
	public static void main(String[] args) {
		//1.提示并接收用户要计算的自然数:
		System.out.println("请输出您要求和的自然数:");
		int n = new Scanner(System.in).nextInt();
		//2.定义一个变量用来保存最终求和的结果
		int sum=0;
		//3.循环获取每一位上的数
		while(n!=0){
			//4.求当前的个位数,并将个位数累加
			sum = sum + (n%10);
			//5.去掉刚刚累加过的最后一位数,得到新的整数
			//比如刚刚的十位就变成了现在的个位
			n=n/10;
		}
		//6.打印最终的结果:
		System.out.println(sum);
	}

}

练习题:求任意数组中所有元素的最大值

package cn.cxy.exec;

public class GetArrayMaxNum {
		public static void main(String[] args) {
			//1.定义一个数组
			int[] arr={90,1562,43,2,44,8,6666};
			//2.选取数组中的第一个元素开始比较
			int max=arr[0];
			//3.依次遍历数组中的每个元素
			for(int i=1;i<arr.length;i++){//i指的是下标,我们通过下标来操作数组中的元素
				//4.判断当前元素与目前最大值的大小
				if(arr[i]>max){
					//5.如果当前数组元素大于max,就讲此元素的值赋值给max
					max=arr[i];
				}
			}
			//6.打印最终的结果
			System.out.println(max);
		}
	}

练习题:求1000以内的完数

完数:如果一个数等于其所有因子之和,我们就称这个数为"完数",比如6的因子为1,2,3 6 = 1 + 2 + 3,那么6就是一个完数

 package cn.cxy.exec;
/**获取1000以内的完数*/
public class GetNum {
	public static void main(String[] args) {
		//1.循环遍历1000以内的所有数
		for(int i=1;i<=1000;i++){
			//2.定义一个变量来保存求和的结果
			int sum = 0;
			//3.求i的因子
			for(int j=1;j<=i/2;j++){
				//4.判断是否能被整除
				if(i % j == 0){
					//5.如果能整除,就是因子,因子需要累加
					sum+=j;
				}
			}
			//6.如果因子累加之和为本轮判断的数,则当前数是完数,输出
			if(sum==i){
				System.out.println(i);

			}
		}
	}
}

练习题:求猴子大王

15个猴子围成一圈选大王,依次1-7循环报数,报到7的猴子被淘汰,直到最后一只猴子称为大王,问:哪只猴子会成为大王?

package cn.cxy.exec;
/**猴子选大王*/
public class MonkeyKing {
	public static void main(String[] args) {
		//1.定义长度为15的数组保存猴子,boolean类型是为了判断猴子是否存活
		boolean[] b=new boolean[15];

		//2.依次遍历每一只猴子
		//true---未淘汰  false---已淘汰
		for(int i=0;i<b.length;i++){
			b[i]=true;//先把所有猴子设置成存活
		}
		//3.定义变量保存猴子报的数
		int num=0;
		//4.定义变量保存剩余的猴子数
		int monkeyLeft=15;
		//5.定义数组下标
		int index=0;
		//6.循环,直到只剩最后一只猴子(猴子王)
		while(monkeyLeft>1){//判断条件
			//7.检测猴子是否已淘汰
			if(b[index]){
				//8.报数
				num++;
				//9.判断报数是否为7
				if(num==7){
					b[index]=false;//为7淘汰
					monkeyLeft--;//猴子数减一
					num=0;//报数归零
				}

			}

			//10.下标移动
			index++;
			//11.围成一圈---最后一个置为0
			if(index==15){
				index=0;
			}
		}

		//遍历数组,找到最后活着的那个猴子王
		for(int i=0;i<b.length;i++){
			if(b[i]){
				System.out.println(i+1);
			}
		}
	}
}

练习题:斐波那契问题

已知:斐波那契数列的前几个数分别为0,1,1,2,3,5…从第三项开始,每一项都等于前两项的和.请接收用户输入的整数n,求出此数列的前n项.

package cn.cxy.exec;

import java.util.Scanner;

/**斐波那契数列*/
public class Faibonacci {
	public static void main(String[] args) {
		System.out.println("请输入您要测试的数:");
		int n = new Scanner(System.in).nextInt();
		//判断n是否是不正常的范围
		if(n<1){
			System.out.println("输入数据有误!!!");
		}
		//n==1
		if(n==1){
			System.out.println(0);
		}
		//n==2
		if(n==2){
			System.out.println(0+"\t"+1);	
		}
		//n==3
		if(n==3){
			System.out.println(0+"\t"+1+"\t"+1);	
		}
		//拼接前n项
		if(n>3){
			System.out.print(0+"\t"+1+"\t"+1+"\t");	
		}
		//循环输出后面的数据
		int f1=1;
		int f2=1;
		int next=0;
		for(int i=4;i<=n;i++){
			next=f1+f2;
			f1=f2;
			f2=next;
			System.out.print(next+"\t");
		}
	}
}

练习题:古典问题:有一对兔子,从出生后第3个月起都生一对兔子,小兔子长到第三个月后每个月又生一对兔子,假如兔子都不死,问每个月兔子的对数为多少?

程序分析:前两个月兔子的对数为1
从第三个月开始,兔子的对数变成了 2 3 5 8 13 21 …

package cn.cxy.exec;

import java.util.Scanner;

public class GetRabbitNum {
	public static void main(String[] args) {
		System.out.println("请输入要判断的月数:");
		int month = new Scanner(System.in).nextInt();
		System.out.println("第"+month+"月兔子的对数为:"+getSum(month));
	}

	public static int getSum(int month) {
		//如果是前两个月,还是1对兔子
		if(month == 1 || month == 2) {
			return 1;
		}else {
			//从第三个开始,兔子按照2 3 5 8 13 21变化
			return getSum(month-1)+getSum(month-2);
		}
	}
}

练习题:打印水仙花数

水仙花数:是指一个三位数,其各位数字立方和等于该数字本身
例如:153就是一个水仙花数,因为153 = 1³ + 5³ + 3³

package cn.cxy.exec;

public class GetNum {
	public static void main(String[] args) {
		//1.遍历所有的三位数
		for (int i = 100; i < 1000; i++) {
			//2.调用自定义方法判断是不是水仙花数
			if(isAim(i)) {
				//3.如果是水仙花数,就打印
				System.out.println(i);
			}
		}
	}

	//4.自定义判断水仙花数的方法
	public static boolean isAim(int a) {
		int x = a/100;
		int y = a/10%10;
		int z = a%10;
		if(a == x*x*x+y*y*y+z*z*z) {
			return true;
		}
		return false;
	}
}

练习题:递归求目录总大小

需求:递归求目录的总大小 D:\ready,步骤分析如下:
1.列出文件夹中的所有资源–listFiles()–>File[]
2.判断,当前资源是文件还是文件夹–文件夹大小为0,文件大小需要累加
–是文件,求文件的字节量大小length(),累加就行
–是文件夹,继续列出文件夹下的所有资源–listFiles()–>File[]
–判断,是文件,求文件的字节量大小length(),累加就行
–判断,是文件夹,再一次列出文件夹下的所有资源
–…重复操作
也就是说,规律就是:只要是文件夹,就需要重复步骤1 2

package cn.cxy.file;

import java.io.File;

/**本类用来递归求目录总大小*/
public class FileSumRecursion {
	public static void main(String[] args) {
		//1.指定要求哪个目录的总大小
		/**注意:此处指定的目录必须是真实存在的
		 * 如果传一个不存在的文件夹会报错,如果是传了一个空文件夹,大小为0*/
		File file = new File("D:\\ready");
		//2.调用size()求目录大小
		long total = size(file);
		//3.接收结果并打印
		System.out.println("文件夹的总大小为:"+total);
	}

	private static long size(File file) {
		//1.列出文件夹中的所有资源--listFiles()-->File[]
		File[] fs = file.listFiles();
		
		//2.遍历数组,获取每file对象
		//2.1定义变量,记录总和
		long sum = 0;
		for(int i = 0;i < fs.length ; i++) {
			//2.2通过下标操作当前遍历到的资源
			File f = fs[i];
			//2.3判断,当前资源是文件还是文件夹--文件夹大小为0,文件大小需要累加
			if(f.isFile()) {
				//--是文件,求文件的字节量大小length(),累加就行
				sum += f.length();//相当于:sum = sum + f.length();
			}else if(f.isDirectory()) {
				//--是文件夹,继续列出文件夹下的所有资源,1 2步骤--listFiles()-->File[]
				/**方法的递归,递归现象,就是在方法的内部调用方法自身*/
				sum += size(f);
			}
		}
		return sum;//把sum记录的值返回调用位置
	}
}

练习题:递归删除文件夹

需求:递归删除文件夹 D:\ready\a
1.列出文件夹下的所有资源listFiles()
2.判断,当前资源是文件还是文件夹
–判断,是文件,直接删除delete()
–判断,是文件夹,继续重复操作1 2
具体思路可以分为这么几步:
1.首先,我们需要指定一个根目录作为要删除的对象
2.列出文件夹下的所有资源listFiles(),并进行遍历
3.判断当前的资源,如果是文件,直接删除;如果是文件夹,则执行步骤2
4.将文件夹中的内容删除完毕后,删除文件夹本身

package cn.tedu.file;

import java.io.File;

/**本类用于递归删除目录*/
public class TestFileDeleteRecursion {
	public static void main(String[] args) {
		//1.指定要删除的目录
		/**为了更好的测试,注意指定的目录是已存在的目录,但是,千万不要删盘符!!!!*/
		/*我们也有一些没有权限的文件夹,那个是无法访问且不能删除的哦*/
		File file = new File("D:\\ready\\a");
		//2.调用删除目录的方法
		boolean result = del(file);
		//3.打印删除的结果
		System.out.println("删除的结果为:"+result);
	}

	public static boolean del(File file) {//完成的同学不是很多,抓紧时间写,写完截图发群里哈,这首歌结束我们继续
		//1.列出文件夹下的所有资源
		File[] fs = file.listFiles();
		//2.循环遍历拿到的所有资源
		for (int i = 0; i < fs.length; i++) {
			//2.1获取本次循环遍历到的file对象
			File f = fs[i];
			//3.判断,当前资源是文件还是文件夹
			if(f.isFile()) {
				f.delete();//是文件,直接删除
				System.out.println(file.getName()+"文件删除成功!");
			}else if(f.isDirectory()) {
				//是文件夹,需要继续进行步骤1 2 ,出现了重复调用的情况
				//递归,在方法的内部调用自己
				del(f);
			}
		}
		//位置:在for循环执行之外删除文件夹
		file.delete();//空文件夹直接删除
		System.out.println(file.getName()+"文件夹删除成功!");
		return true;
	}
}

练习题:复制文件(字节流批量读取)

需求:接收用户目标文件的路径,复制目标文件到指定路径

import java.io.*;
import java.util.Scanner;

public class TestCopyFiles {
    public static void main(String[] args) {
        //1.提示并接收用户输入的要复制的源文件路径--复制啥
        System.out.println("请输入源文件路径:");
        String f = new Scanner(System.in).nextLine();

        //2.提示并接收用户输入的目标文件所在的位置--复制到哪
        System.out.println("请输入目标文件的路径:");
        String t = new Scanner(System.in).nextLine();

        //3.1根据源文件路径封装from文件对象
        File from = new File(f);
        //3.2根据目标文件路径封装to文件对象
        File to = new File(t);
        //3.3根据用户提供的路径完成文件的复制操作
        copy(from,to);
    }

    public static void copy(File from, File to) {
        InputStream in = null;//定义在整个方法中都生效的字节输入流对象,注意是局部变量,需要初始化,对象的默认值是null
        OutputStream out = null;//定义在整个方法中都生效的字节输出流对象,注意是局部变量,需要初始化,对象的默认值是null
        try {
            //1.读取from文件--操作文件的是字节输入流
            in = new BufferedInputStream(new FileInputStream(from));
            //2.写出到to文件--操作文件的是字节输出流
            out = new BufferedOutputStream(new FileOutputStream(to));

            //3.边读边写
            int b = 0;//定义变量b,记录读取到的数据
            /**需求:想要实现批量读取,使用的是read(byte[] b)重载的形式,可以按照数组的方式来读 */
            /**可以自定义数组,长度建议与源码保持一致,8*1024 = 8192*/
            byte[] bs = new byte[8*1024];
            while( (b=in.read(bs)) != -1 ) {//只有没有数据时,才返回-1,跳出循环,读写结束
                out.write(bs);//将读到的数据写出到文件
            }
            System.out.println("恭喜您!文件复制成功!");
        } catch (IOException e) {
            System.out.println("很抱歉!文件复制失败!");
            e.printStackTrace();//打印错误信息
        }finally {
            //释放资源
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

练习题:回文问题

需求,如果一个用户输入的数据,从前到后或者从后到前读到的内容都是一样的,我们就称这种数据为"回文",比如123321 或者 12321 或者上海自来水来自海上等等

import java.util.Scanner;

public class TestNumber {
    public static void main(String[] args) {
        System.out.println("请输入一个字符串:");
        String s = new Scanner(System.in).nextLine();

        if(!stringJudge(s)){
            System.out.println(s + "不是回文字符串");
        }else{
            System.out.println(s + "是回文字符串");
        }
        //调用第二个方法解决
        stringJudge2(s);
    }

    //判断字符串是否回文
    private static boolean stringJudge(String str) {
        for (int i = 0; i < str.length() - i - 1; i++){
            if(str.charAt(i) == str.charAt(str.length() - i - 1)){
                continue;
            }else{
                return false;
            }
        }

        return true;
    }
    //判断字符串是否回文2
    private static void stringJudge2(String s) {
        //方法2:将字符串反转比较
        String s2 = new StringBuffer(s).reverse().toString();
        if(s.compareTo(s2) == 0){
            System.out.println(s + "是回文字符串");
        }else{
            System.out.println(s + "不是回文字符串");
        }
    }
}
打赏
文章很值,打赏犒劳作者一下
相关推荐
©️2020 CSDN 皮肤主题: 数字20 设计师:CSDN官方博客 返回首页

打赏

程序媛 泡泡

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者