数组
1. 定义
数据类型[] 变量名 = new 数据类型[长度]; 数据类型 变量名[] = new 数据类型[长度];
定义数组数据类型
定义数组长度
/*
* 创建一个int类型的数组，长度为4
* 1. arr变量所占的内存，被分成4份
* 2. 每份内存只能保存int类型的数据
*/
int[] arr = new int[4];
2. 使用
变量所占内存会根据数据长度进行分割（长度为n,会分成n份）
每一份都有一个下标
下标从0开始，依次递增1
变量可以通过下标操作,设置每个位置的值
//定义长度为3的小数类型的数组，为每一个位置赋值，并获取值
int[] arr1 = new int[3];
arr1[0]=11;
arr1[1]=22;
arr1[2]=33;
int v1=arr1[0];
int v2=arr1[1];
int v3=arr1[2];
System.out.print(v1+","+v2+","+v3);
3. 遍历
遍历获取数组中，每个位置的值
可以通过length属性获取数组的长度
package com.qfedu;
public class Demo02 {
public static void main(String[] args) {
int arr[] = new int[5];
arr[0] =1;
arr[1] =2;
arr[2] =3;
arr[3] =4;
arr[4] =5;
/*
* 遍历数组
* n 0-n-1
*/
for(int i=0; i<=4; i++) {
int v = arr[i];
// System.out.println(v);
}
/*
* 很多时候，数组会作为一个参数，传递到方法中，数组的长度是不确定的
*
* 属性 和方法是相对的 表示一个东西是什么
*
* length 表示数据的长度
*
* 变量名.属性名 获取值，设置值
*
*/
int len = arr.length;
System.out.println(len);
for(int i=0; i<arr.length; i++) {
int v = arr[i];
System.out.println(v);
}
}
public static void max(int[] arr) {
}
}
4. 默认值
基本类型数组
1.1 整数 0 1.2小数 0.0 1.3布尔 false 1.4字符 0
引用类型数组
null
package com.qfedu;
public class Demo03 {
/*
* 数组的默认值
* 1. 基本类型数组
* 1.1 整数 0
* 1.2小数 0.0
* 1.3布尔 false
* 1.4字符 0
* 2. 引用类型数组
* null : 表示一个值，表示的是没有值得意思
*/
public static void main(String[] args) {
char[] arr = new char[5];
for(int i=0; i<arr.length; i++) {
System.out.println(arr[i]);
}
}
}
5. 数组的定义
package com.qfedu;
public class Demo04 {
/*
* 创建数组形式
*/
public static void main(String[] args) {
int[] arr = new int[3];
int arr2[] = new int[4];
arr2[0] = 3;
arr2[1] = 5;
arr2[2] = 7;
arr2[3] = 9;
/*
* 我们可以在创建数组变量
* 1. 确定数组的长度
* 2. 数组中每个元素的值，也确定了
*/
int[] arr3 = {3,5,7,9,11};
/*
* 如果想要先声明，然后初始化数组，并为每个元素赋值
* 1. 声明数组
* 2. 在初始化时， new 数据类型[]{初始化的值};
*/
int[] arr4 ;
arr4 = new int[]{3,5,7,9,11};
/*
* 使用三种方式，定义一个字符串数组
* 并保存三个值 “jackma” "pony" "tomlei"
*/
String[] arr = new String[3];
arr[0]="jackma";
arr[1]="pony";
arr[2]="tomlei";
String[] arr1= {"jackma","pony","tomlei"};
String[] arr2;
arr2=new String[] {"jackma","pony","tomlei"};
}
}
6. 数组的扩容
当我们定义一个数组时，一定要确定数组的长度
如果数组的长度一旦确定了，就无法改变
思路：
创建一个新的指定长度的数组
把原数组中值，添加到新数组指定位置
把新数组赋值给原数组变量
package com.qfedu; public class Demo05 { public static void main(String[] args) { int[] arr = new int[2]; arr[0] = 98; arr[1] = 99; //保存 100 88 /* * arr[2] = 100; arr[3] = 88; */ int[] arr2 = new int[4]; arr2[0] = arr[0]; arr2[1] = arr[1]; /* * 数组的扩容 * 1. 创建了我们想要容量长度的数组 * 2. 把数组中的元素，按照下标，把值保存到新数组中 * 3. 把新数组的值，赋值给原数组的变量 */ arr = arr2; /* * arr2[2] = 100; arr2[3] = 88; */ String[] strArr = {"jackma","pony","tomlei"}; /* * 1.把数组长度扩容为原来的三倍 * 2.继续追加值 “robin” "kobe" */ int length = strArr.length; String[] newArr = new String[length*3]; for(int i=0; i<strArr.length; i++) { newArr[i] = strArr[i]; } strArr = newArr; strArr[3] = "robin"; strArr[4] = "kobe"; } } 编写一个方法
有两个参数， 第一个参数为一个数组，第二个参数目标扩容后的长度
返回值也是一个数组
package com.qfedu;
import java.util.Arrays;
public class Demo05_2 {
public static void main(String[] args) {
int[] arr = {1,2,3}; //原数组
arr = expansionArr(arr,6);
System.out.println( Arrays.toString(arr) );
}
/*
* 编写一个方法
* 1. 有两个参数，
* 第一个参数为一个数组，第二个参数目标扩容后的长度
* 2. 返回值也是一个数组
*
*
* 如果目标长度小于原数组的长度，那么就返回原数组
*/
public static int[] expansionArr(int[] arr, int length) {
//进行判断
if(length<arr.length) {
return arr;
}
//创建一个目标长度的数组
int[] newArr = new int[length];
//把原数组中的值，全部按照下标放到新数组中
for(int i=0; i<arr.length; i++) {
newArr[i] = arr[i];
}
return newArr;
}
}
1.java.util.Arrays.copyOf(原数组, 新⻓度)。
-
返回带有原值的新数组。
2.System.arraycopy(原数组,原数组起始,新数组,新数组起始,⻓度)。
class Demo05{
public static void main(String[] args) {
int[] arr= {1,2,3};
/*
*java.util.Arrays.copyOf(原数组, 新⻓度)。
*返回带有原值的新数组。
*/
arr=Arrays.copyOf(arr,2);
System.out.println(Arrays.toString(arr));
int[] oldArr = {1,2,3,4};//原数组
int[] targetArr=new int[10];//目标数组 [0,0,0,0,0,0,0,0,0,0]
System.arraycopy( oldArr, 1,targetArr, 1,2);
System.arraycopy( oldArr, 0,targetArr, 3,1);
System.arraycopy( oldArr, 0,targetArr, 4,3);
System.out.println(Arrays.toString( targetArr));
int[] targetArr2=new int[oldArr.length*3];
System.arraycopy( oldArr, 0,targetArr2, 0,oldArr.length);
System.out.println(Arrays.toString( targetArr2));
}
}
7. 值传递，引用传递
在调用方法时，如果参数的数据类型为基本类型，那么在调用方法时，为参数赋值，传递的是值，如参数的数据类型为引用类型，那么传递的该引用类型值在堆中的地址，如果对该值发生修改，会改变原变量的值
本文含有隐藏内容，请 开通VIP 后查看