《疯狂Java讲义》学习笔记（四）流程控制与数组

1、顺序结构

• 顺序结构就是程序从上而下逐行地执行，中间没有任何判断和跳转

2、分支结构

• if…else…
• switch
  控制表达式只允许byte、short、char、int、String和枚举类型

swicth(expression){
    case condition1:{
        statement(s)
        break;
    }
    case condition2:{
        statement(s)
        break;
    }
    ...
    default:{
        statement(s)
    }
}
// 注意每个case中需要带有break;

3、循环结构

• 循环语句包含的4个部分：

初始化语句init_statement
循环条件test_expression
循环体body_statement
迭代语句iteration_statement

• while

[init_statement]
while(test_expression){
    statement;
    [iteration_statement]
}
例：
int count = 0;
while(count<10){
    System.out.println(count);
    count++;
}

• do…while

// 循环体至少执行一次
[init_statement]
do{
    statement;
    [iteration_statement]
}while(test_expression);
例：
int count = 0;
do{
    System.out.println(count);
    count++;
}while(count<10);

• for循环

for([init_statement];test_expression;[iteration_statement]){
    statement;
}

• 嵌套循环，就是循环中套有循环

for(int i=0;i<5;i++){
    for(int j=0;j<5;j++){
        System.out.println(i+j);
    }
}

4、控制循环结构

• break
  结束当前循环
• break outer

// 结束至指定循环
outer:
for(int i=0;i<5;i++){
    for(int j=0;j<5;j++){
        System.out.println(i+j);
        if(j==1){
            break outer;
        }
    }
}

• continue

// 忽略本次循环
for(int i=0;i<5;i++){
    if(i==2){
        continue;
        System.out.println(i);
    }
}

• continue outer类似break outer
• return 全部退出

5、数组类型

数组用于存储多个数据，每个数组元素存放一个数据，通常可通过数组元素的索引来访问数组元素，包括为数组元素赋值和取出数组元素的值

• 理解数组
  一个数组中，数组元素的类型是唯一的，但子类
  Person[] personArray = new Person[]{new Person(),new Gril()}
  组初始化完成，数组的内存中所占的空间将被固定下来，即使某个数组元素数据被清空，数组长度不变
  数组也是一种引用类型，int是基本类型，但int[]是引用类型
• 定义数组

String[] strArray(推荐)
String strArray[]

• 数组静态初始化

初始化时由程序员显式指定每个数组元素的初始值，由系统决定数组长度
int[] intArray = new int[]{5,6,7,8}
int[] intArray = {5,6,7,8}

• 数组动态初始化

int[] intArray = new int[4];
初始值如下：
整型（byte、short、int和long），初始值是0
浮点（float、double），初始值是0.0
字符（char），初始值是'\u0000'
布尔（boolean），初始值是false
引用类型（类、接口和数组），初始值是null

• 使用数组
  数组下标从0开始，intArray[0]是第一个元素
  可以使用for或foreach遍历数组
• 内存中的数组
  数组变量只是一个引用，实际的数组对象被存储在堆（heap）中
  如果引用的对象是局部变量，那么它被存储在栈（stack）中
• 二维数组就是每个元素都是一个数组
  String[][] strArray = new String[][]{new String[3],new String[]{"hello"}}
• 操作数组的常用API：
  
  • 查找元素出现索引（要求元素已经升序排序）：
    int Arrays.binarySearch(type[] a,type key)
    如果数组不包含key，则返回负数
  • 在指定范围查找元素出现索引（要求元素已经升序排序）：
    int Arrays.binarySearch(type[] a,int fromIndex,int toIndex,type key)
  • 复制数组，如果小于原来长度则取前面的元素，如果大於则多出来的补默认值
    type[] Arrays.copyOf(type[] original,int length)
  • 在指定范围复制数组，与上面类似
    type[] Arrays.copyOfRange(type[] original,int from,int to)
  • 对比数组，如果长度相等且数组元素也一一相同，返回true
    boolean Arrays.equals(type[] a,type[] b)
  • 数组赋值，把数组元素全部复制为val
    void Arrays.fill(type[] a,type val)
  • 在指定范围数组赋值
    void Arrays.fill(type[] a,int fromIndex,int toIndex,type val)
  • 排序
    void Arrays.sort(type[] a)
  • 在指定范围数组排序
    void Arrays.sort(type[] a,int fromIndex,int toIndex)
  • 转换成字符串，按顺序把多个数组元素连缀在一起，多个数组元素使用英文逗号和空格隔开
    String Arrays.toString(type[] a)
• Java8新增操作数组API

int[] arr1 = new int[]{3,-4,25,16,30,18};
// 并发排序，性能更强
Arrays.parallelSort(arr1);
int[] arr2 = new int[]{3,-4,25,16,30,18};
// 前一个元素乘积和后一个元素相乘，第一个元素时乘以1
{1*3=3,3*-4=-12,-12*25=-300,-300*16=-48000,-48000*30=-144000,-144000*18=-2592000}
Arrays.parallelPrefix(arr2,new IntBinaryOperator(){
    public int applyAsInt(int left,int right){
        return left*right;
    }
});
int[] arr3 = new int[5];
// 与索引值相乘
{0,5,10,15,20}
Arrays.parallelSetAll(arr3,new IntUnaryOperator(){
    public int applyAsInt(int operand){
        return operand*5;
    }
});