Java常见练习题总结

YOLO~~~

已于 2022-01-28 17:23:27 修改

阅读量2.9k

点赞数 5

分类专栏： Java SE 基础编程文章标签： java

于 2021-10-20 16:55:28 首次发布

本文链接：https://blog.csdn.net/m0_57105290/article/details/120839281

版权

Java SE 基础编程专栏收录该内容

10 篇文章 3 订阅

订阅专栏

本文涵盖了Java编程的基础语法，包括输出整数、判断闰年、计算素数、乘法口诀、最大公约数、级数求和、计数、自幂数等。同时涉及递归算法，如阶乘、斐波那契数列和数字位序打印。此外，还讨论了数组操作，如二分查找、冒泡排序和数组逆序。这些实例展示了Java在算法和数据结构上的应用。

摘要由CSDN通过智能技术生成

Java基本语法练习题

1.基本语法练习题

1.1输出一个整数的每一位

参考代码：

//通过循环来不断的%10/10来获取每一位
    public static void func4(int n){
        while(n!=0){
            System.out.print(n%10+" ");
            n/=10;
        }
    }

1.2输出1000-2000之间所有的闰年

参考代码：

 //2.输出1000-2000之间所有的闰年
        for(int year=1000;year<=2000;year++){
            if((year % 4 == 0&& year % 100 != 0)||year % 400 == 0){
                System.out.println(year);
            }
        }

1.3打印1-100之间所有的素数

素数：大于1自然数，且只能被1和其自身整除的数
参考代码：

public class test {
    public static boolean isPrime1(int n) {//方法一
        for(int i = 2;i < n;i++){
            if(n % i==0){//在n的范围内没有其他数字可以被n整除
                return false;//否则返回 false
            }
        }
        return true;
    }
    public static boolean isPrime2(int n) {//方法二
        for(int i = 2;i <=Math.sqrt(n);i++){
        //该算法只在该数字的开方内寻找，效率更高
            if(n % i==0){
                return false;
            }
        }
        return true;
    }

1.4输出乘法口诀

参考代码：

 // 3.输出乘法口诀
        for(int i=1;i<=9;i++){//一共打印9行
            for(int j=1;j<=i;j++){//每行的输出不超过行数
            //注意这里是print
                System.out.print(j+"*"+i+"="+i*j+"  ");
            }
            System.out.println();
        }

输出结果：
九九乘法表

1.5求两个整数的最大公约数

辗转相除法，又名欧几里德算法（Euclidean algorithm），是求最大公约数的一种方法。它的具体做法是：用较小数除较大数，再用出现的余数（第一余数）去除除数，再用出现的余数（第二余数）去除第一余数，如此反复，直到最后余数是0为止。如果是求两个数的最大公约数，那么最后的除数就是这两个数的最大公约数
辗转相除法
参考代码：

// 求两个整数的最大公约数
        //辗转相除法
    public static int func(int a,int b){//辗转相除法
        int c = a % b;
        while(c!=0){//余数不为0，则进入循环
            a=b;//把除数赋值给被除数
            b=c;//余数赋给除数
            c=a%b;//新的余数
        }
        return b;

    }

1.6计算1/1-1/2+1/3-1/4+1/5…+1/99-1/100的值

参考代码：

    public static double func1(int n){//求1/1-1/2+1/3-1/4+1/5......+1/99-1/100的值
        double sum=0.0;//注意，需要用double 类型
        int flg=1;//用于修改+-号
        for(int i=1;i<=n;i++){
            sum=sum+(flg)*1.0/i;
            flg=-flg;
        }
        return sum;
    }

运行结果：

1.7到100之间的所有整数中出现多少个9

参考代码：

    public static int func2(int n){
        int count=0;
        for(int i=1;i<=n;i++){//99有两个9
            if(i%10==9){//个位上有9的数字个数
                count++;
            }if(i/10==9){//十位上有9的个数
                count++;
            }
        }
        return count;
    }

运行结果：

1.8输出10000000以内的自幂数

如果在一个固定的进制中，一个n位自然数等于自身各个数位上数字的n次幂之和，则称此数为自幂数。（按10进制）
例如：在十进制中，153是一个三位数，各个数位的3次幂之和为

1 ^ 3+5 ^ 3+3^3=153，所以153是十进制中的自幂数

   public static void func6(int n){
        for(int i=0;i<n;i++){
            int sum=0;
            int count=0;//计算位数
            int tmp=i;//避免求数字位数时导致数字丢失
            //1.求当前数字是几位数
            while(tmp!=0){
                count++;
                tmp/=10;// 123/10=12  12/10=1  1/10=0
            }
            //得到当前数字的每一位
            tmp=i;//避免求数字位数时导致数字丢失
            while(tmp!=0){//对数字的每一位进行总位数的次方，并求和
            //如135则为 1^3+5^3+3^3
                sum+=Math.pow(tmp%10,count);
                tmp=tmp/10;//参考第一题中获得一个数的每一位
            }
            if(sum==i){
                System.out.println(i);
            }
        }
    }

运行结果：屏幕大小受限1~9之间的没有截屏
自幂数

1.9编写代码模拟三次密码输入场景

参考代码：

    public static void guessPassword(){//猜密码三次登陆
        Scanner scanner = new Scanner(System.in);
        int count = 3;
        while(count != 0){
            System.out.println("请输入你要猜的密码：");
            String password = scanner.nextLine();
            if(password.equals("superman")){
                System.out.println("登录成功！");
                return;
            }else{
                count--;
                System.out.println("你还有"+count+"次机会！");
            }
        }
    }

运行结果：
猜三次密码

1.10写一个函数返回参数二进制中1的个数

//输入20
    public static int func3(int n){
        int count = 0;
        while(n!=0){
            count++;
            n=n&(n-1);
        }
        return count;
    }

运行结果：
在这里插入图片描述

1.11判断数字n是不是2的k次方

若n是2的k次方则其在内存中的二进制只有一位是1，此时 n&n-1结果是0
参考代码：

