Java语句与数组

一、Scanner（键盘录入）

1.概述：是java定义好的类

2.作用：将数据通过键盘录入的形式放到代码中参与运行

3.位置：java.util

4.使用：第一步：导包找到使用的类  import  java.util.Scanner

              第二步：创建对象      Scanner  变量名=new  Scanner（System.in）；

             第三步：调用方法，实现键盘录入        变量名.nextInt   输入整数int型的

注意：

变量名.next（）:录入字符串->遇到空格和回车就结束录入了

变量名.nextLine（）:录入字符串->遇到回车就结束录入了

两者不能同时使用

import java.util.Scanner;

public class Demo02Scanner {

    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        //String data1 = sc.next();
        String data1 = sc.nextLine();

        System.out.println(data1);


    }
}

二、Random（随机数）

1.概述：java自带的一个数

2.作用：可以在指定的范围内随机一个整数

3.位置：java.util

4.使用：第一步：导包：import   java.util.Random

              第二步：创建对象      Random  变量名=new  Random（）

              第三步：调用方法，生成随机数    变量名.nextInt（）  在int的取值范围内随机一个整数

在指定范围内随机一个数

nextInt（int bound）->在0-（bound-1）

例如：nextInt（10）->0-9

          在1-10之间随机一个数：nextInt（10）+1->（0-9）+1->1-10

         在100-999之间随机一个数：nextInt（900）+100->（0-899）+100->100-999

import java.util.Random;

public class Demo01Random {

    public static void main(String[] args) {
        Random rd=new Random();

        //输出0-45
//        int data=rd.nextInt(46);

        //输出1-10
        int data=rd.nextInt(10)+1;

        //输出100-999
        int data1=rd.nextInt(900)+100;

        System.out.println(data);
        System.out.println(data1);
    }
}

三、流程控制语句（重点）

1.switch(选择语句)

格式：

switch（变量）{

                  case  常量值1：

                            执行语句1；

                           break；

                  case  常量值2：

                            执行语句2；

                           break；

                  case  常量值3：

                            执行语句3；

                           break；

                 ........

                 default：

                            执行语句n：

                           break；

}

执行流程：用变量接收的值和下面的case后面的常量值匹配，匹配上哪个case就执行哪个case对应的执行语句，如果以上所有case都没有匹配上，就走default对应的执行语句n，break关键字，代表的是结束switch语句。

注意：1.Case的穿透性，如果没有break，就会出现case的穿透性，直到遇见break或者switch代码执行完毕了，就停止了。

2.switch能匹配什么类型的数据：

Byte  short int  char  枚举类型  String类型

import java.util.Scanner;

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

        switch (data){
             case 1:
                System.out.println("鹅鹅鹅");
                break;
            case 2:
                System.out.println("曲项向天歌");
                break;
            case 3:
                System.out.println("白毛浮绿水");
                break;
            case 4:
                System.out.println("红掌拨清波");
                break;
            default:
                System.out.println("下面没有了");
                break;
        }
    }
}

2.If语句

格式：if（boolean表达式）{

                     执行语句；

}

执行流程：先走if后面的boolean表达式，如果是true，就走if后面大括号中的语句，否则就不走

注意：if后面的boolean表达式，只要是结果为boolean型的，都可以放在小括号中，哪怕直接写一个true或者false

import java.util.Scanner;

public class Demo01If {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int data1=sc.nextInt();
        int data2=sc.nextInt();
       if(data1==data2){
           System.out.println("两个值相等");
       }
    }
}

3.If...elase

格式：if（boolean表达式）{

           执行语句1；

}else{

执行语句2；

}

执行流程：先走if后面的boolean表达式，如果是true，就走if后面的执行语句1否则就走elase后面的执行语句2

import java.util.Scanner;

public class Demo03IFElse {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int data=sc.nextInt();
        if (data%2==0){
            System.out.println("偶数");
        }else {
            System.out.println("奇数");
        }
    }
}

3.If.....else if.....else

格式：if（boolean表达式）{

           执行语句1；

}else if（boolean表达式）{

          执行语句2；

}else if（boolean表达式）{

            执行语句3；

}......else{

            执行语句n

}

执行流程：从if开始往下挨个判断，哪个if判断结果为true，就走哪个if对应的执行语句，如果以上所有的判断都是false，就走else对应的执行语句n

使用场景：两种情况以上的判断

注意：if和switch的区别

switch：会直接跳到相匹配的地方

if：从上到下挨个判断，实际开发只要用if做判断，灵活

4.for循环

格式：for（初始化变量；比较；步进表达式）{

               循环语句->那段代码循环执行，就将那段代码放到此处

}

快捷键（idea）：次数.fori

执行流程：先走初始化变量，比较，如果是true，走循环语句，走步进表达式（初始化的变量的值进行变化），在比较，如果还是true，继续走循环语句，走步进表达式，在比较，直到比较为false，循环结束了

public class Demo01For {
    public static void main(String[] args) {
         for (int i=0;i<3;i++){
             System.out.println("我爱java");
         }
    }
}

5.while循环

格式：初始化变量；

     while（比较）{

                 循环语句；

                 步进表达式；

}

执行流程：初始化变量，比较，如果是true，就走循环语句，走步进表达式，在比较，如果还是true，继续走循环语句，继续走步进表达式，在比较，直到比较为false，循环结束

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

        /*int i=0;
        while (i<5){
            System.out.println("我爱Java，但更爱钱");
            i++;

        }*/
        
        int sum=0;
        int  i=1;
        while (i<=3){
             sum+=i;
             i++;
        }
        System.out.println(sum);
    }
}

6.do...while循环（了解）

格式：初始化变量；

      do{

             循环语句；

             步进表达式；

}while（比较）；

