数组

有点难！

于 2020-12-30 16:55:37 发布

阅读量3.9k

点赞数 2

分类专栏： javase基础

本文链接：https://blog.csdn.net/toomemetoo/article/details/111993393

版权

javase基础专栏收录该内容

49 篇文章 0 订阅

订阅专栏

定义

一段连续的空间了，存储相同的数据类型的。

数组的定义-开辟空间-赋值

//首先基本的数据类型来说
int num ; //定义一个int类型的变量，名叫num
num = 123 ;  //给变量num赋值，这个严谨应该说是将123赋值给num变量

//数据是怎么定义赋值的
//因为数组不是基本数据类型
//它的定义赋值有三走曲，即定义-开辟空间-赋值

//方法一（三步，每一步单走）
int [] num ; //第一种方法定义，这是Java常见的定义方法，推荐这种
int num [] ; //第二种方法定义，这是因为Java底层是c语言，c++写的 ，这种方法常见于C语言中

num = new int[3] ; //这个就是开辟空间
num[0] = 1 ; //赋值语句，将1赋值给数组num中下标0中
num[1] = 2 ; //依次赋值,将2赋值给数组num中下标1中
num[2] = 45 ; //将45赋值给数组num中下标2中

//方法二（前俩步一起走，第三步单走，这种使用于知道数组长度，不知数组元素值）
int [] num1 = new int[45] ; //定义以及开辟空间一起走,给num1数组开辟45个int类型的空间
num1[0] = 453 ； //单独赋值

//方法三（三步一起走，这种知道数组的元素值）
int [] num2 = new int[] { 45, 789, 456, 23} ; //这个等号右边的[]不用填数字，直接由{}中个数开辟空间
//简化为
int [] num2 = { 45 , 789 , 456 , 12} ; //这个效果和上面是一样的

//方法三（定义单走，开辟空间以及赋值一起走）
int [] num3 ; //定义
num3 = new int[]{4567, 4567,1489} ; //开辟空间以及赋值

数组的复制

复制有两种方法，本质是一种，因为代码大致是一样的。一种是我们手写；一种调用系统提供。
方法一：遍历原数组，复制给新数组。

int [] arrOld = {145, 789, 435 ,159} ; //定义并赋值,原数组
		int [] arrNew ; //声明一个新的数组
		int len = arrOld.length ; //获取数组的长度的方法，循环里用得到
		arrNew = new  int [len]; //给新数组开辟空间
		int i ;//循环变量
		for( i = 0 ; i< len ; i++) {//输出新数组
			System.out.println("没复制之前；" + arrNew[i]); 
		}
		System.arraycopy(arrOld, 0, arrNew, 0, len);
		for( i = 0 ; i< len ; i++) {//输出新数组
			System.out.println("复制之后：" + arrNew[i]); 
		}//看看结果

在这里插入图片描述
这说明数组作为引用类型，在开辟空间时候，会赋默认值。整型赋值0；浮点赋值0.0；字符也会赋初值，需要进行（int）转化,数值为0；布尔会赋值false.

int len = 5 ;
char [] arrNew = new char[len] ; //声明一个新的数组
for( i = 0 ; i< len ; i++) {//输出新数组
			System.out.println("没复制之前:" + (int)arrNew[i]); 
		}
//看看结果

在这里插入图片描述
说明char型数组也会赋初值，我们想看就要转化为整型来看。
再来看看方法2：

		int [] arrOld = {145, 789, 435 ,159} ; //定义并赋值,原数组
		int [] arrNew ; //声明一个新的数组
		int len = arrOld.length ; //获取数组的长度的方法，循环里用得到
		arrNew = new  int [len]; //给新数组开辟空间
		int i ;//循环变量
		System.arraycopy(arrOld, 0, arrNew, 0, len);//系统提供了函数给我们使用，参数一：原数组名；参数二：开始复制元素的下标；复制的新数组名；复制到的新数组的开始下标；复制的长度。
		for( i = 0 ; i< len ; i++) {//输出新数组
			System.out.println("复制之后：" + arrNew[i]); 
		}

在数组中查找某元素

