JavaSe基础XX03——数组

数组定义的格式1：需要一个容器，但不明确容器的具体数据。

int[] arr = new int[3];

数组定义的格式2：需要一个容器，存储已知具体数据。

int[] arr = new int[]{1,2,3,4,5,6};

数组定义的格式3：

int[] arr = {1,2,3,4,5,6}; //静态初始化

循环遍历数组时，推荐使用for，而不用while——[涉及到变量的生命周期]

arr.length

获取数组中最值：

1. 初始化数值
2. 初始化角标

public class TestArray {

public static void main(String[] args) {
int[] arr = { 1, 23, 4, 57, 656, 8678, 542, -32345, 3534 };

int max = getMax(arr);
System.out.println("max = " + max);

int max2 = getMax2(arr);
System.out.println("max2 = " + max2);
}

public static int getMax(int[] arr) {
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
return max;
}

public static int getMax2(int[] arr) {
int max = 0;
for (int i = 1; i < arr.length; i++) {
if (arr[i] > arr[max]) {
max = i;
}
}
return arr[max];
}
}

数组的排序：

方法① 选择排序：

public class TestArray {

public static void main(String[] args) {
int[] arr = { 1, 23, 4, 57, 656, 8678, 542, -32345, 3534 };
int[] arr2 = selectSort(arr);
for (int i = 0; i < arr2.length; i++) {
System.out.println(arr2[i]);
}
// 增强循环
System.out.println("---增强for循环---");
for (int n : arr2) {
System.out.println(n);
}
}

public static int[] selectSort(int[] arr) {
int temp = 0;
for (int i = 0; i < arr.length - 1; i++) {
for (int j = i + 1; j < arr.length; j++) {
if (arr[i] > arr[j]) {
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}

}
return arr;
}
}

增强for循环参考：http://blog.sina.com.cn/s/blog_4ae13e550100adx6.html

注意问题：这种调用函数时，传的其实是数组的地址，因此，我们可以将返回值设置为void，见下面程序：

public class TestArray {

public static void main(String[] args) {
int[] arr = { 1, 23, 4, 57, 656, 8678, 542, -32345, 3534 };
selectSort(arr);
System.out.println("---增强for循环---");
for (int n : arr) {
System.out.println(n);
}
}

public static void selectSort(int[] arr) {
int temp = 0;
for (int i = 0; i < arr.length - 1; i++) {
for (int j = i + 1; j < arr.length; j++) {
if (arr[i] > arr[j]) {
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}

}
}
}

方法② 冒泡排序

public class TestArray {

public static void printArray(int[] arr) {
for (int n : arr) {
System.out.print(n + ",");
}
System.out.println();
}

public static void main(String[] args) {
int[] arr = { 34, 19, 11, 109, 3, 56 };
printArray(arr);
bubbleSort(arr);
printArray(arr);
bubbleSort2(arr);
printArray(arr);

}

public static void bubbleSort(int[] arr) {
System.out.println("-----------------");
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {// 内循环-1是为了防止越界，
if (arr[j] > arr[j + 1]) { // -i是外循环增加一次，内循环参数与比较的元素个数递减。
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}

public static void bubbleSort2(int[] arr) {
System.out.println("-----------------");
for (int i = arr.length - 1; i > 0; i--) {
for (int j = 0; j < i; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
}

Java给我们封装了排序函数：

<pre name="code" class="java">import java.util.*;
Arrays.sort(arr);

希尔排序是七种循环中最快的。
数组常见操作——交换

public static void main(String[] args) {
int[] arr = { 34, 19, 11, 109, 3, 56 };
printArray(arr);
bubbleSort(arr);
printArray(arr);
//		bubbleSort2(arr);
//		printArray(arr);

//		Arrays.sort(arr);
//		printArray(arr);
}

public static void  swap(int[] arr,int a,int b){
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
System.out.println("swap");
}
public static void bubbleSort(int[] arr) {
System.out.println("-----------------");
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {// 内循环-1是为了防止越界，
if (arr[j] > arr[j + 1]) { // -i是外循环增加一次，内循环参数与比较的元素个数递减。
swap(arr,j,j+1);
}
}
}
}
}

上面这个方法，运行结果不对，回头在看看。。。

排序的性能：

选择排序中，为了确定第一位为最小值，需要3次的换位，效率太低。



所以，我们对这种方法做了改进，



这样的话，我们交换了一次就达到了目的。而且num、index是在栈内存中，也减少了直接对数组的换位操作，节省了内存。

代码如下：

public class TestArray {

public static void printArray(int[] arr) {
for (int n : arr) {
System.out.print(n + ",");
}
System.out.println();
}

public static void main(String[] args) {
int[] arr = { 34, 19, 11, 109, 3, 56 };
printArray(arr);
selectSort_2(arr);
printArray(arr);

}

private static void selectSort_2(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
int num = arr[i];
int index = i;
for (int j = i + 1; j < arr.length; j++) {
if (num > arr[j]) {
num = arr[j];
index = j;
}
}
swap(arr, i, index);
}
}

public static void swap(int[] arr, int a, int b) {
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}

}

*元素越多，效果越明显。

数组相关操作——查找。

某个数的位置。

①基本查找：

public class TestArray {

public static void main(String[] args) {
int[] arr = { 34, 19, 11, 109, 3, 56 };
int index = getIndex(arr, 14);
System.out.println("index = " + index);
}

public static int getIndex(int arr[], int key) {
System.out.println("find...");
for (int i = 0; i < arr.length; i++) {
if (arr[i] == key) {
return i;
}
}
System.out.println("not found");
return -1;
}
}

②折半查找

对上面的方法优化——“猜价格”

前提：被查找的数组必须是有序的



代码如下：

package testarray;

import java.util.Arrays;

public class TestArray {

public static void main(String[] args) {
int[] arr = { 34, 19, 11, 109, 3, 56, 90, 67 };
// 排序方法1.系统给定的Arrays
// Arrays.sort(arr);
// printArray(arr);
// 方法2.选择排序
// selectSort(arr);
// printArray(arr);
// 方法3.选择排序的优化
// selectSort_2(arr);
printArray(arr);
// 方法4.冒泡排序
bubbleSort(arr);
printArray(arr);
// 接下来要对排好序的数组进行折半(二分)查找：
int index = binarySearch(arr, 67);
System.out.println("index = " + index);

}

private static int binarySearch(int[] arr, int key) {
int min = 0, max = arr.length - 1;
int mid = (min + max) / 2;
// 方法1
// while (max > mid) {
//
// if (arr[mid] == key) {
// return mid;
// }
// if (key > arr[mid]) {
// min = mid + 1;// 注意一定要加上1，要不然是死循环
// mid = (min + max) / 2;
// }
// if (key < arr[mid]) {
// max = mid - 1;// 注意一定要减去1，要不然是死循环
// mid = (min + max) / 2;
// }
// }
// System.out.println("not found...");
// return -1;

// 方法2
// while (arr[mid] != key) {
// if (key > arr[mid])
// min = mid + 1;
// else if (key < arr[mid])
// max = mid - 1;
// if (max < mid)
// return -1;
// mid = (min + max) / 2;
// }
// return mid;

// 方法3
while (min < max) {

if (key > arr[mid])
min = mid + 1;
else if (key < arr[mid])
max = mid - 1;
else
return mid;
mid = (max + min) >> 1;// 相当于mid = (min + max) / 2;但速度比较快
}
return -1;
}

private static void bubbleSort(int[] arr) {
for (int i = arr.length - 1; i > 0; i--) {
for (int j = 0; j < i; j++) {
if (arr[i] < arr[j])
swap(arr, i, j);
}
}
}

private static void selectSort_2(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
int num = arr[i];
int index = i;
for (int j = i + 1; j < arr.length; j++) {
if (num > arr[j]) {
num = arr[j];
index = j;
}
}
swap(arr, i, index);// 这里也可以写作swap(arr,index,i);
}
}

private static void selectSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = i + 1; j < arr.length; j++) {
if (arr[i] > arr[j])
swap(arr, i, j);
}
}
}

private static void swap(int[] arr, int i, int j) {
int temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
}

private static void printArray(int[] arr) {
for (int n : arr) {
System.out.print(n + ",");
}
System.out.println();
}
}

