javaSE(从0开始)day05

       //break 跳出循环
        //continue 跳过本次循环 ，继续执行后面的循
        for (int i = 0; ; i++) {
            System.out.println(i);
            if (i == 10) {
                break;
            }
        }
        System.out.println("end");

2、continue:

结束本次循环，进入下一次循环

 for (int i = 0; ; i++) {
            if (i % 3 == 0) {
                continue;//跳过3的倍数
            }
            System.out.println(i);
        }

二、数组的遍历：

遍历数组可以使用for循环，for循环可以访问数组索引，for each循环直接迭代每个数组元素，但无法获取索引
使用Arrays.toString()可以快速获取数组内容
二维数组就是"数组的数组" : 保存N个一维数组
二维数组的每个数组元素长度都不要求相同
打印二维数组可以使用Arrays.deepToString()
访问二维数组的一个元素使用array[row][col]

1、`for`循环遍历数组：

for(int i=0;i<数组名length；i++){

System.out.println(数组名[i])

}

int[] numbers={2,4,8,3,7,,9}
// 正序遍历:从头元素向后遍历
for (int i = 0; i < numbers.length; i++) {
}
// 逆序遍历:从尾元素向前遍历
for (int i = numbers.length - 1; i >= 0; i--) {
}
//	从中间元素向前遍历
for (int i = numbers.length / 2; i >= 0; i--) {
}
//	从中间元素向后遍历
for (int i = numbers.length / 2; i < numbers.length; i++) {
}

2、foreach 遍历数组：

for(数组类型变量名：数组名){

System.out.println(变量名)

}

        int[] ns = { 1, 4, 9, 16, 25 };
        for (int n : ns) {
            System.out.println(n);
        }

3、Arrays.toString(数组名)遍历：

通过导入Arrays包,使用Java标准库中的Arrays.toString()，进行快速打印数组内容：

String[] cityArray = { "郑州", "广州", "苏州", "赣州", "儋州" };
double[] dataArray = { 3.4, 7.8, 4.7, 8.9 };
int[] numberArray1 = { 4, 11, 6, 8, 9, 23 };
int[] numberArray2 = { 4, 11, 6, 8, 9, 23 };

// 打印数组内容：
       // Arrays类的toString()方法作用：将字符串数组中的所有元素，拼接成一个完整字符串
String str1 = Arrays.toString(cityArray);
       System.out.println(str1);

       System.out.println(Arrays.toString(dataArray));
       System.out.println(Arrays.toString(numberArray1));
       System.out.println(Arrays.toString(numberArray2));

三、数组排序：

常用的排序算法有冒泡排序、插入排序和快速排序等
冒泡排序使用两层for循环实现排序
交换两个变量的值需要借助一个临时变量
可以直接使用Java标准库提供的Arrays.sort()进行排序
对数组排序会直接修改数组本身

1、冒泡排序：

（1）比较相邻的元素。如果第一个比第二个大，就交换位置。

（2）对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

（3）针对所有的元素重复以上的步骤，除了最后一个元素。

（4）持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

（5）冒泡排序的特点：

每一轮循环后，最大的一个数被交换到末尾，因此，下一轮循环就可以“排除”最后的数，每一轮循环都比上一轮循环的结束位置靠前一位。

       int[] ns = { 5, 2, 6, 7, 8, 3, 1, 9, 4 };
        
       // 排序前
       System.out.println("排序前:" + Arrays.toString(ns));
        
       for (int i = 0 ,n = ns.length; i < n - 1; i++) {
           for (int k = 0; k < n - 1 - i ; k++) {
               if (ns[k] > ns[k+1]) {
                   // 交换ns[k]和ns[k+1]:
                   int tmp = ns[k];
                   ns[k] = ns[k+1];
                   ns[k+1] = tmp;
               }
           }
       }
        
       // 排序后
       System.out.println("排序后:" + Arrays.toString(ns));

2、使用Arrays工具类排序：

Java的标准库已经内置了排序功能，我们只需要调用Arrays.sort()就可以排序：

int[] ns = { 28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };

// 排序前
System.out.println("排序前:" + Arrays.toString(ns));

