文章目录
一、数组作为参数
1.数组的引用指向一个新的对象
import java.util.Arrays;
public class ArrayParameter {
public static void main(String[] args) {
int[] array = {0, 1};
newArray(array);
System.out.println(Arrays.toString(array));
}
public static void newArray(int[] array) {
array = new int[] {1, 2, 3, 4, 5};
}
}
上述代码的结果为[0, 1]。
由于形参中的引用变量array指向一个新的对象,导致函数中的array存储的地址与主函数中的实参引用变量array的值不同。所以无法通过这个方法改变实参array的值。
2.数组的引用指向数组的一个变量。
import java.util.Arrays;
public class ArrayParameter {
public static void main(String[] args) {
int[] array = {0, 1};
newArray(array);
System.out.println(Arrays.toString(array));
}
public static void newArray(int[] array) {
array[0] = 5;
array = new int[] {1, 2, 3, 4, 5};
}
}
这样结果会变为[5, 1]
因为形参array所存储的地址是与实参array存储的地址一样的,所以两个参数指向了同一个对象,所以可以直接对指向的对象的值进行修改。
import java.util.Arrays;
public class ArrayParameter {
public static void main(String[] args) {
int[] array = {0, 1};
newArray(array);
System.out.println(Arrays.toString(array));
int[] array2 = {1, 2, 3, 4};
array = array2;
array2[2] = 51;
System.out.println(Arrays.toString(array));
}
public static void newArray(int[] array) {
array[0] = 5;
array = new int[] {1, 2, 3, 4, 5};
}
}
其实上述代码的主函数的后面片段与方法的实现是一样的,因为array和array2存储的地址变得一样了所以array2的值被改变,array所指向的值也被变化。
3.数组作为返回值
数组在java中是可以作为返回值的哦,尽管在C中是不可以作为返回值的。
public static int[] multiplyTwo(int[] array) {
int i = 0;
int[] result = new int[array.length];
for (i = 0; i < array.length; i++) {
result[i] = 2*array[i];
}
return result;
}
二、数组的初始化与赋值方法
int[] array = {0, 1};
int[] array = new int[] {1, 2, 3, 4, 5};
注意,这里的第二种赋值方法中的new int[]中的[ ] 中不能存放数字。并且上面上述代码中的任意一个[ ]中都不能存放数字。
三、数组的打印
public class ArrayPrint {
public static void main(String[] args) {
int[] array = {0, 1, 2, 3};
print(array);
}
public static void print(int[] array) {
for(int x : array) {
System.out.print(x + " ");
}
}
}
for each循环打印代码,用于不需要获取数组下标的情况。
import java.util.Arrays;
System.out.println(Arrays.toString(array));
这种打印运用了工具类Array,需要在使用前声明。这种将打印出来[0, 1, 2, 3]。
三、工具类Arrays中的方法使用
注意哦,使用Arrays需要在开头声明 import java.util.Arrays;
1. Arrays.toString
import java.util.Arrays;
System.out.println(Arrays.toString(array));
toString方法可以将数组以字符串的形式返回。形如:[1, 2, 3, 4]
2. Arrays.binarySearch
int[] array = {1, 5, 7, 9};
int a = 0;
a = Arrays.binarySearch(array, 0);
System.out.println("The number " + 0 + " is in index " + a);
只可以用二分法寻找有序数列的特定元素的下标。
3. Arrays.sort
int[] array = {1, 2, 3, 55, 3, 3, 5, 2, 1};
Arrays.sort(array);
String arr = Arrays.toString(array);
System.out.println(arr);
Arrays.sort可以将数组从小到大排序。
4.Arrays.fill
Arrays.fill其实是具有重载的方法,具有两种参数类型
两个参数与四个参数
int[] array = new int[7];
Arrays.fill(array, 6);
System.out.println(Arrays.toString(array));
Arrays.fill(array, 3, 5, 8);
System.out.println(Arrays.toString(array));
输出结果
[6, 6, 6, 6, 6, 6, 6]
[6, 6, 6, 8, 8, 6, 6]
注意拥有四个参数的fill方法的第二个与第三个参数是左闭右开区间。
import java.util.Arrays;
public class FillTwo {
public static void main(String[] args) {
int[] array = new int[8];
System.out.println(Arrays.toString(array));
Arrays.fill(array, 1, 4, 6);
System.out.println(Arrays.toString(array));
}
}
[0, 0, 0, 0, 0, 0, 0, 0]
[0, 6, 6, 6, 0, 0, 0, 0]
这样数组会被先赋值0。
5.克隆数组(包括与C语言之间的区别)
import java.util.Arrays;
public class CopyOne {
public static void main(String[] args) {
int[] array = {0, 1, 2, 3};
int[] array2 = array;
System.out.println(Arrays.toString(array2));
}
}
这样子克隆出来的数组会互相影响,因为存储的地址一样,只要一个数组的值改变两个数组对应的值都会改变。
而C语言中数组的复制就不能像上面那样操作。
#include <stdio.h>
int main() {
int array[] = { 0, 1, 2, 3, 4 };
int array2[5] = array;
int i = 0;
for (i = 0; i < sizeof(array2) / sizeof(int); i++) {
printf("%d ", array2[i]);
}
return 0;
}
上面的代码会报错。
import java.util.Arrays;
public class CopyDirectly {
public static void main(String[] args) {
double[] array = {0, 1.1, 2.2, 3.3, 4.4};
double[] array2 = Arrays.copyOf(array, array.length * 2);
double[] array3 = Arrays.copyOf(array, array.length - 3);
double[] array4 = Arrays.copyOfRange(array, 1, 2);
System.out.println(Arrays.toString(array2));
System.out.println(Arrays.toString(array3));
System.out.println(Arrays.toString(array4));
}
}
[0.0, 1.1, 2.2, 3.3, 4.4, 0.0, 0.0, 0.0, 0.0, 0.0]
[0.0, 1.1]
[1.1]
上面是代码的运行结果。
public static int[] copyArray(int[] array) {
int[] copy = new int[array.length];
for (int i = 0; i < array.length; i++) {
copy[i] = array[i];
}
return copy;
}
当然,你也可以通过上面的方式遍历数组进行数组的拷贝。
import java.util.Arrays;
public class CopyQuickly {
public static void main(String[] args) {
double[] array = {1.2, 2.2, 2.3, 3.3};
double[] copy = new double[array.length];
System.arraycopy(array, 0, copy, 0, array.length);
System.out.println(Arrays.toString(copy));
}
}
这样的拷贝数组的方式会更快一点因为System.arraycopy是native修饰的方法,由C或C++实现。