java学习笔记-基础阶段02(韩顺平)

四.控制结构

1.流程控制介绍

• 在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的，主要有三大流程控制语句。

  1. 顺序控制

  2. 分支控制

  3. 循环控制

2.顺序控制

• 顺序控制介绍

  程序从上到下逐行的执行，中间没有任何判断和跳转

• 注意事项：

  Java中定义成员变量时采用合法的前向引用。

3.分支控制

• 分支控制if-else介绍

  让程序有选择的执行

  1. 单分支

  2. 双分支

  3. 多分枝

• 单分支

  基本语法

  if(条件表达式){
      执行代码块，可以有多条语句。
  }

• 说明

  当条件表达式为true时，就会执行{}的代码。如果为false，就不执行。

  特别说明，如果{}中只有一条语句，则可以不用{}，建议写上{}

• 流程图

  

• 双分支

  基本语法

  if(条件表达式){
      执行代码块1
  }else{
      执行代码块2
  }

• 说明：当条件表达式成立，则执行代码块1，否则执行代码块2，如果执行代码块只有一条语句，则{}可以被省略，否则不能省略。

• 流程图

  

• 多分支

  基本语法

  if(条件表达式1){
      执行代码块1
  }else if{
      执行代码块2
  }
  ......
  else{
      执行代码块n
  }

• 嵌套分支

  基本介绍

  在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支结构称为内层分支外面的分支结构称为外层分支。规范：不要超过3层。

• switch分支结构

  • 基本语法

    switch(表达式){
        case 常量1:
            语句块1;
            break;
        case 常量2:
            语句块2;
            break;
            ...
        case 常量n:
            语句块n;
            break;
        default:
            default语句块;
            break;
    }

  • 注意

    1. switch关键字，表示switch分支

    2. 表达式对应一个值

    3. case 常量1:当表达式的值等于常量1，就执行语句块1

    4. break：表示退出switch

    5. 如果和case 常量1 匹配 就执行语句块1，如果没有匹配，就继续匹配case 常量2

    6. 如果一个都没有匹配上，执行default

  • 细节讨论

    1. 表达式数据类型应该和case后的常量类型一致，或者时可以自动转成可以相互比较的类型，比如输入的是字符，而常量是int

    2. switch(表达式)中表达式的返回值必须是(byte,short,int,char,enum,String)

    3. case子句中的值必须是常量，而不能是变量

    4. default字句是可选的，当没有匹配的case时，执行default

    5. break语句用来在执行完一个case分支后使程序跳出switch语句块，如果没有写break,程序会顺序执行到switch结尾。

• switch和if的比较

  1. 如果判断的具体数值不多，而且符合byte,short,int,char,enum[枚举],String这6种类型。虽然两个语句都可以使用，建议使用 switch语句。

  2. 其他情况:对区间判断，对结构为boolean类型判断，使用if.if的使用范围更广。

4.循环控制

• for循环控制

  • 基本介绍：听其名而知其意，就是让你的代码可以循环的执行。

  • 基本语法

  • 说明

  • 1. for关键字，表示循环控制

    2. for有四要素：

       1. 循环变量初始化

       2. 循环条件

       3. 循环操作

       4. 循环变量迭代

    3. 循环操作，这里可以有多条语句，也就是我们要循环执行的代码

    4. 如果循环操作(语句)只有一条语句，可以省略{}，建议不要省略

    

  • 注意事项和细节说明

    1. 循环条件时返回一个布尔值的表达式

    2. for(循环判断条件;)中的初始化和变量迭代可以写到其他地方，但两边的分号不能省略

    3. 循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，循环变量迭代可以有多条变量迭代语句，中间用逗号隔开。

• while循环控制

  • 基本语法

    循环变量初始化;
    

    while(循环条件){
        循环体(语句);
        循环变量迭代;
    }

  • 说明

    1. while循环也有四要素

    2. 只是四要素放的位置不同

  • 流程图

    

  • 注意事项和细节说明

    1. 循环条件是返回一个布尔值的表达式

    2. while循环是先判断再执行语句

• do...while循环控制

  • 基本语法

    循环变量初始化;
    do {
        循环体;
        循环变量迭代;
    }while(循环条件);

  • 说明

    1. do while也是关键字

    2. 也有循环四要素，只是位置不一样

    3. 最后一个有分号

    

  • 注意事项和细节

    1. 循环条件是一个布尔值的表达式

    2. do...while循环是先执行后判断，因此它至少执行一次

• 多重循环控制

  • 介绍

    1. 将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for,while,do...while均可以作为外层循环和内层循环。[建议一般使用两层，最多不要超过三层，否则代码的可读性很差]

    2. 实质上，嵌套循环就是把内层循环当作外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。

    3. 设外层循环的次数为m次，内层为n次，则内层循环体实际上需要执行m * n次。

• 跳转控制语句-break

  

  Math.random()

  • 基本介绍:

    break语句用于终止某个语句块的执行，一般使用在switch或者循环[for,while,do...while]中

  • 基本语法

    {
        ......
        break;
        ......
    }

  • 注意事项和细节说明

    1. break语句出现在多层嵌套的语句块中，可以通过标签指明要终止的是哪一层语句块

    2. 标签的基本使用

       

       1. break语句可以指定退出哪一层

       2. label1是标签，由程序员指定

       3. break后指定到哪个label就推出到哪里

       4. 在实际开发中，尽量不要使用标签

       5. 如果没有指定break，默认退出最近的循环

       

• 跳转控制语句-continue

  • 基本介绍

    1. continue语句用于结束本次循环，继续执行下一次循环

    2. continue语句出现在多层嵌套的循环语句体中，可以通过标签指明要跳过的是哪一层循环这个和前面的标签的使用规则一样。

  • 基本语法

    {
        ......
        continue;
        ......
    }

