分支 + 循环结构 + 数组

目录

6. 分⽀

● if

● switch

7.循环结构

● while 循环

● for循环

● 双重for循环：

● continue、break：

8.数组

● ⼆维数组（了解）

● 选择排序

●冒泡排序

---

6. 分⽀

● if

 if (布尔表达式){
         满⾜时执⾏语句
         }else {
         不满⾜时执⾏语句
         }

●if~else 语句最好不要超过三层嵌套
●if（）{  return ; }  表示结束判断，不再向下执行操作
●能 用 if（）{}并列的，不要用 if 嵌套

卫语句：
            把⾮法的操作，⽤ if 语句并列在前⾯，只要有异常操作就结束操作，然后把正常操作的逻辑写在下⾯。

//例子
if(错误操作){
    return; //结束操作
        }
if(正确操作){
    ......
        }

●switch

//不能使用布尔表达式
switch (int|byte 整数类型|char|String|计算语句){
    case :
        case 1:
        .....
        break;
        case 2:
        ....
        break;
        .....
        default:
        .....
        break;
        }

---

7.循环结构

●while 循环

while (boolean) {

    //可以反复执行

}

●for循环

//for的⽆限循环
        for(;;) {
        System.out.println("你好");
        }
 //While的⽆限循环
        while（true）{
        System.out.println("你好");
        }

●双重for循环：

外层循环控制行数，数一下有几行就能确定外层循环。

内层循环控制列数，这一行打印多少个，到底要打印多少个要找出和当前行之间的一个关系。

    //等腰正三角
    @Test
    public void test61(){
        int rows=5;
        for(int i = 1; i <= rows; i++) {
            for (int j = 1; j <= rows - i; j++) {
                System.out.print(" ");
            }
            for (int k = 1; k <= 2*i - 1; k++){
                System.out.print("*");
            }
            System.out.println("");
        }
    }

  

●continue、break：

continue：跳出本次循环，继续下一次循环

break：跳出离他最近的那层循环

注意：
① 循环结构需要多些⼏次。
② while ⽤于不确定次数但是知道结束条件的语句，⽽ for 循环⽤于明确知道确定的次数⽽不知道结束条件的循环。
③ continue、break 都需要和 if 语句结合。

---

8.数组

●数组是最简单的数据结构。

数组：存放同一种类型数据的集合，在内存里面是开辟一块连续的区域。

● 声明数组： 数组类型 数组名称[]=null;      

● 开辟数组： 数组名称= new 数组类型[⻓度]；  int[]  array = new int[4];   // 1、存放整数类型的数组 ；  2、长度是4；  3、只能存放int类型

● 数组定义的方式：

① 在定义的时候直接赋值：       int[] array = {32,5,7,87};              int[] array = new int[]{32,5,7,87};

② 先定义后赋值：      int[] array = new int[4];        array[0] = 34;

java.lang.Array Index OutOf Bounds Exception: 4                数组下标越界异常

// 范例：控制台输⼊⼀个数组：  
  Scanner scanner =new Scanner(System.in);
  System.out.println("请输⼊成绩：");
  int[] score = new int[5];
  for (int i = 0; i < score.length; i++) {
      score[i] = scanner.nextInt();
  }

●  数组最重要操作就是遍历。 

public void test10(){
        int[] array = new int[4];
        array[0] = 1;
        array[1] = 2;
        array[2] = 3;
        array[3] = 4;
        //数组正序遍历
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]);
        }
        System.out.println();
        //数组逆序遍历
        for(int i = array.length - 1; i >=0; i--){
            System.out.print(array[i]);
        }
    }

● ⼆维数组（了解）

●⼆维数组的定义
动态：数据类型 数组名称[][] = new 数据类型[⾏][列]；
静态（对应上表数据）：数据类型 数组名称[][] = new 数据类型[][]{{10,20,30,40},{11,21,31,41},{12,22,32,42},{13,23,33,43}}
                                                                                                             第⼀⾏ 

    public static void main(String[] args) {
        int data[][]=new int[][]{{10,20,30,40},{11,21,31,41},{12,22,32,42},{13,23,33,43}};
        for(int x=0;x<data.length;x++) {//第⼀层循环是为了输出⾏号
            for(int y=0; y < data[x].length;y++) {//每⼀⾏⼜是⼀个⼀维数组，第⼆⾏就是遍历⼀维数组
                System.out.print(data[x][y]+"\t");
            }
            System.out.println() ;
        }
    }
}

●数组可以和循环巧妙结合。
●语法：int[] stu=new int[];
●数组名称.lenght 可以获取数组⻓度；
●⼩标从 0 开始，下标最⼤值，是⻓度-1；
●Math.random()⽅法是⽣成⼤于等于 0 ⼩于 1 的随机数；

  int[] a=new int[20];
  int l=a.length;
  int sum=0;
  double av=0;
  for(int i=0;i<l;i++) {
        a[i]=(int) (Math.random()*50+50);//输出 50 到 100 之间的随机数； MAth.random()是输出 0 到 1 之间随机数
        sum+=a[i];
        av=sum/l;
  }
  System.out.println(sum);
  System.out.println(av);

●数组可以只定以，不创建，例⼦：int[] a,b,c=new int[];这⾥，a 和 b 没有创建，但是定义了；c 即创建了⼜定义了；
●数组在定义时候可以初始化。int[] a = new int[]{20,30,40,50}    和   int[] a = {20,30,40,50}两种，第⼀种可以传递参数，第⼆种不可传递参数。
●数组的遍历 for（int i: s）{}和直接 System 输出

●选择排序

 //选择排序
   public static void main(String[] args) {
        int[] a=new int[] {6,28,104,90,19,200};
        for(int i=0;i<=a.length-1;i++) {//i 代表轮数
            for(int j=0;j<a.length;j++) {
                if(a[j]<a[i]) {
                    int tmp=a[j];
                    a[j]=a[i];
                    a[i]=tmp;
                }
            }
        }
        for(int i=0;i<a.length;i++) {
            System.out.println(a[i]+" ");
        }
    }

 ●冒泡排序

//冒泡排序  
  // 第⼀轮：9,1,5,2 ------------------------------------ ⽐较了 3 次
  // 第⼆轮：9,5,1,2 --------------------------------------⽐较了 2 次
  // 第三轮：9,5,2,1 --------------------------------------⽐较了 1 次
  // 四个数，总共⽐较三轮：length - 1 轮
  // 每轮⽐较了 length - i 次
    public static void main(String[] args) {
        int[] array = new int [] {1,5,9,2};
        int temp = 0;
        for (int i = 1; i <= array.length -1; i++) {
  //外层循环控制总共⽐较多少轮：从第⼀轮开始：1200702Java—王浩
            28
            for (int j = 0; j < array.length - i; j++) {
  //内层循环:每⼀轮⽐较的次数：从第⼀个索引开始:0
                if (array[j] > array[j + 1]) {
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp ;
                }
            }
        }
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

总结：
● 数组⽤的很少，但是⼀定会⽤，⽽且数组的相关逻辑⽐较麻烦；
● 把数组的排序和转置要弄明⽩；
● ⼀切以⼀维数组为主，要明⽩数组定义语法和内存关系（对象⼀致）；
● 对象数组的定义语法。对象数组=多个对象；
● 数组有⼀个最⼤的天⽣短板；⻓度固定，限制数组的开发中的出现
● 数组排序：java.util.Arrays.sort（数组名称）。