Java基础（二）

选择结构与条件循环：

（一）：选择结构

if语句的使用

1：单分支

if (条件) {
   语句组 
}

说明：如果语句组只是一条语句，那么花括号是可以省略的。条件成立，就执行语句组，否则啥也不做。
2：双分支

if (条件) {
   语句组1
} else {
   语句组2
}

说明：语句组1与语句组2，根据条件成立与否，只有其中一个会被执行。
3：多分支
（1）：并列式多分支

if (条件1) {
    语句组1
}
if (条件2) {
    语句组2
}
……
if (条件n) {
    语句组n
}

（2）：嵌套式多分支

if (条件) {
    if (条件1) {
       语句组1
    } else {
       ……
    }
} else {
    if (条件2) {
       语句组2
    } else {
       ……
    }
}

（3）：延拓式多分支

if (条件1) {
    语句组1
} else if (条件2) {
    语句组2
} 
……
} else if (条件n) {
    语句组n
} else {
    语句组n+1
}

switch语句的使用

switch (测试表达式) {
    case 值1:
        语句组1
        break;
    case 值2:
        语句组2
        break;
     ……
    case 值n:
        语句组n
        break;
    default:
        语句组n+1
}

说明：（1）：开关式多分支结构里的测试表达式，类型可以是整数、字符、甚至可以是字符串。
（2）：case 语句可以不包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句或到达该switch语句末尾。
（3）：switch 语句可以包含一个 default 分支，该分支一般是 switch 语句的最后一个分支（可以在任何位置，但建议在最后一个）。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。

（二）：循环结构

1：while循环结构

初始条件
while (循环条件) {
     语句块
     break|continue;
     更新条件
}

说明：首先判断循环条件是真还是假，如果是真的，执行循环体，然后再次判断循环条件。如果是真的，继续循环，直到循环条件变成假的。有一种特殊情况：如果第一次判断循环条件就不成立，那么一次循环也不执行。

2：do...while循环结构

初始条件
do {
     语句块
     break|continue;
     更新条件
} while (循环条件);

说明：首先执行一次循环，然后判断循环条件，如果为真，继续循环，直到条件为假时结束循环。属于先上车后买票，无论如何都会执行一次循环。

3：for循环结构

for（初始化表达式; 循环条件; 操作表达式）{
    执行语句
    ...
    break | continue
    ...
}

4：循环嵌套：

以for循环嵌套为例

for(初始化表达式; 循环条件; 操作表达式) {
    ...
    for(初始化表达式; 循环条件; 操作表达式) {
        执行语句
        ...
    }
    ...
}

说明：外层循环每执行一次；内层循环便会开始执行，直到不满足内层循环条件，才执行下一次外层循环
eg：九九乘法表

package net.algchallenge;

public class MultiplicationTable {
    public static void main(String[] args) {
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j + "x" + i + "=" + (i * j) + "\t");
            }
            System.out.println();
        }
    }
}

说明：在双层嵌套循环中，外层循环变量和内层循环变量多数使用i和j表示
eg：打印实心和空心钻石
链接：https://blog.youkuaiyun.com/yeyu_xing/article/details/105794520

（三）：break关键字和continue关键字的使用

break关键字的使用

使用场景：在switch条件语句和循环结构语句中都可以使用break语句。

功能：（1）：当它出现在switch条件语句中时，作用是终止某个case并跳出switch结构；当它出现在循环结构语句中时，作用是跳出当前循环结构语句，执行后面的代码。（2）：对于双重循环，如果内循环里有break语句，那么其作用仅仅是跳出内循环。如果想跳出外循环，那么需要用到标签。

eg:下面以打印九九表的案例进行说明。

package net.algchallenge;

public class TestBreak {
    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");
                if (j >= 3) {
                    break;
                }
            }
            System.out.println();
        }
    }
}

结果：

说明：首先break语句用在内层循环，并设置了一个条件，当j >= 3时跳出当前的循环即内层循环，所以最后显示结果为每一层最多只打印了3个式子

eg：使用break关键字跳出多重循环

package net.algchallenge;

