本章学习内容
一、顺序结构
任何编程语言中最常见的程序结构就是顺序结构。顺序结构中，程序从上到下逐行执行；在没有流程控制语句的情况下，排在前面的代码总是先执行，排在后面的代码总是后执行。
二、分支结构
两种分支结构
if语句有三种形式，分别是if...，if...else...，if...else if...else。
if () {
// do something
} else if () {
// do something
} else {
// do something
}
switch语句
switch (expression) {
case 'A':
// do something
break;
case 'B':
// do something
break;
default:
// do something
}
三、循环结构
循环的四个部分
1、while循环：先执行条件判断，后执行循环体。
int count = 0;
while(count < 10) {
// do something
count++;
}
2、do...while循环：先执行循环体，后执行条件判断。
int count = 0;
do {
// do something
count++;
} while (count < 10);
3、for循环：在大部分情况下，for循环可以替代while循环、do...while循环。
for (int count=0; count<10; count++) {
// do something
}
4、嵌套循环
嵌套循环的执行流程
for (int i=0; i<10; i++) {
for (int j=0; j<10; j++) {
int sum = i + j;
System.out.println(sum);
}
}
除了这种两层嵌套的循环，事实上还可以有三层、四层、更多层的循环嵌套。
四、控制循环结构
Java语言提供了 continue / break 关键字来控制循环结构。除此之外，还可以使用 return 来结束一次循环并结束整个方法。
1、break 用于结束一个循环、跳出当前循环
for (int i=0; i<100; i++) {
if (i == 50) {
break;
}
}
2、break 用于结束指定的循环、跳出指定的循环
// 为循环指定一个标识符 outer
outer:
for (int i=0; i<100; i++) {
for (int j=0; j<100; j++) {
if (j == 50) {
break outer;
}
}
}
3、continue 用于忽略本次循环中剩下的语句、开始下一次循环
for (int i=0; i<100; i++) {
System.out.println(i);
if (i == 50) {
continue;
}
// 当 i=50 时，下面这条语句将被忽略
System.out.println(i);
}
4、continue 指定某层循环，忽略本次循环，开始下一次循环
// 为循环指定一个标识符
outer:
for (int i=0; i<100; i++) {
for (int j=0; j<100; j++) {
System.out.println(j);
if (j == 50) {
continue outer;
}
// 当 j=50 时，内层循环将被终止
System.out.println(j);
}
// 当 j=50 时，下面这条语句将被忽略
System.out.println(i);
}
5、使用 return 结束整个方法
return
public static void main(String[] args) {
for (int i=0; i<10; i++) {
if (i==5) {
return;
}
}
}
与 continue / break 不同的是，return 直接结束掉整个方法，不管这个 return 处于循环体中的哪个位置。
五、数组类型
1、理解数组：数组也是一种数据类型
Java数组要求所有的元素都是相同的数据类型。即一个数组里只能存储一种数据类型的数据，而不能存储多种数据类型的数据。
数组也是一种类型.png
2、定义数组
int[] arr;
定义数组
3、数组初始化
数组初始化
1）数组的静态初始化
// 数组定义和初始化写成两条语句
int[] arr1;
arr1 = new int[] {1,2,3,4,5};
// 用一条语句完成数组的定义和初始化
int[] arr2 = {1,2,3,4,5};
Object[] arr3;
arr3 = new Object[] {"Java", "技术"};
Java是面向对象的编程语言，很好地支持子类和父类的继承关系，即子类实例是一种特殊的父类实例。因此 Object[]类型的数组中，也可以装载着 String 类型的元素。
2）数组的动态初始化
动态初始化时，只用指定数组的长度，由系统为每个元素指定初始值。
int[] arr1 = new int[5];
Object[] arr2 = new Object[2];
动态初始化
4、使用数组（赋值与取值）
int[] arr = new int[] {1,2,3,4,5};
// 取值
int first = arr[0];
// 赋值
arr[4] = 100;
// 获取数组的长度
int len = arr.length;
数组索引越界异常.png
5、foreach循环，遍历数组
int[] arr = new int[] {1,2,3,4,5};
for (int ele : arr) {
System.out.println(ele);
}
注意事项：1、上述代码中的 ele是形参变量，可看成循环中的一个临时变量，因此建议不要在循环中为 ele赋值。2、foreach循环通常用于遍历数组或集合。
六、内存中的数组
数组是一种引用类型，数组的引用变量是一个引用，数组元素和数组变量在内存中是分开存储的。
1、数组在内存中的存储方式（栈与堆）
1）定义并初始化一个数组后，在内存中会分配两个空间，一个空间（栈）用于存储数组的引用变量，另一个空间（堆）用于存储数组对象本身。数组的引用变量和实际的数组对象，在内存中的存储位置如下图示：
数组在内存中的存储方式.png
2）关于栈和堆的理解：实际的数据对象是存放在堆内存中的，而指向实际数据对象的引用变量是存放在栈内存中的。
关于栈和堆.png
3）只要数据类型兼容，我们可以让一个数组的引用变量指向另一个实际的数组对象。代码示例如下：
int[] a = {1,2,3};
int[] b = {3,4,5,6,7,8};
// 改变 b 引用变量的指向
b = a;
改变引用变量的指向.png
学习数组的建议.png
2、图解实例：进一步理解“内存中的数组”
// 定义一个 Person 类
class Person {
public int age;
public double height;
public void info() {
System.out.println(age + ":" + height);
}
}
public class ReferenceArrayTest {
public static void main(String[] args) {
// 创建数组
Person[] students = new Person[2];
// 创建第一个 Person实例
Person zhang = new Person();
zhang.age = 15;
zhang.height = 158;
// 创建第二个 Person实例
Person lee = new Person();
lee.age = 16;
lee.height = 161;
// 动态初始化 students数组
students[0] = zhang;
students[1] = lee;
}
}
图解
七、多维数组
二维数组
1、图解二维数组在内存中的存储方式
// 创建数组 a，并指定一维的长度为 4
int[][] a = new int[4][];
// 初始化一维数组中的第一个元素
a[0] = new int[2];
a[0][0] = 0;
a[0][1] = 6;
图解
2、二维数组的动态初始化
int[][] b = new int[3][4];
图解
3、二维数组的静态初始化
String[][] str1 = new String[][] {
new String[3],
new String[] {"hello"}
};
// 等价于
String[][] str1 = {
new String[3],
new String[] {"hello"}
};
图解
总结：二维数组是一维数组，其数据元素是一维数组；三维数组也是一维数组，其数据元素是二维数组；依次类推。由此可见，Java语言里本质上并没有什么多维数组。
八、java.util.Arrays
Java提供了 Arrays工具类，它包含一些非常实用的 static静态方法，以用来操作数组，比如数组的复制、排序等，有很多方法还可以利用CPU的并行能力来提高数组操作的性能。
Arrays
本章结束 2019-02-09
网友评论