0基础学java day05（加法运算器，数组，九九乘法表和算法题）

Gu—谷

已于 2023-02-24 22:48:55 修改

阅读量142

点赞数

分类专栏：零基础学习java（持续更新中）文章标签： java jvm 开发语言

于 2023-02-23 22:19:58 首次发布

本文链接：https://blog.csdn.net/qq_44242891/article/details/129190942

版权

零基础学习java（持续更新中）专栏收录该内容

18 篇文章 0 订阅

订阅专栏

该文展示了如何使用IDEA进行加法运算器的编程，包括随机生成加法题目并检查用户答案。此外，还详细讲解了数组的定义、初始化、访问、遍历和排序，以及For循环的应用，如九九乘法表的实现。文中还包括了算法题的示例，如找数组的最大值和最小值，以及计算偶数和等。

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

关于idea的永久使用，我修改了无数次就是不通过审核后，如果想要最新永久使用的可以私聊我获取

//1)加法运算器

package day05;
//随机加法运算器
import java.util.Scanner;
public class Addition {
    public static void main(String[] args) {
        Scanner scan=new Scanner(System.in);
        int score=0;
            for (int i = 1; i <= 10; i++) {
                //1)出题 //2)答题 //3)判断
                int num1 = (int) (Math.random() * 100);//num1(从0-99)
                int num2 = (int) (Math.random() * 100);//num2(从0-99)
                int result = num1 + num2;//存储一下正确的答案
                System.out.println("(" + i + ")" + num1 + "+" + num2 + "=?");
                System.out.println("答吧:");
                int answer = scan.nextInt();
                if (result == answer) {
                    System.out.println("恭喜您答对了");
                    score += 10;
                } else {
                    System.out.println("很遗憾,答错了");
                }
            }
        System.out.println("您的总分为"+score);
    }
}

//2)数组的演示

package day05;
//数组的演示
/*默认值:
        byte,short,int,long,char------------------0
        float,double------------------------------0.0
        boolean-----------------------------------false*/
import java.util.Arrays;
public class ArraryDemo {
    public static void main(String[] args) {
         //1)数组的定义:
         //声明整型数组a,包含5个数组,每个元素都是int类型默认值为·0
         int [] a=new int[5];

         //2)数组的初始化:---初始化数组中的元素
        int[] arr1=new int[3];//0,0,0
        int[] arr2={1,2,3};//1,2,3
        int[] arr3=new int[]{1,2,3};//1,2,3
        int[] arr4;
        //arr4={1,2,3};编译错误,此方式只能声明同时初始化
        arr4=new int[]{1,2,3};//正确

        //3)数组的访问:---访问的是数组中的元素
        int[] arr=new int[3];
        System.out.println(arr.length);//数组的长度3
        System.out.println(arr[1]);//输出第一个元素的值
        arr[1]=10;//把第一个元素的值改为10
        System.out.println(arr[1]);//输出数组第一个元素的值
        System.out.println(arr[arr.length-1]);//输出数组最后一个元素的值
        //System.out.println(arr[3]);//数组越界
        //ArrayIndexOutOfBoundsException，数组越界，报错
        // 数组下标一定在0到(数组长度-1)之间,否则运行时会发生错误

        //4)数组的遍历(迭代):从头到尾输出一遍

        int[] arry=new int[100];
        int sum=0;
        for (int i=0;i<arry.length;i++){
            //arry[i]=100;//把数组中的每个元素都赋值为100
            arry[i]=(int)(Math.random()*1000);//随机给数组赋值
            System.out.println(arry[i]);
            sum++;
        }
        System.out.println("共输出了"+sum+"次");

        //5)数组的排序
        int[] arr=new int[10];
        for(int i=0;i<arr.length;i++){
            arr[i]=(int)(Math.random()*100);
            System.out.println(arr[i]);
        }
        Arrays.sort(arr);//对数组进行升序排序
        System.out.println("排序后...");
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }

        System.out.println("倒着排序排序后...");//降序
        for(int i=arr.length-1;i>=0;i--){//数据还是升序的，只是被倒着显示而已
            System.out.println(arr[i]);
        }

    }
}

//3)For循环的演示（1-100相加详细过程）