• 跳转控制语句-return

  • 介绍

    return使用在方法，表示跳出所在的方法，在方法处会详细介绍。注意：如果return写在main方法，退出程序...

五.数组、排序与查找

1.数组

• 数组介绍

  数组可以存放多个同一类型的数据。数组也是一种数据类型，是引用类型。即：数组就是一组数据

• 数组的使用

  • 使用方式1-动态初始化

    1. 数组的定义

       数据类型 数组名[] = new 数据类型[大小]

       int a[] = new int [5];//创建了一个数组，名字为a，存放5个int

    2. 数组的引用(使用)

       数组名[下标/索引]比如：你要使用a数组的第三个数 a[2]

  • 使用方式2-动态初始化

    1. 先声明数组

       语法：数据类型 数组名[]；也可以 数据类型[] 数组名;

       int a[]; 或者 int[] a;

    2. 创建数组

       语法：数组名 = new 数据类型[大小];

       a = new int[10]

  • 使用方法3-静态初始化

    1. 初始化数组

       语法：数据类型 数组名[] = {元素值，元素值......}

       int a[] = {1,2,3,4,5,6,7,8,9}

  • 数组使用注意事项和细节

    1. 数组是多个相同类型数据的组合，实现对这些数据的统一管理

    2. 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用

    3. 数组创建后，如果没有赋值，有默认值 int 0,short 0,byte 0,float 0.0,double 0.0,char \u0000,boolean false,String null

    4. 使用数组的步骤1. 声明数组并开辟空间 2.给数组各个元素赋值 3. 使用数组

    5. 数组的下标是从0开始的。

    6. 数组下标必须在指定范围内使用，否则报：下标越位异常

    7. 数组属引用类型，数组型数据是对象(object)

• 数组赋值机制

  1. 基本数据类型赋值，这个值就是具体的数据，而且相互不影响。

     int n1 = 2; int n2 = n1;n2的变化不会影响到n1

  2. 数组在默认情况下是引用传递，赋的值是地址。

  

• 数组拷贝

  将int[] arr1 = {10,20,30}拷贝到arr2数组 要求数据空间是独立的

  

• 数组反转

  要求：把数组的元素进行反转

  

• 数组添加(数组扩容)

  要求：实现动态的给数组添加元素效果，实现对数组扩容。

  1. 原始数组使用静态分配 int[] arr = {1,2,3}

  2. 增加的元素，直接放在数组的最后 arr = {1,2,3,4}

     arrNew = {1,2,3,4}

     

• 数组缩减

  

2.排序

• 排序的介绍

  排序是将一群数据，依指定的顺序进行排列的过程

  排序的分类

  1. 内部排序

     指将需要处理的所有数据都加载到内部存储器中进行排序。包括(交换式排序法、选择式排序法和插入式排序法)

  2. 外部排序法

     数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。包括(合并排序法和直接合并排序法)

• 冒泡排序法(Bubble Sorting)

  • 基本思想

    通过对待排序序列从后向前(从下标较大的元素开始)，依次比较相邻元素的值，若发现逆序列交换，使值较大的元素逐渐向前移后部，就像水底下的气泡一样逐渐向上冒。

  • 代码

    public class ArrayDelate {
        public static void main(String[] args) {
            int[] arr = {1,6,5,7,23,9,11,22,82,10};
            for (int i = 0; i < arr.length; i++) {
                for (int j = i; j < arr.length - i -1; j++) {
                    if (arr[j] > arr[j + 1]){
                        int temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                    }
                }
            }
            for (int i = 0; i < arr.length; i++) {
                System.out.println(arr[i]);
            }
        }
    }

• 查找

  • 介绍

    在java中，我们常用的查找有两种：

    1. 顺序查找SeqSearch

    2. 二分查找

3.多维数组-二维数组(Two Dimensional Array)

• 使用方式

  • 使用方式1-动态初始化

    

  • 内存中的存在形式

    

  • 使用方法2-动态初始化 使用方法3-动态初始化-列数不确定

    

  • 使用方法4-静态初始化

    

• • 杨辉三角

• public class YangHui {
      public static void main(String[] args) {
          int arr[][] = new int[10][];
          for (int i = 0; i < arr.length; i++) {
              arr[i] = new int[i + 1];
              for (int j = 0; j <= i; j++) {
                  if (j == 0 || j == i){
                      arr[i][j] = 1;
                  }
                  else {
                      arr[i][j] = arr[i - 1][j] + arr[i - 1][j - 1];
                  }
              }
          }
          for (int i = 0; i < arr.length; i++) {
              for (int j = 0; j <arr[i].length; j++) {
                  System.out.print(arr[i][j] + "\t");
              }
              System.out.println();
          }
      }
  }

• • 使用细节和注意事项

    1. 一维数组的声明方式有：int[] x 或者 int x[]

    2. 二维数组的声明方式有

       

    3. 二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可以相同，也可以不相同。

  • 课堂练习

    

• 章节练习

  1. 

  2. 升序数组中插入一个元素保证还是升序

     public static void main(String[] args) {
             int arr[] = new int[]{3,7,9,11,25,29,58,99};
             int insertNum = 23;
             int index = -1;
             for (int i = 0; i < arr.length; i++) {
                 if (insertNum < arr[i]){
                     index = i;
                     break;
                 }
             }
             int newArr[] = new int[arr.length + 1];
             for (int i = 0, j = 0; i < newArr.length; i++) {
                 if (i != index){
                     newArr[i] = arr[j];
                     j++;
                 }else {
                     newArr[i] = insertNum;
                 }
             }
             arr = newArr;
             for (int i = 0; i < arr.length; i++) {
                 System.out.print(arr[i] + " ");
             }
         }