public class TestBreak2 {
    public static void main(String[] args) {
        ok:
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j + "×" + i + "=" + (i * j) + "\t");
                if (j >= 3) {
                    break ok;
                }
            }
            System.out.println();
        }
    }
}

结果：

说明：将外层循环标记为ok，并在内层循环中设置if语句，如果j >= 3时即刻跳出多重循环

continue关键字的使用

package net.algchallenge;

public class TestContinue {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                continue;
            }
            sum += i;
        }
        System.out.println("1 + 3 + 5 + ... + 99 = " + sum);
    }
}

结果：

说明：for语句中设置了if语句，如果i % 2 == 0即i为偶数，触发continue关键字，后面的代码不执行，则直接进行下一次循环，所以最后sum累加的数字便是1-100之间的奇数

使用continue关键字对多重循环实现跳转与break关键字实现跳转异曲同工，在此不做列举

数组：

（一）：一维数组

1：数组的定义：

数组类型[] 数组名 = new 数组类型[数组长度];   
数组类型[] 数组名 = new 数组类型[]{数组元素0, 数组元素1, ...};  
数组类型[] 数组名 = {数组元素0, 数组元素1, ...}; 

注：数组的下标是从0开始的

2：数组的赋值或修改数组元素已有值

数组名[下标] = 值;

注：没有赋值的数组元素会有默认值，其默认值如下：

数据类型	默认初始值
byte,short,int,long	0
float,double	0.0
char	\u0000
boolean	false
引用数据类型	null，表示变量不引用任何对象

3：特殊的Object数组

说明：一般的数组只能存储相同类型的元素，但Object类作为始祖类，能够表示除基本数据类型的所有类，但是基本数据类型又拥有其对应的封装类，所以Object数组可以间接的存储所有数据类型

eg：Object数组的使用

package net.Test;

class Cat {
}

public class ObjectArray {
    public static void main(String[] args) {
        Object[] arr = {1, 0.0, 'a', false, "Hello", new Cat()};
        for (Object i : arr) {
            System.out.println(i.getClass().toString());
        }
    }
}

结果：

4：增强型for循环

for(声明语句 : 表达式){
   //代码句子
}

eg:

package net.Test;

public class ForEach {
    public static void main(String[] args) {
        int[] values = {1, 2, 3, 4, 5};
        for (int value : values) {
            System.out.println(value);
        }
    }
}

结果：

5：判断数组中是否包含某个元素的方法

链接： https://blog.youkuaiyun.com/yeyu_xing/article/details/106422246

（二）：二维数组

1：数组的定义：

类型[][] xx = new 类型[行数][列数];

2：数组的赋值或修改数组元素已有值

数组名[下标][下标] = 值;

注：行下标和列下标都是从0开始

3：获取不规则二维数组的元素个数

eg:

package net.Test;

public class CountArrElement {
    public static void main(String[] args) {
        int[][] arr = {{1, 2}, {1, 2, 3}, {1, 2, 3, 4}, {1}};
        //第一种方法:
        int sum1 = 0;
        for (int i = 0; i <= arr.length - 1;i++){
            for(int j = 0; j <= arr[i].length - 1; j++){
                sum1++;
            }
        }
        System.out.println(sum1);

        //第二种方法:
        int sum2 = 0;
        for (int i = 0; i <= arr.length - 1;i++){
            sum2 += arr[i].length;
        }
        System.out.println(sum2);
    }
}

结果：

注：用这之中的第一个方法也可以统计二维数组中是否存在某个元素

4：判断二维数组中是否存在某个数组

package net.algchallenge;

import java.util.Arrays;

public class TDArrQuery {
    public static void main(String[] args) {
        Object[][] arr = new Object[10][];//定义10行的二维数组
        Object[] arr1 = {1, 2, 3};
        Object[] arr2 = {1, 0.0, 'a', false};
        //为arr数组赋值：
        arr[0] = arr1;
        arr[1] = arr2;
        Object[] searchedArr = {1, 0.0, 'a', false};
        boolean ifContain = false;
        for (int i = 0 ;i < arr.length;i++){
            if (Arrays.equals(arr[i],searchedArr)){
                ifContain = true;
                break;
            }
        }
        System.out.println(ifContain);
    }
}

结果：