// 排序
Arrays.sort(ns);

// 排序后
System.out.println("排序后:" + Arrays.toString(ns));

四、数组元素的查找

查找数组中的指定元素分为两种情况：无序数组查找和有序数组查找
无序数组可以通过遍历数组或Arrays工具类两种方式查找指定元素
有序数组可以通过二分查找算法查找指定元素

1、无需数组查找元素：

在一个无序数组中，如果需要进行指定元素的查找，可以通过循环遍历或Arrays工具类两种方式进行查找。

（1）遍历查找：

遍历的方式进行查找：可以通过对该无序数组进行遍历，将数组中的每个元素与指定元素进行比较，从而确定该数组中是否存在指定元素。

int[] array = { 28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };
int target = 36; // 目标元素
int index = -1;  // 目标元素下标，默认为-1，代表不存在

// 遍历查找
for (int i = 0; i < array.length; i++) {
    if(array[i] == target) {
        index = i;
        break;
    }
}
System.out.printf("目标值%d在数组中的下标为：%d",target,index);

（2）双指针遍历查找：

双指针遍历的方式进行查找：通过两个下标，分别从数组头部和尾部，同时对该无序数组进行遍历，将数组中的每个元素与指定元素进行比较，从而确定该数组中是否存在指定元素。

String[] singerArray = { "李荣浩", "盘尼西林", "王菲", "王贰浪", "鹿先森乐队", "孙燕姿", "G.E.M.邓紫棋", "方大同", "品冠儿子" };

String target = "方大同";
int index = -1;

// 双指针查找
for (int i = 0, k = singerArray.length - 1; i <= k; i++, k--) {
    // 字符串等值判断使用equals()方法
    if(target.equals(singerArray[i])) {
        index = i;
        break;
    }
	
    // 字符串等值判断使用equals()方法
    if(target.equals(singerArray[k])) {
        index = k;
        break;
    }
}

（3）Arrays工具类的binarySearch()方法：

除了遍历查找，还可以通过调用Arrays.binarySearch()的方法，进行查找：由于该方法是基于二分查找法实现，数组必须处于有序状态。所以，需要先对数组进行排序，然后再通过Arrays.binarySearch()进行查找。

	    int[] array = { 28, 12, 89, 73, 65, 18, 96, 50, 8, 36 };
		int target = 36; // 目标元素
		
		// 先排序
		Arrays.sort(array);
		
		// 再查找
		int index = Arrays.binarySearch(array, target);
        
		System.out.printf("目标值%d在数组中的下标为：%d",target,index);

2、二分查找元素：

（1）二分查找过程：

（1.1）判断

判断搜索数组的“中位元素”与要查找的“目标元素”是否相等。

如果相等，代表查找成功，退出算法；

如果不相等，继续比较“中位元素”与要查找的“目标元素”的大小关系；

如果“中位元素”大于“目标元素”，当前数组的前半部分作为新的搜索数组，因为后半部分的所有元素都大于“目标元素”，它们全都被排除了。

如果“中位元素”小于“目标元素”，当前数组的后半部分作为新的搜索数组，因为前半部分的所有元素都小于“目标元素”，它们全都被排除了。

（1.2）在新的搜索数组上，重新开始第1步的工作。

int[] array = { 1,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59 };

int target = 37; // 目标元素
       int index = -1; // 目标元素的下标，默认为-1，代表不存在

       // low和high分别代表搜索数组的开始下标与结束下标
       // 默认搜索数组是整个数组
       int low = 0, high = array.length - 1;

       while (low <= high) {
           // 计算"中位元素"的下标
           int mid = (high + low) / 2;

           if (array[mid] == target) {
               // 如果"中位元素"等于"目标元素"，查找成功，退出
               index = mid;
               break;
           } else if (array[mid] < target) {
               // 如果"中位元素"小于"目标元素"，当前数组的后半部分作为新的搜索数组
               low = mid + 1;
           } else if (array[mid] > target) {
               // 如果"中位元素"大于"目标元素"，当前数组的前半部分作为新的搜索数组
               high = mid - 1;
           }
       }