【JavaSE】数组的定义和使用

一维数组

一维数组的定义

int[] arr={1,2,3,4,5}; //静态创建
int[] arr1=new int[]{1,2,3,4,5}; //动态创建
int[] arr2=new int[5];

一维数组的遍历

method 1：

for (int i = 0; i < arr.length; i++) {
    System.out.print(arr[i]);
}

method 2：

for (int x:arr) {
    System.out.print(x);
}

method 3：

System.out.println(Arrays.toString(arr));

理解引用

int[] arr=new int[]{1,2,3}创建一个数组，变量arr是一个引用类型，里面只保存了一个整数（数组的起始内存地址），指向{1，2，3}的存储地址。

引用，本质上就是存放了一个地址。当数组作为方法的参数时，其实是将数组的首地址作为参数，通过首地址便可以找到数组中的每一个元素。这样的好处是避免了整个数组的拷贝，可以节省内存。

初识JVM内存区域划分

• 虚拟机栈：重点存储局部变量表，int[] arr这样的引用类型就存储在这里，每次方法执行时，会创建一个栈帧，方法结束后会自动销毁，栈帧内的数据也会一同销毁。
• 堆：JVM管理的最大内存区域，new创建的对象都存储在这里，如new int[]{1，2，3}。程序开始运行，堆创建，程序运行结束，堆销毁。
• 方法区：用于存储已被虚拟机加载的类信息、常量、静态变量等数据，字节码文件就保存在方法区。

二维数组

二维数组的定义

int[][] array={{1,2,3},{4,5,6}};
int[][] array1=new int[][]{{7,8,9},{10,11,12}};
int[][] array2=new int[2][3];

二维数组的遍历

method 1：

for (int i = 0; i < array.length; i++) {
    for (int j = 0; j < array[i].length; j++) {
        System.out.print(array[i][j]+" ");
    }
    System.out.println();
}

method 2：

for ( int[] x:array) {
    for ( int y:x) {
        System.out.print(y);
    }
    System.out.println();
}

method 3：

System.out.println(Arrays.deepToString(array));

数组练习

数组拷贝

public static int[] copyOf(int[] original,int newLength)

original - 要复制的数组
newLength - 要返回的副本的长度

public static int[] copyOfRange(int[] original,int from,int to)

original - 要从中复制范围的数组
from - 要复制的范围的初始索引（包括）
to - 要复制的范围的最终索引（不包括）

int[] arr={1,2,3,4,5};
int[] arr2=Arrays.copyOf(arr,arr.length);
System.out.println(Arrays.toString(arr2)); //{1，2，3，4，5}
arr[0]=100;
System.out.println(Arrays.toString(arr2)); //{1，2，3，4，5}
System.out.println(Arrays.toString(arr)); //{100，2，3，4，5}
int[] arr3=Arrays.copyOfRange(arr,1,3);  // 拷贝[1,3)范围内的数组
System.out.println(Arrays.toString(arr3)); //{2，3}

数组排序（冒泡排序）

public static void main(String[] args) {
    int[] arr={11,2,31,14,5};
    bubbleSort(arr);
    System.out.println(Arrays.toString(arr));
}
public static void bubbleSort(int[] arr){
    for (int i = 0; i < arr.length-1; i++) {
        boolean flg=false;
        for (int j = 0; j < arr.length-1-i; j++) {
            if(arr[j]>arr[j+1]){
                int tmp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=tmp;
                flg=true;
            }
        }
        if(flg==false)
            break;
    }
}

数组排序（偶数在前，奇数在后）

public static void main(String[] args) {
    int[] arr={1,2,3,4,5};
    transform(arr);
    System.out.println(Arrays.toString(arr));
}
public static void transform(int[] arr){
    int left=0;
    int right=arr.length-1;
    while(left<right){
        while(left<right&&arr[left]%2==0){
            left++;
        }
        //遇到奇数了
        while(left<right&&arr[right]%2!=0){
            right--;
        }
        //遇到偶数了
        if(left<right){
            int tmp=arr[left];
            arr[left]=arr[right];
            arr[right]=tmp;
        }
    }
}

查找指定数组元素（二分查找）

public int binarySearch(int[] nums,int target){
    int left=0;
    int right=nums.length-1;
    while(left<=right){
        //每次范围缩小一半
        int mid = (left+right)/2;
        if(nums[mid]<target){ //范围缩小到右半部分
            left = mid + 1;
        }else if(nums[mid]>target){ //范围缩小到左半部分
            right = mid -1;
        }else {
            return mid; //找到了，返回下标
        }
    }
    return -1;
}