package day05;
//for循环演示
public class ForDemo {
    public static void main(String[] args) {
      /*  //计算1到100相加之和(累加)
        int sum=0;
        int i;
        for( i=1;i<=100;i++){
            sum+=i;
        }
        System.out.println("1+2+3+...+99+100="+sum);*/

        /*计算1到100相加之和(累加)执行过程
第一次  sum=0        i=1     i<=100      sum=1            i++=2
第二次  sum=1        i=2     i<=100      sum=1+2          i++=3
第三次  sum=3        i=3     i<=100      sum=1+2+3        i++=4
第四次  sum=6        i=4     i<=100      sum=1+2+3+4      i++=5
................................................
第99次  sum=4851    i=99     i<=100     sum=1+2+...+99    i++=100
第100次 sum=4950    i=100    i<=100     sum=1+2+...+100   i++=101
第101次 sum=5050    i=101    false
 */


       /* for(;;){//没有条件的循环就是一个死循环
            System.out.println("1");
        }*/


        //break一般配合if使用 break只能跳出当前的一层循环
        
       /* for(int i=1;i<10;i++){
            if(i==4){//在某种特定情况下,提前结束循环
                break;//跳出循环
            }
            System.out.println(i+"*9"+"="+i*9);
        }*/

        //continue
        //输出9的乘法表,跳过能被3整除的
        for(int i=1;i<=9;i++){
            if(i%3==0){
                continue;//跳出循环中剩下的语句进入下一次循环
            }
            System.out.println(i+"*9"+"="+i*9);
        }
        //输出乘法表,只要不能被3整除的
        for (int num=1;num<=9;num++){
            if(num%3!=0){
                System.out.println(num+"*9="+num*9);
            }
        }


    }
}

//4)找数组的最大值最小值算法

package day05;

public class MaxOfArray {
    public static void main(String[] args) {
        //数组的创建、赋值、和输出的三种方式
        /*//1)
        int a[]=new int[10];
        a[1]=3;
        a[5]=8;
        for (int i=0;i<a.length;i++){
            System.out.println(a[i]);//0,3,0,0,0,8,0,0,0,0
        }
        //2)
        int a1[]={1,2,3};
        for (int i=0;i<a1.length;i++){
            System.out.println(a1[i]);//1,2,3
       }
        //3)
        int a2[];
        a2=new int[]{1,2,4};
         for (int i=0;i<a2.length;i++){
             System.out.println(a2[i]);//1,2,4
       }
       */
       //创建一个长度为100的数组,然后随机赋值,输出
       /* int arry1[]=new int[100];
        int a=0;
        for(int i=0;i<arry1.length;i++){
            arry1[i]=(int)(Math.random()*1000);
            System.out.println(arry1[i]);
            a++;
        }
            System.out.println("输出了"+a+"次");*/

        //最大值
        /*int arry2[]={3,6,9,3,1};
        int max=arry2[0];
        for (int i=0;i<arry2.length;i++){
            if(arry2[i]>max){
                max=arry2[i];
            }
        }
        System.out.println("最大值为"+max);*/


    }
}

//5）九九乘法表（详细的执行过程）

package day05;
 /*嵌套循环：
         - 循环中套循环，常常多行多列时使用，外层控制行，内层控制列
         - 执行规则：外层循环走一次，内层循环走所有次
         - 建议：嵌套层数越少越好，能用一层就不用两层，能用两层就不用三层
         - break默认只能跳出当前一层循环*/

//九九乘法表
public class MultiTable {
    public static void main(String[] args) {
        for(int i=1;i<=9;i++){
            for(int j=1;j<=i;j++){
            System.out.print(j+"*"+i+"="+i*j+"\t");
            }
            System.out.println("");
        }
        //九九乘法表执行过程
       /*
      第一次:  i=1  1<9  j=1  1<=1  输出1*1=2  j++=2  2!<1  fale i++=2
      第二次:  i=2  2<9  j=1  1<=2  输出1*2=2  J++=2  2<=2  输出2*2=4  j++=3 3!<2 false  i++=3
      .........
        */

    }
}

算法题

 1.Addition随机加法运算器
 要求：由系统随机出10道加法题，而后由用户来答题，答题后输出"答对了"或"答错了"，
 答对1题得10分，答错1题不扣分，最后输出总分数。

package day05;
/*1. Addition随机加法运算器
        要求：由系统随机出10道加法题，而后由用户来答题，答题后输出"答对了"或"答错了"，
        答对1题得10分，答错1题不扣分，最后输出总分数。*/
import java.util.Scanner;
public class Test1 {
    public static void main(String[] args) {
        int score=0;
        for(int i=1;i<=10;i++) {
            int num1 = (int) (Math.random() * 100);
            int num2 = (int) (Math.random() * 100);
            Scanner scan = new Scanner(System.in);
            System.out.println("("+i+")"+num1+"+"+num2+"=?");
            int result = num1 + num2;
            System.out.println("算吧");
            int input = scan.nextInt();
            if(result!=input){
                System.out.println("很遗憾答错了,正确答案为"+result);
            }else {
                System.out.println("恭喜您答对了");
                score+=10;
            }
        }
        System.out.println("您的最终分数为"+score);
    }
}

