JavaSE-数组

数组

1. Java提供了一种叫作数组的数据结构，它是一种用来存储相同类型元素的固定大小顺序集合。 数组用于存储数据集合，但也可以将数组视为相同类型的变量集合。

2. 可以是一维甚至多维。

3. 数组变量本身属于引用类型，数组也可以看成对象（同样可以通过 new 实例化对象），数组中每一个元素相当于对象成员本身，存放于内存的堆空间中。

数组声明与使用

数组的声明

1. 声明数组变量

语法：

dataType[] arrayRefVar;

实例：

int[] arr;

2. 创建数组

• 直接创建

语法：

dataType[] arrayRefVar = {value0, value1, ..., valuek};

实例：

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

• 开辟内存创建

语法：

dataType[] arrayRefVar = new dataType[arraySize];

实例：

int[] arr = new int[2];
int[][] arr2 = new int[2][2];  // 二维数组

说明：使用 new 关键字创建数据默认根据数组长度在开辟内存空间的提示赋值默认为 0。

数组常用方法

1. 遍历数组

public class Main{
	public static void main(String[] args){
		String[] arr = {"10","20","30"};
		int length = arr.length;
		System.out.print(length);
		for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        for (int i = arr.length - 1; i >= 0; i--) {
            System.out.println(arr[i]);
        }
	}
}

2. 数组最值

public class Main{
	public static void main(String[] args){
		int[] arr = {10,20,30,40};
		int a = arr[0];
		for (int i = 1; i < arr.length; i++) {
            if(arr[i] > a){
            // if(arr[i] < a){
				a = arr[i];
			}
        }
        System.out.print("最大(小)值："+a)
	}
}

3. 数组倒叙

public class Main{
	public static void main(String[] args){
		int[] arr = {10,20,30,40};
		for (int i = 0; i < arr.length/2; i++) {
			// 首位互换
            int a = arr[i];
            arr[i] = arr[arr.length-1-i];
            arr[arr.length-1-i] = a;
        }
        System.out.print(Arrays.toString(arr))
	}
}

4. 二分查找

前提：

1. 数组必须有序
2. 核心思想：每一次查找中间的元素，比较大小就能减少一半的元素。

• 如何实现？
  1. 如果这个元素等于中间索引所对应的元素，那么就返回中间索引对应的元素。
  2. 如果这个元素大于中间索引，那么最小索引就要转移到中间索引+1的位置处再进行元素搜索。
  3. 如果这个元素小于中间索引，那么最大索引就要转移到中间索引-1的位置处再进行元素搜索。
  4. 进行循环（最小索引小于等于最大索引）搜索。

public class Main{
	public static void main(String[] args) {
        int[] arr = {10, 20, 30, 30, 40, 50, 60, 70, 80, 90};
        int index = search(arr, 70);
        System.out.println(index);
    }

    public static int search(int[] arr, int num) {
        int min = 0;
        int max = arr.length - 1;
        int center = (min + max) / 2;
        while (min <= max) {
            if (num == arr[center]) {
                return center;
            } else if (num > arr[center]) {
                min = center + 1;
            } else {
                max = center - 1;
            }
            center = (min + max) / 2;
        }
        return -1;
    }
}

Arrays工具类

fill

import java.util.Arrays;

public class Main{
	public static void main(String[] args){
		int[] arr = {2,3,5,8,41,85,11};
		// Arrays.fill(arr,0);  // 全部填充
		Arrays.fill(arr, 2, 4, 0);  // 指定位置填充
		System.out.println(Arrays.toString(arr));   //=> [2, 3, 0, 0, 8, 85, 11]
	}
}

toString

import java.util.Arrays;

public class Main{
	public static void main(String[] args){
		int[] arr = {2,3,5,8,41,85,11};
		System.out.println(Arrays.toString(arr));   //=> [2, 3, 5, 8, 41, 85, 11]
	}
}

• 手写toString

import java.util.Arrays;

public class Main{
	public static void main(String[] args){
		int[] arr = {2,3,5,8,41,85,11};
		printArr(arr)
	}

	// toString
	public static void printArr(int[] arr){
		for(int i = 0; i < arr.length; i++){
			if(i==0){
				System.out.print("[");
			}
			if(i==arr.length -1){
				System.out.print("]");
			}else{
				System.out.print(arr[i]+', ');
			}
		}
	}
}

sort

import java.util.Arrays;

public class Main{
	public static void main (String[] args){
		int[] arr = {2,3,5,8,41,85,11};
		Arrays.sort(arr);   //=> 类工具冒泡排序，不会进行返回。
		System.out.print(Arrays.toString(sort));
	}
}

• 手写 sort

import java.util.Arrays;

public class Main{
	public static void main (String[] args){
		int[] arr = {2,3,5,8,41,85,11};
		int[] sort = sort(arr);
		System.out.print(Arrays.toString(sort))
	}

	public static int[] sort(int[] arr){
		int temp = 0;
		// 执行多少次
		for(int i = 0; i < arr.length-1; i++){
			boolean flag = false;
			// 每执行一次就少一层
			for(int j = 0; j <arr.length-1-i;j++){
				if(arr[j+1]>arr[j]){
					temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
					flag = true;
				}
			}
			if(flag==false){
				break;
			}
		}
		return arr;
	}
}

合并数组

在java6中，有一个方法Arrays.copyOf()，是一个泛型函数。我们可以利用它，写出更通用的合并方法：

public static <T> T[] concat(T[] first, T[] second) {
  T[] result = Arrays.copyOf(first, first.length + second.length);
  System.arraycopy(second, 0, result, first.length, second.length);
  return result;
}    

如果要合并多个，可以这样写：

public static <T> T[] concatAll(T[] first, T[]... rest) {
  int totalLength = first.length;
  for (T[] array : rest) {
    totalLength += array.length;
  }
  T[] result = Arrays.copyOf(first, totalLength);
  int offset = first.length;
  for (T[] array : rest) {
    System.arraycopy(array, 0, result, offset, array.length);
    offset += array.length;
  }
  return result;
}

使用如下：

String[] both = concat(first, second);

String[] more = concat(first, second, third, fourth);

还可以使用：Array.newInstance来生成数组

private static <T> T[] concat(T[] a, T[] b) {
    final int alen = a.length;
    final int blen = b.length;
    if (alen == 0) {
        return b;
    }
    if (blen == 0) {
        return a;
    }
    final T[] result = (T[]) java.lang.reflect.Array.
            newInstance(a.getClass().getComponentType(), alen + blen);
    System.arraycopy(a, 0, result, 0, alen);
    System.arraycopy(b, 0, result, alen, blen);
    return result;
}