day06——数组

最新推荐文章于 2025-05-28 08:53:03 发布

×(ಥ_^)√

最新推荐文章于 2025-05-28 08:53:03 发布

阅读量403

点赞数 5

文章标签： java 开发语言笔记

本文链接：https://blog.youkuaiyun.com/2403_88004502/article/details/143719726

版权

day06

一、一维数组

理解：一组数据的容器

概念：

数组为引用数据类型
数组中的数据，叫做元素
元素都有编号，叫做下标/索引
下标从0开始
数组中的元素是连续的(内存中是挨在一起的)
数组初始化完成后，该数组长度不可变
数组作为容器，需要管理数据，但是数组初始化后长度不可更改，意味着数组只能修改和查询，不能添加和删除(只能通过创建新数组的方式来进行数组的扩容和删除)

数组的声明：

//数据类型[] 数组名;
int[] arr;
//数据类型 数组名[];
int arr[];

1. 数组的初始化

1.1 静态初始化

数据由程序员指定，长度由系统分配

声明时初始化

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

先声明，再初始化

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

简化(1)

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

//初始化数组
int[] arr = {1,2,3,4,5};
//设置指定下标上的元素
num[0] = 6;
//获取指定下标上的元素
System.out.println(arr[0]);//6
//获取元素个数
System.out.println(arr.length);
//遍历数组1---for循环遍历(使用下标)
for(int i = 0;i<arr.length;i++){
    System.out.println(arr[i]);
}
//遍历数组2---foreach/增强for循环遍历(不使用下标)
for(int element:arr){
    System.out.println(element);
}

1.2 动态初始化

//初始化数组，设定长度为3
int[] arr = new int[3];
//设置指定下标上的元素
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;
//遍历
for(int element:arr){
    System.out.println(element);
}
//1
//2
//3

静态初始化vs动态初始化

知道数据，使用静态初始化
知道长度，使用动态初始化

2. 一维数组的排序

2.1 冒泡排序

口诀:

n个数字排序

两两相比小靠前

外层循环n-1

内层循环n-1-i

//声明并初始化数组
int[] arr = {81,53,2,67,18};
//排序
for(int i = 0;i<arr.length-1;i++){
	for(int j = 0;j<arr.length-1-i;j++){
		if(arr[j] > arr[j+1]){
			int temp = arr[j];
			arr[j] = arr[j+1];
			arr[j+1] = temp;
		}
	}
}
//遍历	
for(int element : arr){
	System.out.println(element);
}

3. 一维数组的查找

3.1 线性查找

int[] arr = {81,53,2,67,18};
int num = 2;//要查询的数据	
for(int i = 0;i<arr.length;i++){
	if(arr[i] == num){
		System.out.println("查找到元素了，元素的下标为：" + i);
	}
}

3.2 二分法查找/二叉搜索查找

必须先排序，再查找

 2 , 18 , 53 , 67 , 81
 ↓        ↓         ↓
start     mid      end

int[] arr = {81,53,2,67,18};
//排序 - 2,18,53,67,81
Arrays.sort(arr);
//查询目标
int num = 2;
//查询起始下标
int start = 0;
//查询末尾下标
int end = arr.length-1;

while(start <= end){
    //查询中间下标
	int mid = (start+end)/2;
	//查询目标小于查询中间下标
	if(num < arr[mid]){
        //查询末尾下标左移
		end = mid-1;
    //查询目标大于查询中间下标
	}else if(num > arr[mid]){
        //查询起始下标右移
		start = mid+1;
	}else{
        //查询目标等于查询中间下标
		System.out.println("查找到元素了，元素的下标为：" + mid);
	break;
	}
}

4. 数组的复制

4.1 浅表复制

//源数组/原数组/数据源
String[] arr = {"红","绿","蓝"};
//新数组
String[] newArr = arr;
//修改源数组的数据
arr[1] = "黄";
//遍历新数组
for(String element : newArr){
	System.out.println(element);
}
//红
//黄
//蓝

缺点：修改源数组，新数组的数据也会发生改变
原因：源数组和新数组都是指向同一个对象

4.2 深层复制

//源数组/原数组/数据源
String[] arr = {"红","绿","蓝"};
//新数组
String[] newArr = new String[arr.length];
//遍历源数组，并将元素赋值给新数组
for(int i = 0;i<arr.length;i++){
    newArr[i] = arr[i];
}
//修改源数组的数据
arr[1] = "黄";
//遍历新数组
for(String element : newArr){
	System.out.println(element);
}
//红
//绿
//蓝

5. 数组的扩容

//源数组/原数组/数据源
String[] arr = {"红","绿","蓝"};	
//计算新长度（新长度是原来长度的1.5倍）
int oldCapacity = arr.length;//3
int newCapacity = oldCapacity + (oldCapacity>>1);//4
//创建新数组
String[] newArr = new String[newCapacity];		
//遍历源数组，将源数组的元素赋值给新数组
for(int i = 0;i<arr.length;i++){
	newArr[i] = arr[i];
}		
//将新数组的内层地址赋值给源数组
arr = newArr;		
//遍历源数组
for(String element : arr){
	System.out.println(element);
}
//红
//绿
//蓝
//null

