二维数组(拷贝/扩容/删除)——Java

最新推荐文章于 2022-11-08 20:20:53 发布
最新推荐文章于 2022-11-08 20:20:53 发布
阅读量3.6k 收藏 11
点赞数 1
分类专栏： Java基础笔记 文章标签： java eclipse 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_66598341/article/details/125975258
版权

目录

前言

一、二维数组的声明及初始化

1.二维数组的声明

2.二维数组的初始化

2.1静态初始化

2.2动态初始化

二、访问数组元素

1.设置元素

1.1 设置元素

1.2 案例​​​​​​​

2.遍历数组

2.1 嵌套for循环遍历

2.2 嵌套foreach遍历

三、二维数组的拷贝

1.浅拷贝

2.深拷贝

2.1 for循环嵌套拷贝

2.2 for循环+Arrays工具类中拷贝方法

四、二维数组的扩容

1.扩容二维数组中的一维数组的数量

2. 扩容二维数组中的一维数组的容量

 五、二维数组的删除

1.删除二维数组中某个一维数组

1.1 删除方式1

 1.2  删除方式2

 2.删除二维数组中的一维数组中的某个元素

总结

前言

二维数组包含多个一位数组，将使用多个下标访问数组元素，同样下标是从0开始的。可以结合一维数组的基本知识来学习了解二维数组。在二维数组中的扩容与删除中，可以找到许多与一维数组的扩容与删除的相似之处。

可以通过下方链接温习一些简单的一维数组的知识，温故而知新。

一维数组 ——Java_康凯哇咔咔的博客-CSDN博客

提示：以下是本篇文章正文内容，下面案例可供参考

一、二维数组的声明及初始化

1.二维数组的声明

    数据类型[][] 变量名;

   声明一个数据类型为String的二维数组，数组名为str，代码示例如下： 

String[][] str;

2.二维数组的初始化

对数组进行初始化之前是不能使用的。

2.1静态初始化

//静态初始化1：
String[][] str1 = new String[][]{{"元素0-0","元素0-1","元素0-2"},{"元素1-0","元素1-1","元素1-2"}};
				
//静态初始化2：
String[][] str2;
str2 = new String[][]{{"元素0-0","元素0-1","元素0-2"},{"元素1-0","元素1-1","元素1-2"}};
		
//静态初始化3：
String[][] str3 = {{"元素0-0","元素0-1","元素0-2"},{"元素1-0","元素1-1","元素1-2"}};

//静态初始化3的不同写法
String[][] str3 = {
                    {"元素0-0","元素0-1","元素0-2"},
                    {"元素1-0","元素1-1","元素1-2"}
                    };

静态初始化3没有使用new 操作符号，使用简写形式对二维数组进行初始化。

2.2动态初始化

如果知道了数组的长度，那么就可以使用动态初始化。

//动态初始化1:初始化一个包含了 两个数组长度为3的一维数组 的二维数组
String[][] names = new String[2][3];

//动态初始化2
String[][] names2;
names2 = new String[2][3];

动态初始化的二维数组同样被赋予了系统默认值（不同数据类型系统默认值不同）。

二、访问数组元素

1.设置元素

1.1 设置元素

代码如下（示例）：

//动态初始化1
String[][] names = new String[2][3];

//获取长度
System.out.println("获取二维数组中包含的的一维数组个数："+str1.length);//输出结果：2
System.out.println("获取二维数组中第一个一维数组的长度："+str1[0].length);//输出结果：3
System.out.println("获取二维数组中第二个一维数组的长度: "+str1[1].length);//输出结果：3

//为动态初始化1的二维数组设置指定下标上的元素
names[0][0] = "元素0-0";
names[0][1] = "元素0-1";
names[0][2] = "元素0-2";
names[1][0] = "元素1-0";
names[1][1] = "元素1-1";
names[1][2] = "元素1-2";

//获取动态初始化1的二维数组的指定下标的元素
String n = names[1][1];
System.out.println("该下标元素为： " + n);

1.2 案例