    public static boolean fun5(int n){
        return ((n&(n-1))==0);
    }

1.12获取一个数二进制序列中所有的偶数位和奇数位（*）

解题思路：
创建 n 变量储存输入数，然后由两个循环分别由高位到低位遍历输入数的二进制序列。奇数列从 n >> 31 一直遍历到 n >> 1 并将每一位都输出，需要注意 println 是带换行符的输出，为了让数列保持在同一行，要换用 print 来输出，循环结束后再加一个换行语句，开启下一条偶数列循环。偶数列由 n >> 30 遍历到 n >> 0 并将每一位都输出，就能得到偶数列。
代码实现：

    public static void main(String[] args) {
            System.out.println("请输入一个整数: ");
            Scanner scan = new Scanner(System.in);
            int n = scan.nextInt();

            //打印奇数
            System.out.println("奇数是：");
            for(int i = 31; i >= 1; i -= 2){
                System.out.print(((n>>i)&1) + " ");
            }
            System.out.println();

            //打印偶数
            System.out.println("偶数是：");
            for(int i = 30; i >= 0; i -= 2){
                System.out.print(((n>>i)&1) + " ");
            }

运行结果：
打印奇数位和偶数位

1.13完成猜数字游戏

游戏规则：
系统自动生成一个随机整数（1-100），然后用户输入一个猜测的数字，如果输入的数字比该随机数小，提示“猜小了”，如果输入的数字比随机数小提示“猜大了”，如果相等则输入“猜对了”。
参考代码：

import java.util.Random;
import java.util.Scanner;

public class test {
        // 12.完成猜数字游戏
        Random random = new Random();//默认随机种子是系统时间
        
        Scanner sc = new Scanner(System.in);
        int toGuess = random.nextInt(100)+1;//随机生成的数字范围是[0，100)，+1才满足题意
        while(true) {
            System.out.println("请输入要猜测的数字：（1-100）");
            int num = sc.nextInt();
            if (num < toGuess) {
                System.out.println("猜小了");
            } else if (num > toGuess) {
                System.out.println("猜大了");
            } else {
                System.out.println("恭喜你，猜对了");
                break;
            }
        }

    }
}

运行结果：
猜数字

1.14有一组数据，只有一个数字是出现一次，其他是两次，请找出这个数字。

方法：对同一数据遍历两次，记录数字出现的次数，若相同数值只出现一次，打印

    public static void findOne(int[] a){
        for (int i = 0; i < a.length; i++) {//第一次遍历
            int count =0;//记录
            for (int j = 0; j < a.length; j++) {//第二次遍历
                if(a[i]==a[j]){//每次遇到相同数值都会++
                    count++;
                }
            }
            if(count ==1){//只有出现一次的才是1
                System.out.println(a[i]);
            }
        }

1.15调整数组顺序使得奇数位于偶数之前。调整之后，不关心大小顺序

    public static void order(int[]arr) {
        int left = 0;
        int right =arr.length-1;
        while (left < right)
        {
            while ((left < right) && (arr[left] % 2 == 1))
            {
                left++;//是奇数时，数组向右继续
            }
            while ((left < right) && (arr[right] % 2 == 0))
            {
                right--;//是偶数时，数组向左继续
            }
            if (left < right)
            {
                int tmp = arr[left];//当奇数在右边，偶数在左边，完成交换
                arr[left] = arr[right];
                arr[right] = tmp;
            }
        }
    }

2.递归练习题

2.1递归求N的阶乘

    public static int func(int n){
        if(n==1){
           return 1;
        }
        return n*func(n-1);
    }

2.2求斐波那契数列的第N项

    //递归的方法
    public static int fib1(int n){
        if(n==1||n==2){
            return 1;
        }
        return fib1(n-1)+fib1(n-2);
    }

    //迭代的方法
    public static int fib2(int n){
        int a=1;
        int b=1;
        int c=0;
        for (int i = 3; i <=n ; i++) {
            c=a+b;
            b=a;
            a=c;
        }
        return c;
    }

2.3按顺序打印一个数字的每一位

    public static void print(int n){
        if(n>9){
            print(n/10);
        }
        System.out.print(n%10+" ");
    }

2.4输入一个非负整数，返回组成它的数字之和

    public static int add(int n){
        if(n<10){
            return n;
        }
        return n%10 +func14(n/10);
    }

3.数组练习题

3.1二分查找法

    public static int binarySearch(int[] arr,int toFind){
        int left = 0;
        int right = arr.length-1;
        while(left<right){
            int mid =(left+right)/2;
            if(toFind<arr[mid]){
                right=mid-1;
            }else if(toFind>arr[mid]){
                left=mid+1;
            }else{
                return mid;
            }
        }
        return -1;
    }

3.2冒泡排序

    public static void bubbleSort(int[] arr){
        for (int i = 0; i < arr.length-1; i++) {
            boolean flg = false;//记录当前是否有序
            for (int j = 0; j < arr.length-i-1; j++) {
                if (arr[j] > arr[j+1]) {//若已经有序则无需再排序
                    int tmp = arr[j];
                    arr[j ] = arr[j+1];
                    arr[j+1] = tmp;
                    flg = true;
                }
            }
            if(flg==false){
                break;
            }
        }
    }

3.3数组逆序

    public static void reverse(int[] arr){
        int left = 0;
        int right = arr.length-1;
        while(left<right){
            int tmp = arr[left];
            arr[left]=arr[right];
            arr[right]=tmp;
            left++;
            right--;
        }
    }