JAVA_BASE--3流程控制及数组

注明：准备把java系统的复习一遍，把以前的资料知识也整理一遍，加油！不要拖延！本文有些内容以前收集来自网络，谢谢各位大神！

一.流程控制

流程控制用来控制程序中各语句的执行顺序。
流程控制语句分类：顺序结构、选择结构、循环结构。

1.顺序结构

一般自上而下执行，写在前面的先执行，写在后面的后执行。

2.选择结构，也称为分支结构

不按原先流程运行。
Java语言提供了两种选择结构语句：if语句、switch语句。

1).if语句

1. if语句第一种格式：
   if(关系表达式) {
   语句体
   }
   注意：{}不要省略，如果没有{}，条件成立只执行一条语句。
2. if语句第二种格式：
   if(关系表达式) {
   语句体1;
   }else {
   语句体2;
   }
   另if语句第二种格式和三元运算符：
   三元运算符的操作都可以使用if语句改进，反之不成立。
   什么时候不成立呢?
   当if语句控制的语句体是一条输出语句的时候，就不成立。因为三元运算符是一个运算符，必须要求有一个结果返回。而输出语句却不能作为一个返回结果。
3. 多重if选择结构3、嵌套if选择结构：
   if(关系表达式1) {
   语句体1;
   }else if(关系表达式2) {
   语句体2;
   }else {
   语句体3;
   }
   注意：a).使用多重if选择语句处理问题时需要注意顺序。
   b).else if结构只要满足其中某一个分支的要求后，就不会再执行其他分支语句。

if(关系表达式) {
if(关系表达式a) {
语句体a;
}else {
语句体b;
}
}else {
语句体2;
}

补充知识：
1.字符串[所有引用数据类型]的比较使用equals()方法。
eg: name1.equals(“张三”) >>>>name1等于张三
！name2.equals(“张三”) >>>>name2 不等于张三
2. 随机数Math.random()范围[0.0 , 1.0)
故产生随机数(0~9)的方法如下：int random=(int)(Math.random()*10);

2).switch选择结构

语法:
switch (表达式) {
case 常量 1:
语句;
break;
case 常量 2:
语句;
break;
…
default:
语句;
}

表达式6种类型：int、short、byte、char、枚举类型、String。
break表示中断，结束的意思，可以结束switch语句。
default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。
swith语句注意事项：

1. case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
2. default可以省略吗?
   可以省略。一般不建议。除非判断的值是固定的。(单选题)
3. break可以省略吗?
   可以省略，一般不建议。否则结果可能不是你想要的
4. default的位置一定要在最后吗?
   可以出现在switch语句任意位置，如果不在结尾处必须加上break;
5. switch语句的结束条件：
   遇到break，或者执行到程序的末尾。

比较switch和多重if选择结构：
相同点：都是用来处理多分支条件的结构。
不同点：switch选择结构，只能处理等值条件判断的情况；多重if选择结构，没有switch选择结构的限制，特别适合某个变量处于某个连续区间时的情况。
if语句使用场景：针对结果是boolean类型的判断；针对一个范围的判断；针对几个常量值的判断。
switch语句使用场景：针对几个常量值的判断。

基本if选择结构：可以处理单一或组合条件的情况
if-else选择结构：可以处理简单的条件分支情况
多重if选择结构：可以处理分段的条件分支情况
嵌套if选择结构：可以处理复杂的条件分支情况
switch选择结构：多重分支并且条件判断是等值判断的情况。

3.循环结构

重复执行。

循环语句的组成：

• 初始化语句：一条或者多条语句，这些语句完成一些初始化操作。
• 判断条件语句：这是一个boolean 表达式，这个表达式能决定是否执行循环体。
• 循环体语句：这个部分是循环体语句，也就是我们要多次做的事情。
• 控制条件语句：这个部分在一次循环体结束后，下一次循环判断条件执行前执行。通过用于控制循环条件中的变量，使得循环在合适的时候结束。

1).while循环

初始化语句;
while(判断条件语句) {
循环体语句;
控制条件语句;
}

2).do…while循环

初始化语句;
do {
循环体语句;
控制条件语句;
} while(判断条件语句);
注意：while()里判断条件语句为true时，循环继续。

3).for循环

for(初始化语句;判断条件语句;控制条件语句) {
循环体语句;
}

for循环语句和while循环语句可以等价转换，但还是有些小区别的：
使用区别：控制条件语句所控制的那个变量(for内定义的内部变量)，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量（内部变量）就从内存中消失，能够提高内存的使用效率【也可以在for外先定义变量，这样for循环结束后可继续使用】。
场景区别：
for循环适合针对一个循环次数确定的情况进行操作；
while循环适合判断次数不明确操作。

三种循环语句其实都可以完成一样的功能，也就是说可以等价转换，但还是有小区别的:
do…while循环至少会执行一次循环体。
for循环和while循环只有在条件成立的时候才会去执行循环体
适用情况：
 循环次数确定的情况，通常选用for循环
 循环次数不确定的情况，通常选用while或do-while循环