**假设现在有个需求，查找某个元素，如果查找到了输出该元素的下标，否则输出-1**

		char [] ch = {'a' , '1' , '中' , ',' , '+'} ;//查找的数组
		char found = '1' ; //查找的元素
		int index = -1 ;//下标
		for(int i = 0; i < ch.length ; i++) {
			if(found == ch[i]) {
				index = i ; //获取查找到的下标
				break ;
			}
		}
		System.out.println(index);

在数组中添加个元素或者数组

我们知道，数组是定长，开辟空间是多少就是多少，不能进行扩容。
那么只能新开辟一个数组将原数组和添加的元素加到新数组中。

//添加个元素
		int [] arrOld = {145, 789, 435 ,159} ; //定义并赋值,原数组
		int len = arrOld.length ;
		int num = 1 ;//添加的元素
		int [] arrNew = new int [len + 1]; //保存的新数组
		 
		System.arraycopy(arrOld, 0, arrNew, 0, len); //复制原数组
		arrNew[len] = num ;//添加新的元素
		
		for(int i = 0 ; i < arrNew.length ; i++ ) {//输出看看结果
			System.out.println(arrNew[i]);
		}

//添加个数组
		int [] arrOld1 = {145, 789, 435 ,159} ; //定义并赋值,原数组1
		int len1 = arrOld1.length ;
		int [] arrOld2 = {5, 9, 4 ,1} ; //定义并赋值,原数组2
		int len2 = arrOld1.length ;
		
		
		int [] arrNew = new int [len1 + len2]; //保存的新数组
		 
		System.arraycopy(arrOld1, 0, arrNew, 0, len1); //复制原数组1
		System.arraycopy(arrOld2, 0, arrNew, len1, len2);//复制原数组2
		
		
		for(int i = 0 ; i < arrNew.length ; i++ ) {//输出看看结果
			System.out.println(arrNew[i]);
		}
		//看看结果

在这里插入图片描述
方法二：

int [] arrOld1 = {145, 789, 435 ,159} ; //定义并赋值,原数组1
		int len1 = arrOld1.length ;
		int [] arrOld2 = {5, 9, 4 ,1} ; //定义并赋值,原数组2
		int len2 = arrOld1.length ;
		
		
		int [] arrNew = new int [len1 + len2]; //保存的新数组
		
		arrNew = Arrays.copyOf(arrOld1, len1 + len2); //参数一：复制的原数组，参数二：复制后新数组的长度 。返回结果给一个新的数组,自动帮我们开辟空间
		System.arraycopy(arrOld2, 0, arrNew, len1, len2);
		for(int i = 0 ; i < arrNew.length ; i++ ) {//输出看看结果
			System.out.println(arrNew[i]);
		}

删除数组中某个元素

				int [] arr = {145, 789, 435 ,159} ; //定义并赋值,原数组1
				int num = 435 ; //删除的元素的值
				int [] arrNew = new int [arr.length - 1]; //保存删除元素后的新数组
				int index = -1;//删除元素的下标先赋值为 -1
				for(int i = 0; i < arr.length ; i ++) {
					if(arr[i]  == num) {
						index = i ;
						break ; //找到了就终止循环
					}
				}
				System.arraycopy(arr, 0, arrNew, 0, index );
				
				System.arraycopy(arr, index + 1, arrNew, index, arr.length - index - 1);
				
				for(int i = 0; i < arrNew.length ; i ++) {
					System.out.println( "删除后的：" + arrNew[i]); 
				}

## 修改数组中某个元素的值
修改值，并没有修改数组的长度，那么就不用开辟一个新的数组保存。也比较简单，直接上代码。

