JAVA零基础入门笔记(七)

1，break

可以使用在swtich还有循环当中。

不管是用在哪里，都表示跳出，停止的意思。

但是，他只能跳出当前的语句。

案例1：

//如果是循环嵌套。在内循环中写break，那么只能跳出内循环。

for (int i = 0; i < 10; i++) {
    for (int j = 0; j < 10; j++) {
        if(j == 0){
            break;
        }
    }
    System.out.println("内循环执行完毕");
}
System.out.println("外循环执行完毕");

案例2：

//如果是循环里面有swtich，在swtich里面写break，那么只能跳出swtich。

for (int i = 0; i < 10; i++) {
    int number = 10;
    switch (number){
        case 10:
            System.out.println("AAA");
            break;
        case 20:
            System.out.println("BBB");
            break;
        default:
            System.out.println("BBB");
            break;
    }
    System.out.println("switch执行完毕了");
}
System.out.println("外循环结束了");

2，continue

只能用在循环当中。

表示结束本次循环，继续下次循环。

如果是循环嵌套，在内循环中写continue，那么只能结束内循环中的本次循环，继续执行循环的下次循环。

  for (int i = 0; i < 10; i++) {
        for (int j = 0; j < 10; j++) {
            if(j == 0){
                continue;//执行到这行代码时，结束本次循环，跳到j++，继续内循环的下次循环。
            }
            System.out.println("AAA");
        }
        System.out.println("BBB");
    }

3，如何快速不出错的拼接字符串

技巧： 完全掌握的。

• 先把最终的结果写出来。
• 把其中有可能发生变化的值用变量替代
• 把变量挪到外面去

案例：

1 * 1 = 1  其中第一个1是变量i的值，第二个1是变量j的值，第三个1，是i*j的积
i+" * "+j+" = "+(i*j)+"\t"

4，Random

其实是Java已经写好的一个类。所以Java在定义这个类的时候也遵守了见名知意，驼峰命名。

所以首字母是大写的。

使用步骤：

1，导包 — 告诉虚拟机这个类在哪

		用idea不需要手动写，帮我们自动生成。

2，创建对象 — 打个招呼，我要用这个类了。

3，获取随机数 — 真正获取随机数代码。

注意点：

nextInt(范围);

一定是从0开始的。

到指定的范围结束，但是包头不包尾，包左不包右。

举例:

nextInt(100);//实际上就是从0~99之间获取的一个随机数。

技巧：

用在任意数到任意数之间获取一个随机数。

1，头尾都减去一个值，让这个范围从0开始。

2，尾巴+1。并这个+1的结果写在小括号中。

3，最终再加上第一步减去的值。

5，数组的介绍

数组就是一个容器，可以存储同种数据类型的多个值。

举例：

如果要存1,2,3,4,5.那么我们就可以用int类型的数组去存储。

如果要存"zhangsan" “lisi” … 那么我们就可以用String类型的数组去存储。

6，数组的定义方式

方式一：

数据类型 []  数组名

举例：

int  [] arr

方式二：

数据类型 数组名 []

int arr []

建议：以后使用方式一。

格式组成：

int ：表示这个数组以后只能存int类型的数据

[] :表示现在定义的是一个数组

arr:表示数组的名字。

7，数组的动态初始化

格式：

数据类型 [] 变量名/数组名 = new 数据类型[数组的长度];

举例：

int [] arr = new int[3];

注意点：

数组一旦创建出来了，那么长度是**不能发生变化的**。

现在我创建了一个长度为3的数组，就表示这个数组中，只能存3个数据。

如果现在我有5个数据想要存储。只能重新定义一个长度为5的数组。

格式解析：

等号左边

int ： 表示了数组以后能存储的数据类型。

[] : 表示这个是一个数组

arr: 是一个变量名，也是数组的名字

等号右边

new： Java中的一个关键字，在内存中开辟一个空间。

int ： 表示了数组以后能存储的数据类型。

[] : 表示这个是一个数组

3 ： 表示数组的长度。

8，索引

概念：

索引，可以把他理解为编号。

我们可以通过索引来获取数组中的元素。

特点：

• 一定是从0开始的
• 索引是依次递增的
• 一定是每次+1

0 1 2 3 4 5 6 7 8 9 …

针对于任意一个数组：

最大索引：长度-1

最小索引：0

作用：

可以获取数组中的元素（数据）。

可以对数组中的元素进行手动赋值。

格式：

获取数组中元素的格式：数组名[索引]

获取出来之后，值需要被使用，可以赋值给一个变量，也可以直接输出。

 //创建一个长度为3的数组
    int [] arr = new int[3];
    //获取0索引的元素
    int number = arr[0];
    System.out.println(number);
    
    //获取1索引的元素
    System.out.println(arr[1]);
    
    //获取2索引的元素
    //alt + shift + 上下键 --- 可以上下移动代码
    System.out.println(arr[2]);