折半查找练习：

给定一个有序数组，如果往该数组存储一个数，并保证这个数组还是有序的，如何获取这个元素的脚标？

package testarray;

import java.util.Arrays;

public class TestArray {

public static void main(String[] args) {
int[] arr = { 34, 19, 11, 109, 3, 56, 90, 67 };
// 排序方法1.系统给定的Arrays
// Arrays.sort(arr);
// printArray(arr);
// 方法2.选择排序
// selectSort(arr);
// printArray(arr);
// 方法3.选择排序的优化
// selectSort_2(arr);
printArray(arr);
// 方法4.冒泡排序
bubbleSort(arr);
printArray(arr);
// 接下来要对排好序的数组进行折半(二分)查找：
int index = binarySearch(arr,4);
System.out.println("index = " + index);

}

private static int binarySearch(int[] arr, int key) {
//		if(key < arr[0])
//			return 0;
//		if(key>arr[arr.length-1])
//			return arr.length;
//实际上，上面的语句不用执行，也是能得到相应的结果的。
int min = 0, max = arr.length - 1;
int mid = (min + max) / 2;
// 方法1
// while (max > mid) {
//
// if (arr[mid] == key) {
// return mid;
// }
// if (key > arr[mid]) {
// min = mid + 1;// 注意一定要加上1，要不然是死循环
// mid = (min + max) / 2;
// }
// if (key < arr[mid]) {
// max = mid - 1;// 注意一定要减去1，要不然是死循环
// mid = (min + max) / 2;
// }
// }
// System.out.println("not found...");
// return -1;

// 方法2
// while (arr[mid] != key) {
// if (key > arr[mid])
// min = mid + 1;
// else if (key < arr[mid])
// max = mid - 1;
// if (max < mid)
// return -1;
// mid = (min + max) / 2;
// }
// return mid;

// 方法3
while (min <= max) {

if (key > arr[mid])
min = mid + 1;
else if (key < arr[mid])
max = mid - 1;
else
return mid;
mid = (max + min) >> 1;// 相当于mid = (min + max) / 2;但速度比较快
}
return min;//之前返回的是-1.现在只要改为min，观察上面的图就知道了。
}

private static void bubbleSort(int[] arr) {
for (int i = arr.length - 1; i > 0; i--) {
for (int j = 0; j < i; j++) {
if (arr[i] < arr[j])
swap(arr, i, j);
}
}
}

private static void selectSort_2(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
int num = arr[i];
int index = i;
for (int j = i + 1; j < arr.length; j++) {
if (num > arr[j]) {
num = arr[j];
index = j;
}
}
swap(arr, i, index);// 这里也可以写作swap(arr,index,i);
}
}

