一维数组中的一些常用方法（打印数组、逆序、选择排序、冒泡排序、二分法查找、普通查找）

```
package sunlei.util;
/**
 * 本类中包括一些数组操作中常用的方法。
 * 包括：打印数组，逆序，选择排序，冒泡排序，二分法（折半）查找，普通查找
 * 如果有不对的请多指正，谢谢
 */
public class ArrayUtil {

	public static void main(String[] args) {
		
		int[] arr1 = {1,22,-56,89,5,-7,98};
		int[] arr2 = {-66,7,85,23,-42,79,-16,35};
		int[] arr3 = {0,22,45,69,20,-38,92,-88,71};
		int[] arr4 = {32,65,77,90,-12,26,-8,44,-57};
		int[] arr5 = {22,55,8,-34,-77,69,-83,46,-95};
		
		System.out.println("----------逆序----------");
		printArray(arr1);//调用打印数组方法
		reverse(arr1);//调用逆序排序方法
		printArray(arr1);//调用打印数组方法

		System.out.println("----------选择排序----------");
		printArray(arr2);//调用打印数组方法
		selectSort(arr2);//调用选择排序
		printArray(arr2);//调用打印数组方法
		
		System.out.println("----------冒泡排序----------");
		printArray(arr3);//调用打印数组方法
		bubbleSort(arr3);//调用冒泡排序
		printArray(arr3);//调用打印数组方法
		
		System.out.println("----------二分法查找----------");
		bubbleSort(arr4);//调用冒泡排序
		printArray(arr4);//调用打印数组方法
		int key1 = binarySearch(arr4,8);//调用二分法查找8在arr4中的索引
		System.out.println(key1);
		
		System.out.println("----------普通查找----------");
		printArray(arr5);//调用打印数组方法
		int key2 = search(arr5,99);//调用选择排序,查找99在数组arr5中的索引
		System.out.println(key2);
		
	}
	
	/**
	 * 按[1,22,-56,89,5,-7,98]的格式打印数组（有中括号，有元素，有逗号）
	 * 思想是：数组遍历，其中加入相应的符号即可
	 */
	public static void printArray(int[] arr) {
		
		for(int i = 0; i < arr.length; i++) {
			if(i == 0) {
				System.out.print("["+arr[i]+",");
			}else if(i == arr.length-1) {
				System.out.print(arr[i]+"]");
			}else{
				System.out.print(arr[i]+",");
			}
		}
		System.out.println();
	}
	
	/**
	 * 数组逆序排序（数组下标逆序）
	 * 思想是：数组下标互换，当开始的下标等于结束的下标时互不互换下标都没有关系，
	 * 当开始的下标大于结束的下标时结束循环（此处是大于等于结束循环）
	 */
	public static void reverse(int[] arr) {
		
		for(int start = 0, end = arr.length-1; start < end; start++,end--) {
				int temp = arr[start];
				arr[start] = arr[end];
				arr[end] = temp;
		}
	}
	
	/**
	 * 选择排序（数组元素从小到大排序）
	 * 思想是：第一个数组元素与该元素后面的数组元素依次比较直到数组的最后一个元素，
	 * 把小的值放在第一个数组元素中，数组循环一圈后，则把最小元素值互换到了第一个元素中；
	 * 数组再循环一圈后，把第二小的元素值互换到了第二个元素中。
	 * 按照这种方式，数组循环多次以后，就完成了数组元素的排序。
	 */
	public static void selectSort(int[] arr) {
		
		for(int i = 0; i < arr.length-1; i++){//最后一个不用比，所以是arr.length-1
			//比如arr.length=4时：arr[0]分别和arr[1]、arr[2]、arr[3]比较，所以是arr.length
			for(int j = i+1; j  arr[j]) {
					int temp = arr[i];
					arr[i] = arr[j];
					arr[j] = temp;
				}
			}
		}
	}
	
	/**
	 * 冒泡排序（数组元素从小到大排序）
	 * 思想是：相邻的元素值依次比较，把大的值放后面的元素中，
	 * 数组循环一圈后，则把最大元素值互换到了最后一个元素中；
	 * 数组再循环一圈后，把第二大的元素值互换到了倒数第二个元素中。
	 * 按照这种方式，数组循环多次以后，就完成了数组元素的排序。
	 */
	public static void bubbleSort(int[] arr) {
		
		for(int i = 0; i < arr.length-1; i++) {
			for(int j = 0; j  arr[j+1]) {
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
					
				}
			}
		}
	}
	
	/**
	 * 二分法查找（也叫折半查找）（必须建立在排好序的基础上）
	 * 思想是：用数组最中间位置的元素值与要查找的指定数值进行比较，
	 * 若相等，则返回中间元素值的索引，若不相等，则根据比较的结果，缩小查询范围为上次数组查询范围的一半；
	 * 再根据新的查询范围，更新最中间元素位置，然后使用中间元素值与要查找的指定数值进行比较，
	 * 若结果相等，返回中间元素值的索引，
	 * 若比较结果不相等，继续缩小查询范围为上次数组查询范围的一半，更新最中间元素位置，继续比较。
	 * 当查询范围缩小到小于0个元素时，则表明指定数值没有查询到，返回索引值-1。
	 */
	public static int binarySearch(int[] arr, int value) {

		 int min = 0 ;
		 int max = arr.length -1 ;
		 int mid = 0;
		 
		 //循环折半,条件 min<=max
		 while( min <= max){
			 
			 mid = (min+max)/2;

			 if(value > arr[mid]){
				 min = mid + 1;
			 }else if (value < arr[mid]){
				 max = mid - 1;
			 }else{
				 return mid;
			 }
		 }
		 return -1;
	 }
	
	/**
	 * 普通查找
	 * 思想是：遍历数组中的元素，与要查找的值进行比较，若相等则返回该元素在数组中的下标，若不等则返回-1。
	 */
	public static int search(int[] arr,int value) {
		for(int i = 0; i < arr.length; i++) {
			if(arr[i] == value) {
				return i;
			}
		}
		return -1;
	}
}

```