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

Java语言有三种控制结构：顺序结构、分支结构、循环结构

一、顺序结构

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

二、分支结构

• 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;

switch中的每一个case中都须要带有break，由于switch语句遇到相等的值，程序就开始执行这个case标签后的代码，再也不判断与后面case，default标签的条件是否匹配，除非遇到break;才会结束

三、循环结构

• 循环语句包含的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);
    }
}

四、控制循环结构

• 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 所有退出

五、数组类型

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

• 理解数组 

Java语言中数组必须先初始化，而后才可使用。所谓初始化，就是为数组元素分配内存空间，并为每一个数组元素赋初始值。只要为数组元素分配了内存空间，数组元素就具备了初始值。初始值的得到由两种形式：一种是由系统自动分配，另外一种由程序员指定。

• 定义数组

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

• 数组静态初始化：初始化时由程序员显示指定每一个数组元素的初始值，由系统决定数组长度。

arrayName=new type[ ] {element1,element2,element3.....};

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

• 数组动态初始化 ：执行动态初始化时，程序员只须要指定数组的长度，即为每一个数组元素指定所需的内存空间，系统将负责为这些数组元素分配初始值。

arrayName=new type[length];

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： 

Java提供了操做数组的工具类：java.util.Arrays；Arrays类包含的一些static修饰的方法能够直接操做手数组。

查找元素出现索引（要求元素已经升序排序）： 
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

Java8加强了Arrays类的功能，为Arrays类增长了一些工具方法，这些工具方法能够充分利用多CPU并行的能力来提升设值、排序的性能。

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;
    }
});