for倒序 java java倒序遍历数组

1，数组的倒序遍历
数组中第1个元素下标：0
数组中最后1个元素下标：arr.length - 1
数组的倒序遍历就是使用for循环从最后1个元素往前遍历，直到第1个元素

public void test1() {
	int [] arr = {1,2,5,8,92,13};
	//数组中最后1个元素的下标 arr.length -1
	for (int i = arr.length -1; i >= 0; i--) {
        //System.out.print("i " + i + " value " + arr[i] + " ");
		System.out.print(arr[i] + " ");
	}
}

2，数组中元素整体移动，左移或者右移
方式一：关键通过整体移动一位的方式实现，移动多位就多次调用移动一位的方法
方式二：通过数组的拆分，调整前后两部分的顺序之后，合并得到移动后的数组（如果移动次数大于数组长度，先将移动次数取余）

public void test2() {
	int [] arr = {1,2,5,8,92,13};
	//{2,5,8,92,13,1} 左移一位
	//方式一：通过多次移动一位
	//左移3位，左移n位
	int result[] = arr;
	for (int i = 0; i < 3; i++) {
		result = test2Child(result);
	}
	System.out.println(Arrays.toString(result));
	
	//方式2：截取重新拼接的方式；
	int leftArr[] = Arrays.copyOf(arr, 3); //{1,2,5}
	int rightArr[] = Arrays.copyOfRange(arr, 3, arr.length); //{8,92,13}
	//拼接数组
	int result [] = new int [leftArr.length + rightArr.length];
	System.arraycopy(rightArr, 0, result, 0, rightArr.length);
	//{8,92,13,0,0,0}
	System.arraycopy(leftArr, 0, result, rightArr.length, leftArr.length);
	System.out.println(Arrays.toString(result));
}

//数组左移一位的方法
public int [] test2Child(int arr[]) {
	int tempArr[] = new int[arr.length];
	for (int i = 0; i < tempArr.length -1; i++) {
		tempArr[i] = arr[i + 1];
	}
	tempArr[tempArr.length -1] = arr[0];
	return tempArr;
}

3，判断数组中是否包含某个元素
方式一：直接通过循环去判断
方式二：先将数组进行排序，然后使用Arrays.binarySearch方法进行二分查找
注意：如果确定只需要排序一次，或者说已经排好序；会进行多次的查找，那么使用二分查找会更快

public void test3() {
	int [] arr = {1,2,5,8,92,13};
	int num = 10;
	boolean isContain = false;
	//方式一：循环去判断
	for (int i = 0; i < arr.length; i++) {
		if (num == arr[i]) {
			isContain = true;
			break;
		}
	}
	//方式二：先排序，然后通过2分查找法判断（只需要排序1次，但是会查找多次）
	Arrays.sort(arr);
	int index = Arrays.binarySearch(arr, num);
	isContain = index >= 0;
	
	if (isContain) {
		System.out.println("包含");
	}
}

4，获取数组中连续区间的元素
数组结尾元素不够从数组前面补，循环取元素

/**
 * 4,连续一段区间数组循环
 * {1,2,5,8,92,13} 连续3个数
 * 1,2,5
 * 2,5,8
 * 5,8,92
 * 8,92,13
 * 92,13,1
 * 13,1,2
 * 
 * 13, n1, n2
 * n1下标 = 6%6 = 0 , 对应值为1
 * n2下标 = 7%6 = 1 , 对应值为2 
 */
public void test4() {
	int arr[] = {1,2,5,8,92,13};
	int num = 4; //连续的长度为4
	for (int i = 0; i < arr.length; i++) {
		for (int j = i; j < i + num; j++) {
			int temp = j;
			if (temp >= arr.length) {
				temp = temp % arr.length;
			}
			System.out.print(arr[temp] + " ");
		}
		System.out.println();
	}
}

5，用数组表示连续区间，判断两个区间是否相交

例如：{4,9} 和{3,5} 就是两个相交区间；{3,5} 和 {8,10}是两个不相交的区间

思路：获得两个区间起始值的最大值maxStart， 终点值的最小值minEnd, 如果minEnd >= maxStart，那么就表示两个区间相交
合并两个相交的区间：new int []{minStart, maxEnd}

public void test5() {
	int arr1 [] = {2,7};
	int arr2 [] = {9,10};
	//100
	int result[] = test5Child(arr1, arr2);
	if (result != null) {
		System.out.println(Arrays.toString(result));
	} else {
		System.out.println("两个区间不相交");
	}
}

public int[] test5Child(int arr1[], int arr2[]) {
	int maxStart = Math.max(arr1[0], arr2[0]); //得到最大的起点
	int minEnd = Math.min(arr1[1], arr2[1]); //得到最小的终点
	if (maxStart <= minEnd) {
		return new int[] {Math.min(arr1[0], arr2[0]), Math.max(arr1[1],	arr2[1])};
	}
	return null;
}

6，多种方式遍历二维数组(矩阵)中的元素

按照指定的要求遍历矩阵中的元素：指定的起始点，指定的遍历方向

arr.length --行数
 arr[i].length --列数
 arr[row][column]  --row行, column列对应的元素

public void test6() {
	int [][] arr = {
			{1,2,3},
			{4,5,6},
			{7,8,9}
	};
	
	//左-右；上下
	for (int i = 0; i < arr.length; i++) {
		//输入第i行的值
		for (int j = 0; j < arr[i].length; j++) {
			System.out.print(arr[i][j] + " ");
		}
	}
	
	System.out.println();
	System.out.println("----------上-下；左-右-------------");
	//上-下；左-右
	for (int i = 0; i < arr[0].length; i++) {
		//输出第i列的值
		for (int j = 0; j < arr.length; j++) {
			System.out.print(arr[j][i] + " ");
		}
	}
	
	System.out.println();
	System.out.println("----------只拿2,5,8这一列-------------");
	//只拿2,5,8这一列
	for (int j = 0; j < arr.length; j++) {
		System.out.print(arr[j][1] + " ");
	}		
}