一维数组

一维数组的定义

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

一维数组的遍历

method 1:

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

method 2:

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

method 3:

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

理解引用

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

image-20220101215440175

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

初识JVM内存区域划分

img

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

二维数组

二维数组的内存结构

二维数组的定义

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:

1
2
3
4
5
6
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:

1
2
3
4
5
6
for ( int[] x:array) {
for ( int y:x) {
System.out.print(y);
}
System.out.println();
}

method 3:

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

数组练习

数组拷贝

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

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

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

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

1
2
3
4
5
6
7
8
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}

数组排序(冒泡排序)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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;
}
}

数组排序(偶数在前,奇数在后)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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;
}
}
}

查找指定数组元素(二分查找)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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;
}