JAVA语言基础（三）——跳转语句、数组

Java程序语句执行的顺序包括4种基本控制结构：
（1）顺序结构；
（2）选择结构：if语句和switch语句；
（3）循环结构：for、while、do……while、for each；
（4）异常处理逻辑结构。

一、跳转语句

跳转语句用于无条件地转移控制。使用跳转语句执行分支，该语句会导致立即传递程序控制。
（一）break语句
（1）不带标签的break语句：
在多分支选择（switch结构）中的作用是跳出switch结构，继续执行switch语句的后继语句。
还可以用于退出for、for each、while或do……while循环，即提前结束循环，接着执行循环语句的后继语句。

注：不能用于循环语句和switch语句之外的任何其他语句之中，否则将产生编译错误。
当多个switch、while、do……while、for或for each语句彼此嵌套时，不带标签的break语句只应用于最里层的语句，即用于跳出最近的一层循环。

若要穿过多个嵌套层转移控制，必须使用带标签的break语句。
（2）带标签的break语句：
带标签的break语句用于跳出有标签标记的语句/语句块。
标签是一个标识符，标签后面带一个冒号，并置于一个语句或语句块之前，则标记该语句或语句块。
注：带标签的break语句跳转到目的标签只能指向包含该break语句的外层语句块，否则会产生编译错误。
（二）continue语句
（1）不带标签的continue语句：
类似于break语句，但它结束本次循环，即跳过循环体内continue下面尚未执行的语句，返回到循环起始处，并根据循环条件判断是否执行下一次循环。
与不带标签的break语句的区别在于：continue语句只结束本次循环，并返回到循环起始处，如果条件满足就开始执行下一次循环；而break语句则是结束循环，跳转到循环的后继语句执行。

与不带标签的break语句相似，当多个while、do……while、for或for each语句彼此嵌套时，不带标签的continue语句只应用于最里层的语句。如果要穿过多个嵌套层转移控制，必须使用带标签的continue语句。
（2）带标签的continue语句：
与带标签的break语句相似，用于结束本次循环，并跳转到由标签标记的外层循环。

注：带标签的continue语句只能用于穿过多个嵌套层转移控制，它跳转到的目标标签也只能指向包含该continue语句的外层语句块，否则会产生编译错误。
（三）return语句
用于终止方法的执行并将控制返回给调用方法。
如果方法有返回类型，return语句必须返回这个类型的值。
如果方法为void类型，不使用return语句。

二、数组概述

数组是一种数据结构，是包含相同数据类型的集合。本身是数组引用类型对象，数组元素可以是任何数据类型（简单类型或引用类型），包括数组类型。

• 数组必须先声明。因为数组类型为引用类型，数组变量的声明只是为数组实例的引用留出空间。
• 数组在声明后必须实例化才能使用。

注：如果通过{}初始化数组的元素，使用new运算符创建数组不需要也不能指定数组元素的个数，Java编译器将自动推断数组的个数。

通过数组下标来访问数组中的数据元素。数组下标从0开始，具有n个元素（即长度为n）的数组的下标是0~n-1.

三、Java类库中操作数组的类和方法

（1）java.util.Arrays：可用于数组的复制、排序等操作处理。
（2）System.arraycopy：是System类提供的一个静态方法，可以用它来实现数组间的复制。
（3）数组名.clone()：
如果要将一个数组a1的内容复制给另外一个数组a2的方法：

• 使用循环语句，将数组a1的每个元素复制到数组a2对应的元素。优点：灵活；缺点：需要编码。
• 使用数组变量的clone()方法。优点：简单；缺点：不够灵活。
• 使用System.arraycopy(src,srcPos,dest,destPos,length)方法。该方法灵活简单推荐使用。
• 使用java.util.Arrays.CopyOf/copyOfRang方法。简单灵活推荐使用。

注：clone()方法不能直接作用于多维数组。如果要用clone()方法对多维数组进行复制，就要在每一维上调用clone()方法。

练习

**1.1.实现二分查找算法：有序的数组
**

//import java.util.Scanner;

public class BinarySearch {
    //二分查找
    public static int binarySearch(int[] a,int key){
        //开始查找范围始从数组的第一个元素到最后一个
        int low = 0;//最小元素下标为0
        int high = a.length - 1;//最大元素下标==数组长度-1
        int m = a.length / 2;//中间数下标
        if (key == a[m]){//中间数和key相等，查找成功
            return m;
        }else{
            //如果不相等，继续查找
            while(low <= high){//查找结束,退出循环
                m = (low + high) /2;
                if (key == a[m]){//如果key和比较元素的值相等，查找成功
//                System.out.println(key + "= array[" + m + "]" );
                    return m;
                }else if(key < a[m]){
                    high = m - 1;//在中间数的左边查找
                } else{//key>a[m]
                    low = m +1;//在中间数右边查找
                }
            }
            //查找失败，返回-1
            return -1;
        }

    }

    public static void main(String[] args){

//        Scanner scan = new Scanner(System.in);
//        System.out.println("输入一个长度为10的一维数组：");
//        int[] array = new int[10];
//        for(int i = 0;i < 10;i ++){
//            array[i] = scan.nextInt();
//        }

        int[] array = {1,2,3,4,5,6,7,8,9,10};
        binarySearch(array,3);

//        System.out.println("查找元素：");
//        int k = scan.nextInt();
        System.out.println(k);
//        binarySearch(array,k);
    }
}

**2.求连续子数组的最大和
**

//求连续子数组的最大和，不能超过0x8000 0000
//import java.util.Scanner;
import java.util.Arrays;

public class MaxSumOfSubarray {
    public static int maxSum(int a[]) {
        if (a.length == 0) //数组长度为0，直接返回-1
            return -1;
        if (a.length == 1)
            return a[0];
        int sum = a[0];
        int max;
        for (int i = 0; i < a.length - 1; i++) {
            max = a[i];//从a[i]往后遍历，相加之后和sum比较
            for (int j = i + 1; j < a.length; j++) {
                sum = sum + a[j];
                if (sum > max) {
                    max = sum;
                }
            }
        }
        return max;//返回错误？？
    }

    public static void main(String[] args) {
        int array[] = {-1, 5, 10, -2, 9};
        System.out.println("子数组最大和：");
        maxSum(array);
        System.out.println(Arrays.toString(array));
    }
}

**3.交换两个数
**
//交换两个数

import java.util.Arrays;
import java.util.Scanner;

public class ExchangeNumber {
public static void exchange(int a[]){
int t;
t = a[0];
a[0] = a[1];
a[1] = t;
System.out.println(Arrays.toString(a));
}
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.println(“输入两个数字：”);
int[] array = new int[2];
array[0] = scan.nextInt();
array[1] = scan.nextInt();
exchange(array);
}
}
4.逆置数组

//逆置数组
import java.util.Scanner;
import java.util.Arrays;

public class InverseArray {
    //逆置
    public static void inverse(int a[]){
        int t;//设中间变量t，方便数组元素间的转换
        for(int i = 0;i <= a.length / 2;i ++){//循环5次
            t = a[i];
            a[i] = a[a.length - 1 - i];//对应元素的下标和是数组长度减一
            a[a.length - 1 - i] = t;
        }
        System.out.println(Arrays.toString(a));//输出逆置后的数组
    }
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        System.out.println("输入一个长度为10的一维数组：");
        int[] array = new int[10];
        for(int i = 0;i < 10;i ++){
            array[i] = scan.nextInt();
        }

//        int array[] = {0,1,2,3,4,5,6,7,8,9};
        inverse(array);
    }
}