Java数组基础
目录
- 一、基本要点
- 二、定义、赋值
-
- 2.1 数组定义
- 2.2 数组赋值
- 三、数组索引的使用
- 四、数组循环遍历
-
- 4.1 普通for循环
- 4.2 增强型foreach
- 五、数组、字符串的逆置
-
- 3.1 数组的逆置
- 3.2 字符串的逆序
- 六、字符串格式化
- 七、“是否找到”问题
- 八、参数传递（引用传递、值传递）
- 九、二维数组
-
- 9.1 定义
- 9.2 二维数组与一维数组的关系
- 十、数组复制
-
- 10.1 引用复制与遍历值复制
- 10.2 System.arraycopy（）方法
- 十一、Arrays类
-
- 11.1 Arrays类简介
- 11.2 copyOf()用法
- 11.3 toString()方法
- 11.4 equals()方法
- 11.5 fill()方法
- 11.6 binarySearch()方法
一、基本要点
- 数组是最常见的一种数据结构，是将数据按照线性顺序连续存储的序列。
- 数组存储和访问元素的效率最高。
二、定义、赋值
2.1 数组定义
int[] array1; //更符合原理
int array2[]; //更符合原始编程习惯
//元素类型可以是基本数据类型或者引用类型
String[] array3;
2.2 数组赋值
- 赋值的元素类型即为数组类型（基本数据类型、引用类型都可以）
- 初始化赋值后数组长度固定不变。（若要改变长度，只能重新定义）
//基本数据类型定义与赋值
int[] array11 = new int[10]; //长度初始化，元素为默认值
int[] array12 = new int[] {
1,2,3,4,5}; //标准初始化
int[] array13 = {
5,63,9,8}; //省略初始化-仅用于初始化
int[] array14;
//引用类型定义与赋值
String[] a1; //没有对象
String[] a2 = new String[] {
}; //有对象，长度为0
Integer[] a3 = new Integer[] {
}; //有对象，长度为0
//此方法展示先定义后初始化的3种情况
@Test
public void finit() {
array14 = new int[5];
array14 = new int[] {
6,3};
//array14 = {4,6,8}; 此种赋值不允许
System.out.println(a1);
System.out.println(a2);
System.out.println(a3);
System.out.println(array11);
System.out.println(array12);
System.out.println(array13);
}
输出：
null
[Ljava.lang.String;@262b2c86
[Ljava.lang.Integer;@371a67ec
[I@5ed828d
[I@50d0686
[I@7a3d45bd
输出时，自动调用toString方法，@符号右边的是引用类型在内存中地址的16进制的数，左侧中括号代表数组（1个代表一维数组，2个代表二维数组），I是int首字母的大写。a1没有对象，所以为null。
三、数组索引的使用
- 数组是简单的线性数列，所以访问速度很快。
- 每个元素拥有一个索引值（下标），通过索引检索访问该元素。
public void print(int[] c) {
for (int i = 0; i <= c.length - 1; i++) {
System.out.println("c[" + i + "]=" + c[i]);
}
}
@Test
public void index() {
int[] array = new int[3]; // index从0开始，最大数组长度为lenth-1
array[0] = 10;
array[1] = 11;
array[2] = 12;
// array[4] = 5; 赋值错误，数组索引越界 会引发异常
int k1 = array[1]; // 取值
System.out.println(k1);
print(array);
}
输出：
11
c[0]=10
c[1]=11
c[2]=12
例题：
长度为10的数组，随机生成元素，元素范围为-50~150
public void randomInt() {
int[] arr = new int[10];
Random random = new Random();
for (int i = 0; i <= arr.length - 1; i++) {
arr[i] = random.nextInt(200) - 50;
}
print(arr);
}
输出：
143
7
-25
108
-11
56
86
91
-23
38
四、数组循环遍历
4.1 普通for循环
//循环遍历
public void print(int[] c) {
for (int i = 0; i <= c.length - 1; i++) {
System.out.println("c[" + i + "]=" + c[i]);
}
}
4.2 增强型foreach
- 格式：for(A:B){C}，for（变量类型 变量名称 ： 数组变量）{循环体}
- 变量类型是数组的元素类型
- 变量名称对应的是数组中的每个元素
- 每次遍历数组的一个元素，赋值给循环变量，都会执行一次循环体。
public void print(int[] c) {
for (int k : c) {
System.out.println(k);
}
}
五、数组、字符串的逆置
3.1 数组的逆置
public void invert1() {
// 数组倒置后输出
int c[] = new int[] {
10, 20, 32, -3, 69, -56, 66 };
int temp;
for (int m = 0, n = c.length - 1; m < n; m++, n--) {
temp = c[m];
c[m] = c[n];
c[n] = temp;
}
for (int i = 0; i < c.length; i++) {
System.out.print(c[i] + " ");
}
}
输出：
66 -56 69 -3 32 20 10
3.2 字符串的逆序
public void invert2() {
// 字符串倒置
String s = "abclpyhg";
char[] ch = s.toCharArray();
char temp;
for (int m = 0, n = ch.length - 1; m < n; m++, n--) {
temp = ch[m];
ch[m] = ch[n];
ch[n] = temp;
}
System.out.println(new String(ch)); // 调用String(char value[]) {}构造方法
}
输出：
ghyplcba
输出的应为字符串，所以通过 System.out.println(new String(ch)); 将ch通过构造函数转化为String类型。
六、字符串格式化
- String类的format()方法用于创建格式化的字符串以及连接多个字符串对象。
| 转换符 | 说明 | 示例 |
|---|---|---|
| %s | 字符串类型 | “ming” |
| %c | 字符类型 | ‘m’ |
| %b | 布尔类型 | true |
| %d | 十进制整数 | 66 |
| %x | 十六进制整数 | FF |
public void format() {
String name1 = "aaa";
String name2 = "bbb";
String result = String.format("name1=%s,name2=%s", name1, name2);
System.out.println(result);
}
输出：
name1=aaa,name2=bbb
七、“是否找到”问题
给定一个数，判断是否能够在数组中找到这个数？
代码1：
public void f51() {
// 是否找到
int c[] = new int[] {
10, 20, 32, -3, 69, -56, 66 };
int k = 32;
for (int i = 0; i <= c.length - 1; i++) {
if (k == c[i]) {
System.out.println("找到");
return;
}
}
System.out.println("没找到");
}
代码2：
public void f52() {
int c[] = new int[] {
10, 20, 32, -3, 69, -56, 66 };
int k = 32;
boolean temp = false;
for (int i = 0; i <= c.length - 1; i++) {
if (k == c[i]) {
temp = true;
}
}
if (temp) {
System.out.println("找到");
} else {
System.out.println("没找到");
}
}
输出：
找到
八、参数传递（引用传递、值传递）
public void functionA(int[] array, int t) {
array = new int[] {
6, 7, 8, 9 };
for (int i = 0; i <= array.length - 1; i++) {
array[i] *= 2;
}
t += 5;
System.out.println("\nt=" + t);
}
@Test
public void functionB() {
int[] array = {
1, 2, 3, 5 };
System.out.println("未传递前数组元素为：");
print(array);
int t = 2;
functionA(array, t); //引用传递与值传递
System.out.println("\nt=" + t + "\n+++++++已传递后数组元素为：");
print(array);
}
输出：
未传递前数组元素为：
1
2
3
5
t=7
t=2
+++++++已传递后数组元素为：
1
2
3
5
为什么functionB中输出的 t=2？
答：因为t为基本数据类型，参数传递过程中传递的是值。传递完后functionA()中对参数的操作不会影响到functionB()中t的值。
如果将functionA（）中的array = new int[] { 6, 7, 8, 9 };去掉，则代码变为：
public void functionA(int[] array, int t) {
//array = new int[] { 6, 7, 8, 9 };
for (int i = 0; i <= array.length - 1; i++) {
array[i] *= 2;
}
t += 5;
System.out.println("\nt=" + t);
}
@Test
public void functionB() {
int[] array = {
1, 2, 3, 5 };
System.out.println("未传递前数组元素为：");
print(array);
int t = 2;
functionA(array, t); //引用传递与值传递
System.out.println("\nt=" + t + "\n+++++++已传递后数组元素为：");
print(array);
}
输出：
未传递前数组元素为：
1
2
3
5
t=7
t=2
+++++++已传递后数组元素为：
2
4
6
10
可以发现去掉后数组array的值发生了变化，这是因为引用类型传递的是地址，在B方法调用A方法时，将参数地址传递给了数组参数，也就是说，这时在A中的数组和B中的数组指向的是同一个内容，两者对内容的操作都会改变内容的值。
在没去掉array = new int[] { 6, 7, 8, 9 };之前，在A方法中虽然起初是被赋值了同一地址，但是经过new之后在A中的array指向了另外的内容，所以对另外内容的操作，不会影响原来的内容。
九、二维数组
9.1 定义
public class Array2_1 {
// 定义：
int[][] arr1;
int arr2[][];
int[] arr3[];
// 初始化
int[][] arr4 = new int[2][3];
int[][] arr5 = new int[][] {
{
1, 2, 3 }, {
5, 6, 7, 9 } };
int[][] arr6 = {
{
1, 2, 3 }, {
5, 6, 7, 9 } };
// 特殊初始化
int[][] arr7 = new int[2][];
int[] aa1 = arr6[0];
int[][] aa2 = new int[][] {
};
}
练习1：
public void f1() {
System.out.println(arr7[0]);
System.out.println(new int[2]);
System.out.println(aa2);
System.out.println(aa2.length);
}
结果：
null
[I@4923ab24
[[I@44c8afef
0
练习2：
public void f2() {
System.out.println(arr7.length);// 2
arr7[0] = new int[] {
1, 2, 3 };
System.out.println(arr7[0].length);
}
结果：
2
3
9.2 二维数组与一维数组的关系
- 二维数组是以行和列存储的，第一个下标代表所在行，第二个下标代表所在列，左行右列。
- 二维数组也可以看做数组的数组，即它是一个特殊的一维数组，其中每个元素又是一个一维数组。
十、数组复制
10.1 引用复制与遍历值复制
遍历复制代码：
public void f1() {
int[] array1 = new int[] {
5, 4, 3, 2, 1 };
int[] array2 = new int[array1.length];
System.out.print("array1为：");
print(array1);
System.out.println();
System.out.print("array2为：");
print(array2);
for (int i = 0; i < array1.length; i++) {
array2[i] = array1[i];
}
System.out.println();
System.out.print("复制后array2为：");
print(array2);
}
结果：
array1为：5 4 3 2 1
array2为：0 0 0 0 0
复制后array2为：5 4 3 2 1
10.2 System.arraycopy（）方法
方法介绍：
JDK中定义的arraycopy():
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
- 第一个参数：来源数组名称
- 第二个参数：来源数组的起始位置
- 第三个参数：目的数组的名称
- 第四个参数：目的数组的起始位置
- 第五个参数：来源数组中需要复制元素的个数长度
代码：
// 在System类中提供了一个特殊的方法：arraycopy()
@Test
public void function2() {
int[] arr1 = new int[] {
5, 6, 9, 8, 7 };
int[] arr2 = new int[arr1.length];
System.arraycopy(arr1, 0, arr2, 0, arr1.length);
System.out.println("arr2复制后为：");
print(arr2);
}
结果：
arr2复制后为：
5 6 9 8 7
十一、Arrays类
11.1 Arrays类简介
Arrays类包含了用来操作数组的各种方法，是数组的一个方法类。
11.2 copyOf()用法
JDK代码介绍：
public static int[] copyOf(int[] original, int newLength) {
}
- Arrays的copyOf()方法传回的数组是新的数组对象。
- copyOf()的第二个变量指定要建立的新数组长度。
copyOf()使用：
public void function3() {
int[] arr1 = new int[] {
5, 6, 9, 8, 7 };
int[] arr2 = new int[arr1.length];
System.arraycopy(arr1, 0, arr2, 0, 5);
int[] arr3 = Arrays.copyOf(arr1, arr1.length);
print(arr2);
System.out.println();
print(arr3);
}
结果：
5 6 9 8 7
5 6 9 8 7
11.3 toString()方法
public static String toString(int[] a) {
}
参数为数组，将数组按照默认格式输出为字符串。
代码实例：
public void function3() {
int[] arr1 = new int[] {
5, 6, 9, 8, 7 };
System.out.println(Arrays.toString(arr1));
}
结果：
[5, 6, 9, 8, 7]
11.4 equals()方法
public static boolean equals(int[] a, int[] a2) {
}
比较两个数组的元素是否相等，返回值为boolean类型,参数为两个数组。
代码示例：
public void function4() {
int[] arr1 = new int[] {
5, 6, 9, 8, 7 };
int[] arr2 = new int[] {
5, 6, 9, 8, 7 };
int[] arr3 = arr1;
int[] arr4 = new int[8];
System.out.println(Arrays.equals(arr1, arr2)); //内容相同
System.out.println(arr1==arr2); //new出来的，引用不同
System.out.println(Arrays.equals(arr1, arr4));
System.out.println(arr1==arr3);
}
结果：
true
false
false
true
11.5 fill()方法
向数组中填充数据。
代码演示：
public void function5() {
int[] array = new int[5];
// 向数组中填充1
Arrays.fill(array, 1);
System.out.println(Arrays.toString(array));
// 向数组中索引号为[1,3)的元素进行填充0
Arrays.fill(array, 1, 3, 0);
System.out.println(Arrays.toString(array));
}
结果：
[1, 1, 1, 1, 1]
[1, 0, 0, 1, 1]
上述代码用到了2个fill()方法：
方法1：
public static void fill(int[] a, int val) {
for (int i = 0, len = a.length; i < len; i++)
a[i] = val;
}
向数组a中填充数据val。
方法2：
public static void fill(int[] a, int fromIndex, int toIndex, int val) {
rangeCheck(a.length, fromIndex, toIndex);
for (int i = fromIndex; i < toIndex; i++)
a[i] = val;
}
在数组a的索引为[1,3)的位置处插入val。
11.6 binarySearch()方法
binarySearch(object[ ], object key)如果key在数组中，则返回搜索值的索引；否则返回-1或者”-“(插入点)。插入点是索引键将要插入数组的那一点，即第一个大于该键的元素索引。
代码：
public void f5() {
String[] s1 = {
"aaa", "bbb", "ccc", "ddd" };
int index1 = Arrays.binarySearch(s1, "aaa");
System.out.println(index1);
int index2 = Arrays.binarySearch(s1, "ppp");
System.out.println(index2);
}
结果：
0
-5
数据必须是已排序的才可以使用binarySearch方法。