Java基础经典训练题

1. 求和问题

所有的求和问题，都按照下面的步骤来做

定义求和变量sum
遍历获取所有需要求和的数据
和sum累加

//求1-100之间偶数的和
int sum=0; // 定义求和变量
for(int i=1;i<=100;i++){ //遍历所有需要求和的数据
    if(i%2==0){
        sum+=i;  //和sum累加
    }
}
//最终sum记录的就是所有数据的和
System.out.println("1-100的和："+sum);

2. 求最值问题

所有求最值的问题，都按照下面的步骤去做

假定一个数为最大值 max
遍历所有数据和max比较
把较大的数赋值给max，最终max就是最大值

//求数组中元素的最大值
int[] array={3,1,2,5,7,9,10,4};
//假定一个数为最大值 max
int max=array[0];
//遍历所有数据和max比较
for(int i=0;i<array.length;i++){
    if(array[i]>max){
        //把较大的数赋值给max
        max=array[i];
    }
}
//最终max就是最大值
System.out.println("最大值："+max);

3. 求个数问题

所有求个数的问题，都按照下面的步骤来做

定义一个计数器count 默认为0
遍历所有数据，判断是否满足条件
只要满足条件，count++

//求数组中偶数元素有多少个
int[] array={3,1,2,5,7,9,10,4};
//定义一个计数器count 默认为0
int count=0;
//遍历所有数据，判断是否满足条件
for(int i=0;i<array.length;i++){
    if(array[i]%2==0){
        count++；//只要满足条件，count++
    }
}
//最终count记录的就是，满足条件的个数
System.out.println("个数为:"+count);

4. 键盘录入问题

只要你想键盘录入，一定是下面两个步骤

创建Scanner对象
调用nextInt()或者next()方法

//第一步：创建Scanner对象
Scanner sc=new Scanner(System.in);
//第二步：调用nextInt()键盘录入整数
int num=sc.nextInt();

5. 随机数问题

只要你想得到随机数，一定是下面两个步骤

创建Random对象
调用nextInt(int n)方法

//第一步：创建Random对象
Random sc=new Random();
//第二步：调用nextInt(int n)键盘录入整数
int num=sc.nextInt(10);//键盘录入一个0~10不包括10的整数

6. 水仙花数问题

打印所有的“水仙花数“，所谓“水仙花数“是指一个三位数，每一个数字的立方和等于该数本身。
如153就是一个“水仙花数“，153=1*1*1+5*5*5+3*3*3等于。

/*
    分析思路：
    a: 循环遍历100-999中的每一个数
    b：对每一个数进行判断是否满足水仙花数的条件
       每一个3位数分别计算出个位、百位、十位
*/
public class Test{
    public static void main(String[] args){
        //循环获取100-999中的每一个3位数
        for(int i=100;i<=999;i++){
            int ge=i%10;//个位
            int shi=i/10%10;//十位
            int bai=i/100%10;//百位
            //判断这个数i,是否满足水仙花数的条件
            if(ge*ge*ge+shi*shi*shi+bai*bai*bai==i){
                System.out.println(i);//打印这个数
            }
        }
    }
}

7. 不死神兔问题

古典问题：有一对小兔子，从第3个月起每个月都会生一对兔子，小兔子长到第三个月每个月又会生一对兔子，假设兔子都不死，问第10个月兔子对数是多少？
其实这是一个数学家斐波那契提出的一个假设，叫做斐波那契数列，如下
1 1 2 3 5 8 13 21 34…

/*
我们发现这个数列是有规律的：
第一个数是1，第二个数也是1，从第3个数开始每一个数等于前两个数之和。
这就转换成了一个数学问题，求数列中第n个数是多少？
我们用一个数组保存每一个数，数组的长度为n,按照规律王数组中填充元素即可。
int[] arr=new int[n];
arr[0]=1;//第一个数
arr[1]=1;//第二个数
arr[n]=arr[n-1]+arr[n-2];//第n个数
*/
public class Test{
    public static void main(String[] args){
        //获取第10个数是多少
        int count=getNum(10);
        System.out.println(num);
    }