执行流程：初始化变量，走循环语句，走步进表达式，判断，如果是true，继续循环，直到比较为false，循环结束

特点：至少循环一次

注意：

break：

• 在switch中代表结束switch语句 
• 再循环中代表结束循环

continue：

  结束当前本次循环，直接进入下一次循环，直到条件为false为止

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

        for (int i = 1; i <=5; i++) {
            if (i==3){
                //结束循环
                //break;
                //结束本次循环，进入下一次循环
                continue;
            }
            System.out.println("我爱java"+i);
        }
    }
}

7.死循环

概述：一直循环

什么条件下一直循环：比较条件一直是true

public class Demo01Endless {
    public static void main(String[] args) {
        int count=0;
        for (int i = 0; i < 10; ) {
            count++;
            System.out.println("我爱Java"+count);
        }
    }
}

8.嵌套循环

概述：循环中还有循环、

执行流程：先执行外层循环，在进入内层循环，内层循环就一直循环，直到内层循环结束，外层循环进入下一次循环，直到外层循环都结束了，整体结束

public class Demo03Nest {
    public static void main(String[] args) {
        //外层循环控制行
        for (int i = 0; i < 5; i++) {
            //内层循环控制列
            for (int j = 0; j < 5; j++) {
                System.out.print("* ");
            }
            System.out.println();
        }

    }
}

四、数组

1.数组

概念：是一个容器，本身属于引用数据类型

作用：存取多个数据

特点：既可以存储基本数据类型的数据，还可以存储引用类型的数据。

 定长（定义数组时长度为多长，最多能存取多少个数据）

定义：

动态初始化：在定义数组时，没有具体的数据，只指定了长度

  数据类型[] 数组名 =new 数据类型[长度]

  数据类型  数组名[]=new 数据类型[长度]

静态初始化：在定义数组的时候，我们直接给了数据

  数据类型[] 数组名 ={元素1，元素2. ........}

注意：动态初始化和静态初始化的区别：

  动态初始化：定义时候只指定了长度，没有存具体的数据，只知道长度不知道数据时，使用动态初始化

静态初始化：定义的时候就知道存什么数据

public class Demo01Array {
    public static void main(String[] args) {
        //动态初始化
        int[] arr1=new int[3];

        String[] arr2=new String[3];

        //静态初始化->简化
        int[] arr3 ={1,3,4,5,6,7,8,9};

        String[] arr4={"猫","米奇"};

    }
}

2.获取数组长度

格式：数组名.length

注意：length后面不要带小括号，因为length不是数组中的方法，而是数组中的一个属性

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

        String[] arr1={"迪迦奥特曼","猫和老鼠","海绵宝宝"};

        int len=arr1.length;

        System.out.println(len);
    }
}

3.索引

格式：数组名[索引值]=值  ->将等号右边的数据放到数组指定的索引位置上

public class Demo03Array {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr=new int[3];
        arr[0]=100;
        arr[1]=200;
        arr[2]=300;

    }
}

4.获取元素

格式：数组名[索引值]

注意：

直接输出数组名，会输出数组在内存中的地址值

地址值：数组在内存中的一个身份证号，唯一标识，我们可以通过这个唯一标识到内存中找到这个数据，从而操作这个数组中的数据

public class Demo01Array {
    public static void main(String[] args) {
        int[] arr=new int[3];

        System.out.println(arr);//地址值
        System.out.println(arr[1]);//0
        arr[1]=100;
        System.out.println(arr[1]);//100
        
    }
}

如果arr[索引值]在等号右边，证明是获取值，如果在等号左边，证明是存值

5.数组内存图

内存可以理解为“内存条”,程序运行起来都会进入到内存中，占用内存，在java在世界中，将内存划分为5块。

• 栈（重点）（Stack）：主要运行方法，方法的运行都会进栈内存运行，运行完毕，需要“弹栈”，为了腾空间
• 堆（重点）（Heap）：保存的是对象，数组，每new一次，都会在堆内存中开辟空间，并为这个空间分配一个地址值，堆内存中的数据都是有默认值的
• 方法区（重点）（Method Area）：代码的“预备区”，记录了类的信息以及方法的信息，方法区中主要保存class文件以及其中的信息，代码运行之前，需要先进内存（方法区）
• 本地方法（了解）（Native Method Stack）：专门运行native方法（本地方法）可以理解为堆对java功能的扩充，有很多功能java语言实现不了，所以就需要依靠本地方法完成（c语言编写）
• 寄存器（了解）（pc register）：和CPU有关

我们创建了两个数组，在堆内存中开辟了两个不同的空间，此时修改一个空间中的数据不会影响刀另外一个空间的数据。

6.二维数组

概述：数组中套了多个数组

动态初始化：在定义数组时，没有具体的数据，只指定了长度

  数据类型[][] 数组名 =new 数据类型[m][n]

  数据类型  数组名[][]=new 数据类型[m][n]

  数据类型[]  数组名[]=new 数据类型[m][n]

m:代表的是二维数组的长度

n：代表的是二维数组中每一个一维数组的长度

静态初始化：在定义数组的时候，我们直接给了数据

  数据类型[][] 数组名 ={{元素1，元素2.},{元素1，......} ........}

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

        String[][] arr1={{"孙悟空","唐僧"},{"孙悟空","唐僧","猪八戒"},{"林黛玉","贾宝玉"}};

        System.out.println(arr1.length);
        
        //获取每一个一维数组
        for (int i = 0; i < arr1.length; i++) {

            /*
            * arr1[i]代表每一个一维数组
            * */

            System.out.println(arr1[i].length);

        }

    }
}

如有不足，请各位大佬多多指教，谢谢