数组的各种常用的方法

```

public class ArrayUtil {

/**
* 将参数数组进行倒序(可以创建一个临时的数组对象)
* 
* @param arr
*/
public int[] reverse1(int[] arr) {
// 创建一个和参数数组相同长度的数组对象
int[] temp = new int[arr.length];

// i控制的是tepm数组的下标(从0开始)
// j控制的是arr数组的下标(从最后一个下标开始)
for (int i = 0, j = arr.length - 1; i < temp.length; i++, j--) {
temp[i] = arr[j];
}

return temp;
}

/**
* 将参数数组进行倒序(不能创建临时数组对象,就在原来的数组对象上进行倒序操作)
* 
* @param arr
*/
public void reverse2(int[] arr) {
// i既控制的是数组的下标,又控制的是循环的次数
for (int i = 0; i < arr.length / 2; i++) {
int temp = arr[i];
arr[i] = arr[arr.length - 1 - i];
arr[arr.length - 1 - i] = temp;
}
}

/**
* 把数组中的元素组织到一个String中并返回;数据的格式:[1,2,3,4,5]
* 
* @param arr
* @return
*/
public String toString(int[] arr) {
String str = "[";

for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
str += arr[i];
} else {
str += arr[i] + " , ";
}
}

str += "]";
return str;
}

/**
* 对参数数组进行排序(采用冒泡法)
* 
* @param arr
*/
public void sort1(int[] arr) {
// 6个元素的数组,要比较5轮
// 外面这个循环控制的是比较的轮数
for (int i = arr.length - 1; i > 0; i--) {
// 控制的是每轮比较的次数
for (int j = 0; j < i; j++) {
if (arr[j + 1] < arr[j]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}

/**
* 对参数数组进行排序(选择排序)
* 
* @param arr
*/
public void sort2(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
int min = i;
for (int j = i + 1; j < arr.length; j++) {
if (arr[min] > arr[j]) {
min = j;
}
}

if (min != i) {
int temp = arr[i];
arr[i] = arr[min];
arr[min] = temp;
}
}
}

/**
* 从数组中查询指定数据第一次出现的索引.通过变量数组来查询数据这种方式称为线性查询.线性查询适合于小型的数组
* 
* @param arr
* @param key
* @return 当要查询的数据不存在的时候,则返回-1;
*/
public int search(int[] arr, int key) {
for (int i = 0; i < arr.length; i++) {
if (arr[i] == key) {
return i;
}
}
return -1;
}

/**
* 使用二分法(折半法)从数组中查询指定数据第一次出现的索引.注意,二分法只能针对排序好的数组
* 
* @param arr
* @param key
* @return
*/
public int binarySearch(int[] arr, int key) {
int benginPost = 0;
int endPost = arr.length - 1;

while (benginPost <= endPost) {
int middlePost = (benginPost + endPost) / 2;

if (arr[middlePost] == key) {
return middlePost;
} else if (arr[middlePost] > key) {
endPost = middlePost - 1;
} else {
benginPost = middlePost + 1;
}
}

return -1;
}
}

```