    //求斐波那契数列的第n个数是多少
    public static int getNum(int n){
        int[] arr=new int[n];
        arr[0]=1;//第一个数为1
        arr[1]=1;//第二个数为1
        //从第三个数开始每一个数等于阿前两个数之和
        for(int i=2;i<arr.length;i++){
            arr[i]=arr[i-1]+arr[i-2];
        }
        return arr[n-1];//返回最后一个元素
    }

}

8. 质素问题

打印输出1-100之间的质素

/*
分析：
质素是只能被1和本身整除的数
a: 遍历1-100之间的所有数据
b：判断这个数是否可以被1和它本身之外的数整数
    如果可以就不是质数，否则就是质数
*/
public class Test8{
    public static void main(String[] args){
        //遍历1-100之间所有的数
        for(int i=1;i<=100;i++){
            //调用isPrime(i)判断数据i是否为质数
            if(isPrime(i)){
                System.out.print(i+" ");
            }
        }
    }

    public static boolean isPrime(int num){
        boolean flag=true;//设质素为true
        //如果num能够被2~num之间的的任何一个数整除就不是质数
        for(int j=2;j<num;j++){
            if(num%j==0){
                flag=false;//false不是质数
                break;
            }
        }
        return flag;
    }
}

9. 数据交换

public class Test9{
    public static void main(String[] args){
        int[] arr={1,2,3,4,5,6};
        swap(arr,0,2);//0索引和2索引的元素交换位置
        printArray(arr);交换后{3,2,1,4,5,6}
    }
    //对数组中i索引和j索引的元素交换位置
    public static swap(int[] arr,int i,int j){
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
    //打印输出数组中的元素
    public static void printArray(int[] arr){
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }
}

10. 数组元素逆序

public class Test9{
    public static void main(String[] args){
        int[] arr={1,2,3,4,5,6};
        reverse(arr);
        printArray(arr);
    }
    //数组元素逆序
    public static reverse(int[] arr){
        for(int start=0,end=arr.length-1;start<=end;start++,end--){
            //start索引和end索引位置元素互换
            swap(arr,start,end);
        }
    }

    //对数组中i索引和j索引的元素交换位置
    public static swap(int[] arr,int i,int j){
        int temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }
    //打印输出数组中的元素
    public static void printArray(int[] arr){
        for(int i=0;i<arr.length;i++){
            System.out.print(arr[i]+" ");
        }
    }
}

11. 排序算法

11.1 选择排序

//选择排序
public static void sort(int[] arr){
    //获取数组中的每一个元素
    for(int i=0;i<arr.length-1;i++){
        //获取i索引之后的每一个元素
        for(int j=i+1;j<arr.length;j++){
            if(arr[i]>arr[j]){
                int temp=arr[i];
                arr[i]=arr[j];
                arr[j]=temp;
            }
        }
    }
}

11.2 冒泡排序

//冒泡排序
public static void sort(int[] arr){
    for(int i=0;i<arr.length-1;i++){
        for(int j=0;j<arr.length-1-i;j++){
            if(arr[j]>arr[j+1]){
                int temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }
    }
}

12. 递归问题

12.1 求5的阶乘

public class Test12a{
    public static void main(String[] args){
        int result=jc(5);//求5的阶乘
        System.out.println(result);
    }

    //求n的阶乘
    public static int jc(int n){
        if(n==1){
            return 1;
        }else{
            return n*jc(n-1);
        }
    }
}

12.2 斐波拉契数列

public class Test12b{
    public static void main(String[] args){
        int result=getCount(5);//求第5个数的值
        System.out.println(result);
    }

    //求斐波那契数列第n个数的值
    public static int getCount(int n){
        //第一个数和第二个数都是1
        if(n==1||n==2){
            return 1;
        }else{
            //从第3个数开始其他数等于前两个数之和
            return getCount(n-1)+getCount(n-2);
        }
    }
}

12. 打印乘法口诀表

public static void print(){
    //1-9表示9行
    for(int i=1;i<=9;i++){
        //每行的列数跟随行数变化
        for(int j=1;j<=i;j++){
            System.out.print(j+"*"+i+"="+(j*i)+"\t");
        }
        System.out.println();
    }
}

结果如下
乘法口诀表