初始化包含不同长度的一维数组的二维数组，可加深对创建二维数组的理解（代码示例如下）

/*
需求：创建一个二维数组，包含2个一维数组，其中第一个一维数组的长度为3，第二个一维数组的长度为4
 
*/
		
//创建一个包含两个一维数组的二维数组
String[][] names = new String[2][];
		
//设置在二维数组中下标为0的一维数组
names[0] = new String[]{"00","01","02"};
		
//设置在二维数组中下标为1的一维数组
names[1] = new String[]{"10","11","12","13"};

（实用性不高，但是有助于理解二维数组。）

2.遍历数组

2.1 嵌套for循环遍历

遍历思想：先遍历二维数组中的一维数组的个数，再遍历一维数组中的元素

代码如下（示例）：

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

2.2 嵌套foreach遍历

for each 循环语句不能自动处理二维数组中的每一个元素，所以需要两个foreach嵌套。首先最外层的foreach语句先遍历二维数组中它包含的每一个一维数组，内层的foreach再遍历一维数组中的每一个元素。

//外层foreach
for(String[] ss : names){
    //内层foreach
	for(String element : ss){
		System.out.println(element);
	}
}

三、二维数组的拷贝

1.浅拷贝

原数组（str）和拷贝后的新数组（strCopy）的引用指向同一个数组的内存地址。

//原数组
String[][] str = {{"元素0-0","元素0-1","元素0-2"},{"元素1-0","元素1-1","元素1-2"}};

//新数组
String[][] strCopy;	

//将原数组地址赋给新数组
strCopy = str;

需要注意的是新数组一开始并没有初始化，由于没有在初始化之前访问新数组中的元素，所以不会报错。也就是说在得到原数组的内存地址后，再访问新数组，访问的其实就是原数组。

2.深拷贝

原数组和拷贝后的数组指向两个不同的二维数组，是两个不同的内存地址。

2.1 for循环嵌套拷贝

//原数组
String[][] str = {{"元素0-0","元素0-1","元素0-2"},{"元素1-0","元素1-1","元素1-2"}};

//新数组（由于会操作新数组的下标，必须初始化）
String[][] strCopy = new String[2][3];

//利用双重for循环依次拷贝
for(int i=0;i < str.length; i++) {//遍历一维数组的个数
	for(int j=0;j<str[i].length;j++) {//遍历一维数组
		strCopy[i][j] = str[i][j];//依次拷贝
	}
}

2.2 for循环+Arrays工具类中拷贝方法

//原数组
String[][] str = {{"元素0-0","元素0-1","元素0-2"},{"元素1-0","元素1-1","元素1-2"}};

//新数组（由于会操作新数组的下标，必须初始化）
String[][] strCopy = new String[2][3];

//方法3：Arrays.copyOf方法
for(int i = 0; i < str.length; i++) {
    //调用Arrays工具类的copyOf方法
	strCopy[i] = Arrays.copyOf(str[i], str[i].length);
}

需要额外注意的是：数组未初始化前不能使用。

四、二维数组的扩容

1.扩容二维数组中的一维数组的数量

将二维数组中一维数组的数量扩容为原先的1.5倍（代码示例如下）

//1.原数组
String[][] str =  {{"元素0-0","元素0-1","元素0-2"},{"元素1-0","元素1-1","元素1-2"}};
				
//2.定义新数组中的一维数组的数量（原一维数组数量的1.5倍）
int oldCapacity = str.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
		
//3.循环比较二维数组中所有一维数组的长度,选出最长的长度，防止二维数组中一维数组长度不同造成的数组下标越界异常。
int n = oldCapacity-1;
int maxLenth = 0;
while(n>0) {
	maxLenth = str[n].length > str[n-1].length? str[n].length : str[n-1].length;
	n--;
}
		
//4.动态初始化新数组
String[][] newStr = new String[newCapacity][maxLenth];
				
//5.复制原数组中数据到新数组
for(int i = 0; i < oldCapacity; i++) {
	for(int j = 0; j < str[i].length; j++) {
		newStr[i][j] = str[i][j];
	}
}

