定义
一段连续的空间了,存储相同的数据类型的。
数组的定义-开辟空间-赋值
//首先基本的数据类型来说
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:复制的长度。
数组的优缺点
一句话总结数组的优缺点:适用于读操作多,写操作少,因为对数组进行添加元素,删除元素都会进行数组移动,十分不方便。