数组使用
使用数组注意：
- 引用数据类型，数组中的数据类型必须一致
- 数组长度在程序运行期间不可改变
- 不能对布尔型数组排序
- 下标 index 必须是整数、整数表达式
常见问题：
- ArrayIndexOutOfBoundsException：下标越界
- NullPointerException：空指针异常
一维数组
数组初始化
动态初始化：指定长度
数据类型[] 数组名称 = new 数据类型[数组长度];
int[] array1 = new int[100];
double[] array2 = new double[100];
String[] array3 = new String[100];
int[] array8;
array8 = new int[5];
静态初始化：指定内容
数据类型[] 数组名称 = new 数据类型[]{参数1, 参数2, 参数3 ...};
int[] array4 = new int[]{ 2 ,15, 25 };
double[] array5 = new double[]{ 2.1, 12.2, 24.3 };
String[] array6 = new String[]{ "Hello", "World", "Java" };
int[] array7;
array7 = new int[]{ 11, 22, 33 };
int[] array4 = { 2 ,15, 25 };
double[] array5 = { 2.1, 12.2, 24.3 };
String[] array6 = { "Hello", "World", "Java" };
注意事项：
- 都可以拆分为两步，静态初始化的省略不能拆分
int[] array9;
array9 = { 11, 22, 33 }; //错误 - 动态初始化默认值：
整数：0 浮点：0.0 字符：'\u0000' 布尔：false 引用：null
数组遍历
for( int i=0; i<arr.length; i++ ) {
System.out.println(arr[i]);
}
for (int e:arr) {
System.out.println(e);
}
public static void printArray(int[] arr) {
for( int i=0; i<arr.length; i++ ) {
if( i == arr.length-1 ) {
System.out.print(arr[i]);
}else {
System.out.print(arr[i] + ", ");
}
}
}
最大最小
int max=arr[0], min=arr[0];
for( int i=0; i<arr.length; i++ ) {
if( arr[i] > max ) {
max = arr[i];
}
if( arr[i] < min ) {
min = arr[i];
}
}
//最大值
public static int getMax_ArrayElem(int[] arr) {
int max=arr[0];
for( int i=0; i<arr.length; i++ ) {
if( arr[i] > max ) {
max = arr[i];
}
}
return max;
}
//最小值
public static int getMin_ArrayElem(int[] arr) {
int min=arr[0];
for( int i=0; i<arr.length; i++ ) {
if( arr[i] < min ) {
min = arr[i];
}
}
return min;
}
数组逆序
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;
}
System.out.print("逆序：");
for( int i=0; i<arr.length; i++ ) {
System.out.print(arr[i]+" ");
}
public static void reverse(int[] arr) {
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;
}
}
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;
}
}
数组查值
//元素第一次出现的索引
int[] arr = {11, 22, 33, 44, 77, 66, 55};
int index = getIndex(arr, 77);
System.out.println("77第一次在数组中出现的索引："+index);
int index2 = getIndex2(arr, 44);
System.out.println("44第一次在数组中出现的索引："+index2);
public static int getIndex(int[] arr, int value) {
for( int i=0; i<arr.length; i++ ) {
if( arr[i]==value ) {
return i;
}
}
//是判断，结果就有可能为false
//如果找不到数据，则返回一个负数（-1）
return -1;
}
public static int getIndex(int[] arr, int value) {
int index = -1;
for( int i=0; i<arr.length; i++ ) {
if( arr[i]==value ) {
index = i;
break;
}
}
return index;
}
数组排序
插入排序
public class InsertSort {
public static void sort(int[] data) {
for (int i = 1; i < data.length; i++) {
for (int j = i; (j > 0) && (data[j] < data[j - 1]); j--) {
SortTest.swap(data, j, j - 1);
}
}
}
}
冒泡排序
public class BubbleSort {
public static void sort(int[] data) {
for (int i = 0; i < data.length - 1; i++) {
for (int j = 0; j < data.length - 1 - i; j++) {
if (data[j] > data[j + 1]) {
SortTest.swap(data, j, j + 1);
}
}
}
}
}
快速排序
public class QuickSort {
public static void sort(int[] data) {
quickSort(data, 0, data.length - 1);
}
private static void quickSort(int[] data, int i, int j) {
int pivotIndex = (i + j) / 2;
// swap
SortTest.swap(data, pivotIndex, j);
int k = partition(data, i - 1, j, data[j]);
SortTest.swap(data, k, j);
if ((k - i) > 1)
quickSort(data, i, k - 1);
if ((j - k) > 1)
quickSort(data, k + 1, j);
}
private static int partition(int[] data, int l, int r, int pivot) {
do {
while (data[++l] < pivot)
;
while ((r != 0) && data[--r] > pivot)
;
SortTest.swap(data, l, r);
} while (l < r);
SortTest.swap(data, l, r);
return l;
}
}
选择排序
public class SelectionSort {
public static void sort(int[] data) {
for (int x = 0; x < data.length - 1; x++) {
for (int y = x + 1; y < data.length; y++) {
if (data[y] < data[x]) {
SortTest.swap(data, x, y);
}
}
}
}
}
希尔排序
public class ShellSort {
public static void sort(int[] data) {
for (int i = data.length / 2; i > 2; i /= 2) {
for (int j = 0; j < i; j++) {
insertSort(data, j, i);
}
}
insertSort(data, 0, 1);
}
private static void insertSort(int[] data, int start, int inc) {
for (int i = start + inc; i < data.length; i += inc) {
for (int j = i; (j >= inc) && (data[j] < data[j - inc]); j -= inc) {
SortTest.swap(data, j, j - inc);
}
}
}
}
堆排序
public class HeapSort {
public static void sort(int[] data) {
MaxHeap h = new MaxHeap();
h.init(data);
for (int i = 0; i < data.length; i++)
h.remove();
System.arraycopy(h.queue, 1, data, 0, data.length);
}
private static class MaxHeap {
void init(int[] data) {
this.queue = new int[data.length + 1];
for (int i = 0; i < data.length; i++) {
queue[++size] = data[i];
fixUp(size);
}
}
private int size = 0;
private int[] queue;
public int get() {
return queue[1];
}
public void remove() {
SortTest.swap(queue, 1, size--);
fixDown(1);
}
private void fixDown(int k) {
int j;
while ((j = k << 1) <= size) {
if (j < size && queue[j] < queue[j + 1])
j++;
if (queue[k] > queue[j])
break;
SortTest.swap(queue, j, k);
k = j;
}
}
private void fixUp(int k) {
while (k > 1) {
int j = k >> 1;
if (queue[j] > queue[k])
break;
SortTest.swap(queue, j, k);
k = j;
}
}
}
}
归并排序
public class MergeSort {
public static void sort(int[] data) {
int[] temp = new int[data.length];
mergeSort(data, temp, 0, data.length - 1);
}
private static void mergeSort(int[] data, int[] temp, int l, int r) {
int mid = (l + r) / 2;
if (l == r)
return;
mergeSort(data, temp, l, mid);
mergeSort(data, temp, mid + 1, r);
for (int i = l; i <= r; i++) {
temp[i] = data[i];
}
int i1 = l;
int i2 = mid + 1;
for (int cur = l; cur <= r; cur++) {
if (i1 == mid + 1)
data[cur] = temp[i2++];
else if (i2 > r)
data[cur] = temp[i1++];
else if (temp[i1] < temp[i2])
data[cur] = temp[i1++];
else
data[cur] = temp[i2++];
}
}
}
二维数组
public static void printTwodimensionalArray(int[][] arr) {
for( int i=0; i<arr.length; i++ ) {
for( int j=0; j<arr[i].length; j++ ) {
System.out.print(arr[i][j]+" ");
}
System.out.println();
}
}
数组初始化
数据类型[][] 数组名 = new 数据类型[M][]; //M：二维数组中一维数组的数量
//拆分
int[][] arr = new int[3][];
arr[0] = new int[2];
arr[1] = new int[3];
arr[2] = new int[4];
int[][] arr_1 = new int[][] {{1,2,3}, {4,5,6}, {7,8,9}};
int[][] arr_2 = {{1,2,3}, {4,5,6}, {7,8,9}};
int[][] arr_3 = {{1,2,3}, {4,5}, {6}};
数组遍历
public static void printTwodimensionalArray(int[][] arr) {
for( int i=0; i<arr.length; i++ ) {
for( int j=0; j<arr[i].length; j++ ) {
System.out.print(arr[i][j]+" ");
}
System.out.println();
}
}
数组查值
public static void getTwodimensionalArrayElem(int[][] arr, int value) {
for( int i=0; i<arr.length; i++ ) {
for( int j=0; j<arr[i].length; j++ ) {
if( arr[i][j] == value ) {
System.out.println(value + "：第" + i + "行" + "第" + j + "列");
}
}
System.out.println();
}
}