2. MultiTable九九乘法表
    要求：输出九九乘法表

package day05;
/*2. MultiTable九九乘法表
        要求：输出九九乘法表*/
public class Test2 {
    public static void main(String[] args) {
        int num=9;
        for (int i=1;i<=num;i++){
            for (int j=1;j<=i;j++){
                System.out.print(j+"*"+i+"="+i*j+"\t");
            }
            System.out.println();
        }
    }
}

/*3. 数组小代码练习：声明、初始化、访问、遍历*/

package day05;
/*3. 数组小代码练习：声明、初始化、访问、遍历*/
public class Test3 {
    public static void main(String[] args) {
        //数组的三种定义方式
        //1)
        int arr[]=new int[5];
        arr[0]=1; arr[1]=2; arr[2]=3; arr[3]=4; arr[4]=5;
        System.out.println(arr[2]);
        for (int i=0;i<arr.length;i++){
            System.out.print(arr[i]+"\t");
        }
        System.out.println( );
        System.out.println("---------");
        //2)
        int arr2[]={2,3,4,5,6};
        for (int i=0;i<arr2.length;i++){
            System.out.print(arr2[i]+"\t");
        }
        System.out.println();
        System.out.println("---------");
        //3)
        int arr3[];
        arr3=new int[5];
        arr3[0]=5; arr3[1]=6; arr3[2]=7;  arr3[3]=8;  arr3[4]=9;
        for (int i=0;i<arr3.length;i++){
            System.out.print(arr3[i]+"\t");
        }


    }
}

强化算法题

1. 利用for循环计算：求数字1到100之内，所有偶数的和，并输出

package day05;
/*1. 利用for循环计算：求数字1到100之内，所有偶数的和，并输出*/
public class Ttest1 {
    public static void main(String[] args) {
        int sum=0;
        for(int i=0;i<=100;i+=2 ){
              sum+=i;
        }
        System.out.println("1-100之间所有偶数的和为"+sum);
    }
}

2.输出8的阶乘

package day05;
//2.输出8的阶乘
public class Ttest2 {
    public static void main(String[] args) {
        int sum=1;
        for(int i=1;i<=8;i++){
            sum*=i;
        }
        System.out.println("8!="+sum);

    }
}

3. 利用for循环计算：打印字符*组成的直角三角形，输出结果如下所示：
        *
        ***
        *****
        *******
        *********
        ***********

package day05;
/*3. 利用for循环计算：打印字符*组成的直角三角形，输出结果如下所示：
        *
        ***
        *****
        *******
        *********
        ***********
        ```*/
public class Ttest3 {
    public static void main(String[] args) {
        for(int i=1;i<=6;i++){
            for(int k=1;k<=2*i-1;k++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

4.随机生成一个数组，并且输出最大值和最小值

package day05;
//4.随机生成一个数组，并且输出最大值和最小值
public class Ttest4 {
    public static void main(String[] args) {
        int[] arr = new int[10];
        for(int i=0;i<arr.length;i++){
            arr[i] = (int)(Math.random()*100);
            System.out.println(arr[i]);
        }
        int max = arr[0];
        int min = arr[0];
        for(int i=1;i<arr.length;i++){ //遍历剩余元素
            if(arr[i]>max){   //若剩余元素大于max
                max = arr[i]; //将max修改为较大的
            }
            if(arr[i]<min){
                min = arr[i];
            }
        }
        System.out.println("最大值为:"+max+"，最小值为:"+min);

    }
}

笔记：

1. for的练习：
2. break：跳出循环
continue：跳过循环体中剩余语句而进入下一次循环
3. 嵌套循环：
循环中套循环，常常多行多列时使用，外层控制行，内层控制列
执行规则：外层循环走一次，内层循环走所有次
建议：嵌套层数越少越好，能用一层就不用两层，能用两层就不用三层
break默认只能跳出当前一层循环
4. 数组(上)：
是一种引用数据类型
相同数据类型元素的集合
定义：
初始化：初始化数组中的元素
访问：
通过(数组名.length)可以获取数组的长度(元素个数)
通过下标/索引来访问元素，下标从0开始，最大到(数组的长度-1)
遍历/迭代：从头到尾挨个走一遍
排序