注意事项：
写程序优先考虑for循环，再考虑while循环，最后考虑do…while循环。【for循环结束后，内部变量消失，节省内存】
如下代码是死循环：
while(true){}
for(;?{}

增强for循环即foreach 遍历使用：
for(数据类型 变量:数组名){}
【要求定义变量的数据类型要和数组类型一致。本方法程序步骤是将数组各元素等等 依次赋值给同类型变量,并依次执行{}】

4).跳转控制语句

==break 中断、continue 继续、return 返回 ==

1. return：结束当前方法的执行并退出，返回到调用该方法的语句处。

2. break 和continue
   使用场合：
   break常用于switch结构和循环结构中
   continue一般用于循环结构中
   作用（循环结构中【while；do…while；for(for语句可在嵌套的if语句里用break跳出整个for语句,用continue跳出当前循环)】）：
   break语句终止某个循环，程序跳转到循环块外的下一条语句
   continue跳出本次循环，进入下一次循环
   双重循环亦如此

3. 跳出多层循环的外层循环时使用 标签名：
   【语法】标签名: 循环语句
   eg:
   a:for( ; ;）{
   b:for( ; ;）{
   break a; // 结果直接跳出外层for循环
   }
   }

4.如何进行程序调试

1.通过代码阅读或者加输出语句查找程序错误。
2.当程序结构越来越复杂时，需要专门的技术来发现和定位错误，就是“程序调试”。(debug 调试)

1. 设置断点【双击代码行前的数字】
2. 单步运行【点击debug as（虫子）】
3. 观察变量【点击 step over箭头，一步步运行，观察结果，找到问题】

二.数组

数组是一个变量，存储相同数据类型的一组数据。
声明一个变量就是在内存空间划出一块合适的空间；
声明一个数组就是在内存空间划出一串连续的空间。

1).基础概念

数组长度固定不变，避免数组越界。数组中的所有元素必须属于相同的数据类型。

数组基本要素：
数组名称(标识符)、数组元素、元素类型、元素下标(从0开始)。
数组长度：数组名称.length

Java中的数组必须先初始化,然后才能使用。创建数组并初始化，必须在一条语句中完成。
所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。动态初始化和静态初始化不能混合使用。动态初始化后，只能一个个自定义数组元素值。

数组的初始化方式：

• 动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
  【int/short/byte/long–0; float/double–0.0; String–null(所有引用类型的默认值都是null); char-- (空格)；boolean–false】
  格式：
  数据类型[] 数组名 = new 数据类型[数组长度];
  数据类型[] 数组名 = 数组2名;【数组2已定义】
  其中数组长度其实就是数组中元素的个数。
  举例：int[] arr = new int[3];
  解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值。
• 静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。
  格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
  可简写为：数据类型[] 数组名 = {元素1,元素2,…}
  举例：
  int[] arr = new int[]{1,2,3};
  解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值，并且值分别是1,2,3。
  其实这种写法还有一个简化的写法
  int[] arr = {1,2,3};

数组元素遍历方法：

1. 增强for循环即foreach
   for(数据类型 变量:数组名){}
   【要求定义变量的数据类型要和数组类型一致,本方法程序步骤是将数组各元素依次赋值给同类型变量,并依次执行{}】
2. 普通for循环
   for(int i=0;i<arr.length;i++){}

Java中的内存分配（必须专项学习）：
Java 程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
全面浅析：https://blog.csdn.net/scliu12345/article/details/53738185

• 栈：存储局部变量【读取速度快】
  栈存放基本类型的变量数据和对象的引用，但对象本身不存放在栈中，而是存放在堆（new 出来的对象）或者常量池中（字符串常量对象存放在常量池中。）。对于基础类型的变量和常量：变量和引用存储在栈中，常量存储在常量池中。
  局部变量：定义在方法中的变量都是局部变量(main方法也是方法，所以定义在main方法中的变量也是局部变量)。
  __ 形式参数是局部变量__，局部变量的数据存在于栈内存中。栈内存中的局部变量随着方法的消失而消失。
  无论是普通类型的变量还是引用类型的变量(俗称实例)，都可以作为局部变量，他们都可以出现在栈中。只不过普通类型的变量在栈中直接保存它所对应的值，而引用类型的变量保存的是一个指向堆区的指针，通过这个指针，就可以找到这个实例在堆区对应的对象。因此，普通类型变量只在栈区占用一块内存，而引用类型变量要在栈区和堆区各占一块内存。
• 堆：【动态分配】
  存储new出来的东西即引用数据类型【对象(类实例)、数组、String、、、】(这里的new不是指一定要写出来的new，比如对象和数组静态初始化就是)，。
• 方法区 (面向对象部分讲)

2).数组常用操作

1. 获取最大、最小值；数字排序；插入数字
   用二重循环实现冒泡排序，冒泡排序速记口诀（升序）：
   N个数字来排队
   两两相比小靠前/大靠后
   外层循环 共 N-1 次
   内层循环 N-k 次 (k—第k次外层循环)