//6.将新数组引用赋给原数组
str = newStr;
		
//7.遍历原数组
for (String[] ss : str) {
	for (String element : ss) {
	    System.out.println(element);
	}
}

结果如下：

2. 扩容二维数组中的一维数组的容量

将二维数组中每一个一维数组的长度扩容为原先的2倍

//1.原数组
String[][] str =  {{"元素0-0","元素0-1","元素0-2"},{"元素1-0","元素1-1","元素1-2"}};
			
//2.定义新数组中的一维数组的容量（原一维数组容量的2倍）
int oldCapacity = str[0].length;
int newCapacity = oldCapacity * 2;
	
//3.动态初始化新数组
String[][] newStr = new String[2][newCapacity];
			
//4.复制原数组中数据到新数组
for(int i = 0; i < str.length; i++) {
	for(int j = 0; j < oldCapacity; j++) {
		newStr[i][j] = str[i][j];
	}
}
	
//5.将新数组引用赋给原数组
str = newStr;
	
//6.遍历原数组
for (String[] ss : str) {
	for (String element : ss) {
	    System.out.println(element);
	}
}

结果如下：

 五、二维数组的删除

1.删除二维数组中某个一维数组

1.1 删除方式1

思路：将除了被删除的数组之外的数组复制到新数组中，再将新数组的地址引用赋给原数组

缺陷：减小了原有二维数组的所包含一位数组的数量，数组是存放数据的容器，最好不要轻易改小。

（代码示例如下）

/*
    需求：删除{"xxx","xxx","xxx","xxx"}
*/
	
//1.原数组
String[][] str = {{"xxx","xxx","xxx","xxx"},{"大黄瓜","大南瓜","大西瓜","大冬瓜"},{"沙糖桔","红富士","丑橘","大香蕉"}};
		
//2.初始化一个除了删除元素之外的数组
String[][] deleteStr = new String[str.length-1][str[0].length];
		
//3.定义需要删除的一维数组的下标
int deleteRow = 0;
		
//4.除了删除的一维数组，将其他一维数组复制到新数组中
int index = 0;//记录新数组中一维数组的下标
for(int i = 0;i < str.length; i++) {
	if(i != deleteRow) {
		for(int j = 0; j<str[i].length; j++) {
			deleteStr[index][j] = str[i][j];
		}
		index++;
	}	
}
		
//5.将新数组引用的数组地址赋值给原数组
str = deleteStr;
		
//6.遍历原数组
for (String[] ss : str) {
	for (String element : ss) {
	    System.out.println(element);
	}
}

结果如下：

 1.2  删除方式2

思路：通过迁移（覆盖）删除特定的一维数组

好处：没有改变原有数组的大小。

/*
    需求：删除{"xxx","xxx","xxx","xxx"}
*/

//1.原数组
String[][] str = {{"xxx","xxx","xxx","xxx"},{"大黄瓜","大南瓜","大西瓜","大冬瓜"},{"沙糖桔","红富士","丑橘","大香蕉"}};
		
//2.设置需要覆盖的一维数组的下一个下标
int index = 1;
		
//3.迁移覆盖指定下标之前的一维数组
for(int i = index; i<str.length; i++) {
	for(int j = 0; j<str[i].length;j++) {
		str[i-1][j] = str[i][j];
	}
}
		
//4.将最后一个一维数组设置为null
for(int i = 0; i<str[str.length-1].length;i++) {
	str[str.length-1][i] = null;
}
		
//5.遍历原数组
for (String[] ss : str) {
	for (String element : ss) {
	    System.out.println(element);
	}
}

结果如下：

 2.删除二维数组中的一维数组中的某个元素

思路：通过遍历二维数组找到需要删除的元素，使用该元素之后的元素将其覆盖。

（代码示例如下）

/*
    需求：删除丑橘
*/

//1.原数组
String[][] str = {{"xxx","xxx","xxx","xxx"},{"大黄瓜","大南瓜","大西瓜","大冬瓜"},{"沙糖桔","红富士","丑橘","大香蕉"}};
		