```java
				int [] arr = {145, 789, 435 ,159} ; //定义并赋值,原数组1
				int num = 435 ; //修改的元素的值
				
				for(int i = 0; i < arr.length ; i ++) {
					if(arr[i]  == num) {
						arr[i] = 1; //修改后的值
						
					}
				}
				System.out.println(Arrays.toString(arr));

数组类型的参数

数组不是基本类型，那么和基本类型在方法中传参有何不同
先看基本类型在方法中传参。

public static void main(String[] args) {
		int n1 = 1 ;
		int n2 = 2 ;
		basic(n1,n2);
			System.out.println("在main中交换后的两个值：" + n1 + "," + n2 );
		}
public static void basic(int num1 , int num2) {
				num1 = num1 ^ num2 ;
				num2 = num1 ^ num2 ;
				num1 = num1 ^ num2 ;
				System.out.println("在方法中交换后的两个值：" + num1 + "," + num2 );
			}
	//看看结果

在这里插入图片描述
说明基本类型传参是传递的值，将原来变量的值传递到方法中的新变量（即参数）。在方法中对值进行修改不会改变原变量的值。
再来看看数组作为参数

public static void main(String[] args) {
		int [] n1 = {1 , 2 };
		System.out.println("在main中的两个值：" +n1[0] + "," + n1[1] );
		string(n1);
		System.out.println("在方法中交换了值后在main中的两个值：" +n1[0] + "," + n1[1] );
		}

public static void string(int [] a) {//参数是个数组
				a[0] = a[0] ^ a[1] ;
				a[1] = a[0] ^ a[1] ;
				a[0] = a[0] ^ a[1] ;
				System.out.println("在方法中交换后的两个值：" + a[0] + "," + a[1] );
			}
		//看看结果

在这里插入图片描述
在方法中调换了数组中两个元素的值，那么原函数中两个值也交换了
这是因为数组是引用类型，在传参时传递的是数组的地址。

什么是数组的地址

先说说数组为什么有下标。
数组名保存的是数组的起始地址，也是第一个元素的地址，例如：一个数组int [] str = { 1 , 2 , 3 } ;那么str 保存的是下标为0（即第一个元素的地址），后面的下标1，2这个是说明数组向后偏移1个单位长度,偏移2个单位长度，这里的单位长度是由数组类型决定的，例如：int就是4个字节长度。

数组作为参数，返回值怎么确定

如果没有修改数组长度，那么就不用开辟新的空间保存数组，那么返回值就是void
如果对数组进行删除，或者添加元素，进行扩容，那么就要开辟新的空间保存新的数组，那么就要要返回值了，例如：int [],这个就是整型的数组。
给个栗子。

public static void main(String[] args) {
		int [] n1 = {1 , 2 };
		System.out.println("没添加时的数组" + Arrays.toString(n1) );
		int n = 5 ;
		n1 = add(n1 , n) ; //将添加数后的数组给数组，那么原数组将保存添加元素数组的新起始地址
		System.out.println("添加后的数组" + Arrays.toString(n1));
		}
public static int [] add( int [] arr, int num) {
				int [] newArr = new int [arr.length + 1];
				System.arraycopy(arr, 0, newArr, 0, arr.length);
				newArr[arr.length] = num ;
				return newArr;
			}

可变长的参数

在方法中使用…代替数组方括号
只能作为最后一个参数
会自动把它识别为一个数组
可以传递一个参数，俩个参数，多个参数，也可以不传递参数

public static void main(String[] args) {
		String s1 = "14" ;
		
		String s2 = "13" ;
		int n = 5 ;
	    output(n , s1 , s2 ) ; 
		
		}
public static void output( int n, String ... num) {//这个参数只能这样放
				System.out.println(Arrays.toString(num));
			}

在这里插入图片描述

系统给数组提供的函数总结

输出数组：

System.out.println(Arrays.toString(num));//这样就不用我们写遍历，其实系统也是遍历输出

原数组复制到新的数组

int [] newArr = Arrays.copyOf(arr1, arr1.length + 5);
//参数1：原数组；参数二：新数组长度，可以比原数组短，一样长，更长。

System.arraycopy(arr2, 0, newArr, arr1.length, arr2.length);
//这个是第二种复制的方法，这个需要前面先定义一个新数组。参数一：原数组；参数二：原数组起始复制的下标；参数三：新数组的名称；参数四：复制到新数组的起始位置；参数5：复制的长度。

数组的优缺点

一句话总结数组的优缺点：适用于读操作多，写操作少，因为对数组进行添加元素，删除元素都会进行数组移动，十分不方便。

有点难！

关注

2
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
数组

定义一段连续的空间了，存储相同的数据类型的。直接上代码//首先基本的数据类型来说int num ; //定义一个int类型的变量，名叫numnum = 123 ; //给变量num赋值，这个严谨应该说是将123赋值给num变量//数据是怎么定义赋值的//因为数组不是基本数据类型//它的定义赋值有三走曲，即定义-开辟空间-赋值//方法一（三步，每一步单走）int [] num ; //第一种方法定义，这是Java常见的定义方法，推荐这种int num [] ; //第二种方法定义，
复制链接

扫一扫

专栏目录