private static void selectSort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = i + 1; j < arr.length; j++) {
if (arr[i] > arr[j])
swap(arr, i, j);
}
}
}

private static void swap(int[] arr, int i, int j) {
int temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
}

private static void printArray(int[] arr) {
for (int n : arr) {
System.out.print(n + ",");
}
System.out.println();
}
}

但是实际开发中，也不需要我们做，因为有下面的函数语句：

int index = Arrays.binarySearch(arr,45);
System.out.println("index = " + index);

注：怎么结果是负数呢？ 因为：返回的负数也是插入点，

Arrays.binarySearch(arr,45);//这个方法，如果没有该值，就会返回负数。以负数来表示。 等价于：-min-1。为什么要减一。思考。[不存在，返回-插入点-1]

javascript就没有折半查找。

应用：

1.获取一个整数的16进制

为什么要有16进制，因为二进制在内存中存放长度太长了。



&15--->向右移

public class TestArray {

public static void main(String[] args) {
toHex(60);
}

private static void toHex(int i) {
int n1 = i & 15;
System.out.println("n1 = " + n1);
i = i >>> 4;
int n2 = i & 15;
System.out.println("n2 = " + n2);
}

}

如果大于60呢？

public class TestArray {

public static void main(String[] args) {
toHex(60);
}

private static void toHex(int i) {
for (int x = 0; x < 8; x++) {
int n1 = i & 15;
System.out.println(n1);
i = i >>> 4;
}
}
}

完善：

public class TestArray {

public static void main(String[] args) {
toHex(60);
}

private static void toHex(int i) {
for (int x = 0; x < 8; x++) {
int n1 = i & 15;
if (n1 > 9){
int temp = n1-10;
char c = (char) ('A'+temp);
System.out.print(c);
}
else
System.out.print(n1);
i = i >>> 4;
}
}
}

结果是：C3000000

改良：[什么时候使用数组呢]——如果数据出现了对应关系，而且对应关系的一方是有序的数字编号，并作为脚标使用，这个时候就要使用数组了。

*发现了对应关系，但不是有些的数字编号，这个时候可以使用map集合。

就可以将这些数据存储在数组中，根据运算结果作为脚标直接找到数组对应数据，这种方法叫做：查表法。

public class TestArray {

public static void main(String[] args) {
toHex(60);
}

private static void toHex(int i) {
char[] chs = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A',
'B', 'C', 'D', 'E', 'F' };
for (int x = 0; x < 8; x++) {
int n1 = i & 15;
System.out.print(chs[n1]);
i = i >>> 4;
}
}
}

结果：C3000000

继续优化：

public class TestArray {

public static void main(String[] args) {
toHex(60);
}

private static void toHex(int i) {
char[] chs = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A',
'B', 'C', 'D', 'E', 'F' };
char[] arr = new char[8];
int pos = 0;
while(i != 0){
int temp = i & 15;
arr[pos++] = chs[temp];
i = i>>>4;
}
System.out.println("pos = "+pos);
for(char c:arr){
System.out.print(c+",");
}
}
}

结果：

pos = 2

C,3, //注意其实是null

继续修改，使得输出方式是3c

public class TestArray {

public static void main(String[] args) {
toHex(60);
}

private static void toHex(int i) {
char[] chs = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A',
'B', 'C', 'D', 'E', 'F' };
char[] arr = new char[8];
int pos = arr.length;
while(i != 0){
int temp = i & 15;
arr[--pos] = chs[temp];
i = i>>>4;
}
System.out.println("pos = "+pos);
for(char c:arr){
System.out.print(c);
}
}
}

输出结果：

pos = 6

3C

这个时候，还需要对toHex(0)，这种情况进行预判：

if(i == 0)
{
System.out.println("0");
return ;
}

【其他二进制、八进制都是一样，只是&的是2、7，移位是1、3位，容器改成char[32]】

其实系统也给了我们对应的系统方法：

System.out.println(Integer.toBinaryString(67));
System.out.println(Integer.toHexString(67));
System.out.println(Integer.toOctalString(67));

总结：三个函数sort、binarySearch、toBinaryString；

查表法练习：

1.星期

public class TestArray {

public static void main(String[] args) {

String s = getWeek(4);
System.out.println(s);
}

private static String getWeek(int i) {
if (i > 7)
return "error";
String[] s = { "", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日" };
return s[i];
}
}