//2.循环遍历数组找到需要删除的元素
for (int i = 0; i < str.length; i++) {
    for (int j = 0; j < str[i].length-1; j++) {
    	if(str[i][j].equals("丑橘")) {//判断如果为要删除的元素，就用它之后的元素覆盖此元素，并把该一维数组最后一个元素设置为null
		    str[i][j] = str[i][j+1];
			str[i][str[i].length-1] = null;
		}
	}
}
			
//3.遍历数组
for (String[] ss : str) {
	for (String element : ss) {
		System.out.println(element);
   	}
}

结果如下：

总结

以上就是今天要讲的内容，本文仅仅简单介绍了二维数组，在二维数组的扩容与删除中有许多一维数组的知识，可以通过一维数组，更好地掌握二维数组。希望对您有所帮助！

康凯哇咔咔
关注
专栏目录
java二维数组的扩容_Java开发笔记（二十一）二维数组的扩展
weixin_42510262的博客
02-13 1148
前面介绍的数组容纳的是一串数字，仿佛一根线把这组数字串了起来，故而它只是一维数组。一维数组用来表示简单的数列尚可，要是表达复杂的平面坐标系，那就力不从心了。由于平面坐标系存在水平和垂直两个方向，因此可用二维数组来保存平面坐标系上的一组坐标顶点，其中第一维是顶点队列，第二维是顶点的横纵坐标。许多个平面组合起来变成一幅动画，每个平面都构成动画的一个帧，这样就形成了三维数组。二维数组、三维数组，乃至更多...
Java基础知识——数组
qq_65573436的博客
08-04 757
1、一维数组 2、二维数组 3、数组排序
java中二维数组删除一行
11-22
1.方便获得一个字符串表示的矩阵 2.删除二维数组中的第几行 3.删除二维数组中与所要删除行内容一样的此行 4.获得此二维数组
Java二维数组扩容
weixin_46080371的博客
12-21 1560
public static void main(String[] args) { int a[][]=new int[3][3]; System.out.println(a.length); a=Arrays.copyOf(a,a.length+1); a[3]=new int[3]; //二维数组扩容必须要分配空间，不然会抛出异常 //（一维数组不用分配空间） System.out.print.
java二维数组的扩容_Java数组
weixin_36147585的博客
02-25 440
它用于组织同种类型的数据，这些数据既可以是基础的数据类型的集合，也可以是一组对象的集合。数据从本质上理解就是一种线性表，用户可以方便的获取该线性表中任意一个元素或者修改其中一个元素的值。数组在内存中通常都是一块连续的存储单元。package com.what21.array;/*** Java数组*/public class ArrayTest {/*** @param args*/public ...
java二维数组删除特定行代码
01-16
可以删除data矩阵中末尾数据个数《=1的行
Java - 数组
最新发布
m0_65638983的博客
11-08 1109
数组，就是用来存放一组数据的集合，例如我们想要存放某个班级每位同学的成绩时，就需要使用数组。当我们不使用数组来存放并打印某个班级同学的成绩时。这样看上去是不是很麻烦，如果要存放100位 200位同学的成绩时呢，这时候数组就派上用场了，类型不能用混用，例如存放分数 (int)的数组里面不能放姓名 (char)的数据他的下标是从0开始的，例如存放9个数据的数组他的下标是 0 - 8 ，n个数据就是 0 - (n-1)
参照Java学Go（三）—— go的内置类型：数组、切片slice、map
mingjia1987的博客
05-29 2924
    前一篇说到了go的变量、常量和基本数据类型，接下来继续说一下go的其他内置类型：数组、切片（slice）和集合（map）    一，数组    go和java中肯定都有数组了，只不过在定定义上和定义变量类似，把类型放到了后边（还是觉得很难受有没有？）    首先对比一下定义：//java： int[] arr; //没有初始化 arr = new int[1]{}; ...
Java第七章笔记———数组
THEGREATHXY的博客
06-26 474
数组定义： 数组是相同类型数据的有序集。 数组就是一个对象，数组的每一个元素可以看成一个成员变量。 数组一旦被创建，它的大小就是固定的 其元素必须是相同类型 数组类型可以是任何数据类型，包括基本类型和引用类型 数组的声明方式： type[] arr_name; //（推荐使用这种方式） type arr_name[]; 1.数组声明时并没有实例化任何对象，只有在实例化数组对象时...
Java入门-Java数组
刘树之的博客
04-26 317
Java入门——数组 1.一维数组 1.含义及声明 ​ 含义：一组数据的容器 ​ 声明：数据类型 [] 数组名 2.注意 ​ (1).变量只能存单个数据，数组可以存多个数据; ​ (2).数组是引用类型; ​ (3).数组中的数据叫做元素； ​ (4).每个元素都有编号，叫做下标(索引)，下标从0开始; ​ (5).数组一但初始化后，在内存里会开辟一连串连续的空间，且空间长度不可变; ​ (6).数组作为一个容器，容器就应该有增删改查的功能，但由于数组的长度不可变，所以数组没有增加删除的功能，只有查询和修改
java数组扩容
08-18
打破数组的固定长度局限性！使之逻辑延长
二维数组及扩容
yiXin_Chen的博客
08-11 557
1. 声明 int [ ] [ ] arr1; String [ ] [] arr2; 2. 初始化 完整的初始化 :arr1 = new int [3] [5]; 二维数组与foreach的使用 (增强 for循环) for ( int [ ] temp : arr1) { System.out.println("\t" + tem...
【Java】二维数组的简单扩容示例
K_byul的博客
04-01 1770
public class Deep { public static void main(String[] args) { int[][] arr = new int[][]{{1,2,3},{4,5,6}}; int[][] brr = Arrays.copyOf(arr,arr.length); System.out.println("arr...
二维数组扩展
WLinyi的博客
07-18 687
var Creat2XArr = function(_i,_j,defaultValue){ var returnArr0 = [] for(var i = 0;i<_i;i++){ returnArr[i] = [] for(var j=0;j<_j;j++){ returnArr[i][j] = defaultValue;
二维数组的扩展
qq_45767166的博客
02-20 1244
1.二维数组的含义 由行和列组成的表格，尤其对于二维数组而言，无非就是一个一维数组，只不过该一维数组中的每一个元素是另一个一维数组。 2.二维数组的创建 2.1 创建一个3行3列的二维数组，元素默认都是0 int[][] matrix=new int[3][3]; 2.2 创建一个指定元素的二维数组(两种方法) int[][] matrix=new int[][]{ {1,2,3...
Java中一维数组和二维数组的扩容
CSDN_XHC的博客
12-30 466
Java中数组的扩容采用的是System.arraycopy()方法 一维数组扩容 public class Test { public static void main (String[] args) { expansionOne(); } // 一维数组扩容 public static void expansionOne () { // 定义一个源数组 int[] array = {1, 2, 3, 4}; // 定义一个目标数组 int[] arraycopy =.
java删除二维数组中的一行_Day 1:二维数组中查找
weixin_39633781的博客
12-02 1440
题目描述： 在一个二维数组中(每个一维数组的长度相同)，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组中的一个整数，判断数组中是否含有该整数。具体要求：时间限制：C/C++ 1秒，其他语言2秒空间限制：C/C++32M，其他语言64M具体思路： 思路1：由于每行都是有序递增的二维数组；因此可以用二分查找更为方便。时...
把int[n,m]的二维数组，扩充为int[2n,2m]大小
XMJ101307330的博客
07-15 166
规则是： 转载于:https://www.cnblogs.com/LouisGuo/p/4649029.html
Java二维数组转Arraylist集合，并做删除操作
sofewave_hand_LI的博客
04-23 1030
import java.util.*; public class Demo2 { static<T> ArrayList<T> getList(T[][] arr){//二维数组转Arraylist ArrayList<T> list = new ArrayList<T>(); for(int i=0; i<arr.l...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值