三个基本排序算法：冒泡排序、选择排序、插入排序【专项学习】

• 冒泡排序：【升序】每次相邻元素进行比较，如果发现较小的元素在后面，就交换两个相邻的元素。
• 选择排序：在冒泡排序上做了优化，减少了交换次数。
  【升序】外层循环控制次数，内层循环控制找到最小的值。然后将内层循环找到的最小值与外层循环本次索引对应元素进行交换，直至遍历完整个数组。
  即在首轮选择最小的数放在第一项，第二轮从第二项开始选择最小的数放在第二项，以此类推，直到整个数组完全有序。
• 插入排序：和前俩种排序不同，插入排序在排序过程中是局部有序。 随着插入项的增多，有序部分的项的位置会发生改变，而冒泡排序和选择排序每轮确定的项数的位置是永远不变的。
  【升序】首轮选择第二项作为插入项，然后取出这一项放在一个变量中，和前一项比较而且小时，则前一项后移到第二项的位置，然后第二项也就是插入项放在前一项的位置。 第二轮选择第三项作为插入项，和前一项也就是第二项比较如果小时，第二项后移到插入项，然后插入项在和第一项比较如果小时，则第一项后移到第二项，插入项放在第一项。（插入项的数组值最终赋值给内层循环元素空出的下标位置）。以此类推。

  case: 对int[] sr={99,82,63,85,60}; 进行降序排列。
  for(int i=1;i<sr.length;i++){
  int temp=sr[i]; //把插入项的数值赋值给临时变量
  int j=i;
  while(sr[j-1]<temp && j>=0){ //判断前一项是否比插入项小
  sr[j]=sr[j-1];
  j–;
  }
  sr[j]=temp; //把插入项的数组值赋值给 内层循环元素空出的下标位置
  }

三种排序学习参考： https://blog.csdn.net/qq_39380737/article/details/80907396
插入排序算法比冒泡快一倍，比选择排序略快一点，但这些算法都是O(N2)的时间级别。

2. 使用Arrays类操作数组
   使用java.util包提供的工具类Arrays类（java.util.Arrays）提供了操作数组的方法，例如排序sort、查询binarySearch
   
   具体使用方法解释如下：
   1）.数组排序【没有返回值】
   调用系统Arrays类的sort()方法:对数组进行升序排列 。Arrays.sort(数组名);
   从第几个到第几个之间的进行排序,下标【a,b)范围。 Arrays.sort(数组名,a,b);
   2）.数组转成string数组【返回值是String类型】
   调用系统Array类的方法toString,将基本数据类型数组转成string数组
   String str1 = Arrays.toString(数组名);
   System.out.println(Arrays.toString(数组名));
   3）.复制数组
   把数组array复制成一个长度为length的新数组，返回类型与复制的数组一致.新数组长度小于原数组长度时仅取原数组下标相应长度元素;新数组长度大于原数组长度时,超出部分补全默认值.
   int[] 新数组名 = Arrays.copyOf(原数组名, 新长度);
   int[] 新数组名 = Arrays.copyOfRange(原数组名, c,d); 下标【c,d)范围
   4）.比较两个数组是否相等 【比较的是数组元素】
   【返回值是boolean类型】
   boolean a = Arrays.equals(数组名1, 数组名2);
   System.out.println(Arrays.equals(数组名1,数组名2));
   5）.把数组array所有元素都赋值为val 【void–返回空类型】
   == Arrays.fill(数组名,val) ;==
   6）.查询元素值val在数组array中的下标。（要求数组中元素已经按升序/降序排列，即有序数组）
   【返回值是int类型】
   int b=Arrays.binarySearch(数组名,val);
   System.out.println(Arrays.binarySearch(数组名,val));

3).二维数组（多维数组）的使用

二维数组其实就是一个元素为一维数组的数组。
定义二维数组时，须定义最大维数，也即有多少个一维数组。

二维数组定义格式：

• 格式1：数据类型[][] 变量名 = new 数据类型[m][n];
  m表示这个二维数组有多少个一维数组
  n表示每一个一维数组的元素个数
  举例：
  int[][] arr = new int[3][2];
  定义了一个二维数组arr
  这个二维数组有3个一维数组，名称是arr[0],arr[1],arr[2]
  每个一维数组有2个元素，可以通过arr[m][n]来获取
  表示获取第m+1个一维数组的第n+1个元素
• 格式2：数据类型[][] 变量名 = new 数据类型[m][];
  m表示这个二维数组有多少个一维数组
  这一次没有直接给出一维数组的元素个数，可以动态的给出。
  举例：
  int[][] arr = new int[3][];
  arr[0] = new int[2];
  arr[1] = new int[3]
  arr[2] = new int[1];
• 格式3：
  数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
  简化版格式： 数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
  举例：
  int[][] arr = {{1,2,3},{4,6},{6}};

二维数组的长度表示
举例：int a[2][2];
int len1=a.length;行长度
int len2=a[i].length.列长度

遍历二维数组