9，数组的默认初始化值

概念：

**如果你没有给数组赋值，那么数组里面也是有默认值的。**

整数类型的数组：默认值0

小数类型的数组：默认值0.0

字符类型的数组：默认值空字符

布尔类型的数组：默认值false

引用数据类型的数组：默认值null

10，堆内存中的地址值

11，一个数组的内存图

结论：

int [] arr = new int[3];

以等号为中间界，左边在栈，右边在堆。

arr记录的就是堆里面那个小空间的地址值。

12，两个数组的内存图

结论：

只要看到了new，那么一定是在堆当中，开辟了一个新的小空间。

13，两个数组指向同一个小空间

结论：

如果两个数组指向了同一个小空间。

如果其中一个对小空间里面的值发生了修改，那么所有数组再次访问的时候，就是修改之后的结果了。

14，数组静态初始化

  // 数组的静态初始化
            // 完整格式：数据类型 [] 变量名/数组名 = new 数据类型[]{元素1,元素2,.....};
            // 简写格式：数据类型 [] 变量名/数组名 = {元素1,元素2,.....};
    
            int [] arr1 = new int[]{1,2,3,4,5};
            int [] arr2 = {1,2,3,4,5,6};
    
            System.out.println(arr1[0]);
            System.out.println(arr1[1]);
            System.out.println(arr1[2]);
            System.out.println(arr1[3]);
            System.out.println(arr1[4]);
    
            //修改0索引的值
            arr1[0] = 100;
            //再次输出
            System.out.println(arr1[0]);
            System.out.println(arr1[1]);
            System.out.println(arr1[2]);
            System.out.println(arr1[3]);
            System.out.println(arr1[4]);
    
            //针对于简写格式下，获取，赋值跟上面也是一模一样的。

15，两种定义格式的使用技巧

• 如果知道要存几个，但是不知道要存什么？
  int [] arr = new int[个数];
• 如果知道要存的所有元素？
  int [] arr = {1,2,3,4,5};

案例1：

  //键盘录入5个学生成绩，存入到数组当中
    
    //1，不知道要存什么，但是知道要存几个。
    int [] scoreArr = new int[5];
    
    //2,要做的就是键盘录入，并存入到数组当中。
    Scanner sc = new Scanner(System.in);
    
    for (int i = 0; i < scoreArr.length ; i++) {
        System.out.println("请录入一个分数");
        int score = sc.nextInt();//ctrl + alt + v
        scoreArr[i] = score;
    }
    
    //获取数组中所有的元素
    for (int i = 0; i < scoreArr.length; i++) {
       System.out.println(scoreArr[i]);
    }

案例2：

   //定义一个数组，装3个成绩，成绩分别为：99 99 100
    
    //因为已经知道了所有的元素
    int [] scoreArr = {99,99,100};
    
    
    //获取数组中所有的元素
    System.out.println(scoreArr[0]);
    System.out.println(scoreArr[1]);
    System.out.println(scoreArr[2]);

16，数组操作的两个小问题

数组索引越界异常

访问了不存在的索引
  int [] arr = new int[3];
  System.out.println(arr[10]);//此时出现索引越界异常

比如避免：

咱们要明确的知道某一个数组的索引范围。

最小索引：0

最大索引：数组的长度 - 1

空指针异常

栈里面的arr，记录的地址值被清空了。再次使用arr获取堆里面小空间元素的时候，就会报空指针异常。

比如避免：

尽量不要清空arr记录的地址值。

17，数组的遍历

核心：

获取数组的长度  ---- 数组名点length

概念：

把数组中的元素一个一个的都获取出来的过程。

快速生成方式：

数组名点fori + 回车

案例1：

 //打印数组中所有的元素
    //最终代码
    int[] arr = {1, 2, 3, 4, 5};
    for (int i = 0; i < arr.length; i++) {
        System.out.println(arr[i]);
    }

案例2：

  int[] arr = {1, 2, 3, 4, 5};
    int sum = 0;
    for (int i = 0; i < arr.length; i++) {
        sum += arr[i];
    }
    System.out.println(sum);

18，数组的求最大值

 //定义一个数组
    int [] arr = {1,2,3,4,5,6,7,8};
    
    //定义一个变量，用于记录最大值
    //这个变量的初始值，必须是数组中的某一个元素。
    int max = arr[0];
    
    //因为max一开始记录的是0索引上的值。
    //所以在循环的过程中，就没有必要自己跟自己再比一次。
    //所以循环从1索引开始。
    //如果一定要从0开始，代码也不错，只不过效率会低一些，多比了一次。
    for (int i = 1; i < arr.length; i++) {
        //arr[i] 依次表示数组中的每一个元素。
        if(max < arr[i]){
            max = arr[i];
        }
    }
    System.out.println(max);