6. 数组的删除

6.1 数组的删除1

//源数组/原数组/数据源
String[] arr = {"红","绿","蓝"};	
//创建新数组 -- [null,null]
String[] newArr = new String[arr.length-1];
//遍历源数组，将除了"绿"以外的元素赋值给新数组
int index = 0;
for(String element : arr){
	if(!element.equals("绿")){
		newArr[index] = element;
		index++;
	}
}
//将新数组的内存地址赋值给源数组
arr = newArr;
//遍历源数组
for(String element : arr){
	System.out.println(element);
}
//红
//蓝

缺点：数组空间会越来越小

6.2 数组的删除2

//源数组/原数组/数据源
String[] arr = {"红","绿","蓝"};
//数据的位移 -- ["红","蓝","蓝"]
for(int i = 1;i<arr.length-1;i++){
	arr[i] = arr[i+1];
}	
//把最后一个元素赋值为null
arr[arr.length-1] = null;
//遍历源数组
for(String element : arr){
	System.out.println(element);
}
//红
//蓝
//null

7. 数组作为参数和返回值

注意：

数组可以作为参数，传入方法
方法如果想返回多个数据，可以将多个数据放在一个数组中

public static void main(String[] args){
    int[] arr = {81,53,2,67,18};
    //调用获取最大值和最小值的方法
    int[] maxAndMin = getMaxAndMin(arr);
    System.out.println("最大值为：" + maxAndMin[0]);
    System.out.println("最小值为：" + maxAndMin[1]);
}

public static int[] getMaxAndMin(int[] arr){
    //假设下标为0的元素为最大值和最小值
    int max = arr[0];
    int min = arr[0];
    for(int i = 1;i<arr.length;i++){
        if(max < arr[i]){
            max = arr[i];
        }
        if(min > arr[i]){
            min = arr[i];
        }
    }
    return new int[]{max,min};
}

8. 可变参数

可变参数就是数组

public static void main(String[] args){	
	//注意：1,54,7,32,41,235,34,8数据作为数组的元素
	int max = getMax(1,54,7,32,41,235,34,8);
	System.out.println("最大值为：" + max);
}

//注意：int... arr底层就是数组
public static int getMax(int... arr){
	int max = arr[0];
	
	for(int i = 1;i<arr.length;i++){
		if(max < arr[i]){
			max = arr[i];
		}
	}
	return max;
}

错误写法：

public static void method(int... arr,int num){
}
//报错-The variable argument type int of the method method must be the last parameter
//原因-可变参数后不能再接参数

二、二维数组

理解：二维数组中包含了多个一维数组

数组的声明：

//数据类型[][] 数组名;
int[][] arr;
//数据类型 数组名[][];
int arr[][];

1. 二维数组的初始化

1.1 静态初始化

//声明并初始化
int[][] arr1 = new int[][]{{1,2,3},{4,5,6,7}};
//声明，再初始化
//int[][] arr2;
//arr2 = new int[][]{{1,2,3},{4,5,6,7}};
//简化
//int[][] arr3 = {{1,2,3},{4,5,6,7}};
//设置指定数组指定下标上的元素
arr1[1][3] = 999;
//获取指定数组指定下标上的元素
System.out.println(arr1[1][3]);//999
System.out.println("-------------------------------------");
//获取二维数组长度
System.out.println("二维数组长度:"+arr1.length);
System.out.println("-------------------------------------");
//获取二维数组中一维数组的长度
System.out.println("二维数组中第一个一维数组的长度"+arr1[0].length);
System.out.println("二维数组中第二个一维数组的长度"+arr1[1].length);
System.out.println("-------------------------------------");
//遍历数组1
for (int i = 0; i < arr1.length; i++) {
    for (int j = 0; j < arr1[i].length; j++) {
        System.out.println(arr1[i][j]);
    }
}			
System.out.println("-------------------------------------");
//遍历数组2
for (int[] arrs : arr1) {
    for (int element : arrs) {
        System.out.println(element);
    }
}

1.2 动态初始化

//声明并初始化
int[][] arr1 = new int[2][3];//2-两个一维数组/3-每个一维数组3个元素
//声明，再初始化
//int[][] arr2;
//arr2 = new int[2][3];
//设置指定数组指定下标上的元素
arr1[0][0] = 1;
arr1[0][1] = 2;
arr1[0][2] = 3;
//获取指定数组指定下标上的元素
System.out.println(arr1[0][0]);
System.out.println(arr1[0][1]);
System.out.println(arr1[0][2]);
System.out.println("-------------------------------------");
for (int[] is : arr1) {
    for (int i : is) {
        System.out.println(i);
    }
}

需求：创建一个二维数组，其中第一个一维数组长度为3，第二个一维数组长度为4

//声明二维数组，长度为2
int[][] arr = new int[2][];
//声明第一个一维数组，长度为3
int[] s1 = new int[3];
//声明第一个一维数组，长度为4
int[] s2 = new int[4];
//分别将s1和s2的内存地址赋值给源二维数组中的一维数组的引用
arr[0] = s1;
arr[1] = s2;
//遍历数组
for (int[] ss : arr) {
    for (int element : ss) {
        System.out.println(element);
    }
}