数组的定义
本质上就是存放相同类型的变量集合。例如：
public class test {
public static void main(String[] args) {
int[] array = {1,2,3,4,5};
double[] array = {1.0,2,3.0,4,5};
}
}
那是不是所有类型都可以用数组表示定义呢？
答案当然不是，boolean类型不能用数组定义。
数组的创建
数组的初始化有以下形式：
public static void main(String[] args) {
int[] array = {1,2,3};//静态初始化
int[] array2 = new int[]{1,2,3};//动态初始化
int[] array1 = new int[10];//只是定义了一个数组，默认值为0；
}
注意: 静态初始化的时候, 数组元素个数和初始化数据的格式要保持一致。
那该怎么计算数组长度？又怎么特定输出某个数组元素呢？
int[] array = {1,2,3};
//计算数组长度
int se = array.length;
System.out.println(se);
//访问某个数组元素
System.out.println(array[0]);//结果为1
System.out.println(array[1]);//结果为2
array[0] = 100;
System.out.println(array[0]);//结果为100
注意：
- 使用 arr.length 能够获取到数组的长度。"." 点号这个操作为成员访问操作符。 后面一般接属性，行为等。
- 使用 [ ] 按下标取数组元素。 需要知道下标从 0 开始计数的。
- 使用 [ ] 操作既能读取数据， 也能修改数据。
- 下标访问操作不能超出有效范围 [0, length - 1] ，如果超出有效范围,，会出现下标越界异常。
异常
越界异常
int[] array = new int[10];
System.out.println(array[20]);
//输出结果
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 20
at test.main(test.java:6)
空指针异常
int[] array = null;
System.out.println(array[2]);
//输出结果
Exception in thread "main" java.lang.NullPointerException
at test.main(test.java:6)
要出现异常时知道是什么异常，方便修正。
数组的遍历
数组的遍历是指访问数组中的每一个元素，做到不漏不错。通常是采用循环语句。
int[] array = {1, 2, 3};
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
使用for-each语句：
int[] array = {1, 2, 3};
for (int x : array) {
System.out.println(x);
}
这俩个循环语句都是可以遍历数组中所有的元素。
for-each 是 for 循环的另外一种使用方式. 能够更方便的完成对数组的遍历. 可以避免循环条件和更新语句写错。但是它不能访问数组下标的。
数组作为方法的参数
先来一个代码示例感受一下。
public static void main(String[] args) {
int[] array = {1,2,3};
printArray(array);//打印array数组内容
}
public static void printArray(int[] arr) {
for (int x:arr) {
System.out.println(x);
}
}
这就是一个方法的应用。int[] arr 是函数的形参, int[] array 是函数实参。
理解引用类型(重点/难点)
传参内置类型
public static void main(String[] args) {
int num = 0;
func(num);
System.out.println("num = " + num);
}
public static void func(int x) {
x = 10;
System.out.println("x = " + x);
}
// 执行结果
x = 10
num = 0
我们发现改变形参x,实参num没有改变。
画图解析：
Java中是按值传递，num 把值传递过去后，x接收，x的在内存上的改变并不影响num的值大小。
既然如此我们看以下这个代码：
public static void main(String[] args) {
int[] array = {1,2,3};
func(array);
System.out.println(array[0]);
}
public static void func(int[] arr) {
arr[0] = 99;
System.out.println(arr[0]);
}
//输出结果
arr[0] = 99;
array[0] = 99;
看到这个结果是不是特别惊讶，为什么没有返回值array[0] = 0？
答案：这是数组的引用。引用相当于一个 “别名”, 也可以理解成一个指针.
创建一个引用只是相当于创建了一个很小的变量, 这个变量保存了一个整数, 这个整数表示内存中的一个地址。看似是按值传递，其实是相当于传了这个原数组的内存地址。如下图：
1.开始的时候创建了一个内存，里面放了1，2，3。
2.相当于将上一个内存地址传给了arr[],指向array[]的内存；
3.将arr[0]的值改成了99；因为是指向同一地址，
所以array[0]也改成了99。
public static void main(String[] args) {
int[] array = {1,2,3};
transform(array);
System.out.println(array);
}
public static void transform(int[] arr) {
for (int i = 0; i < arr.length; i++) {
arr[i] = arr[i] * 2;
}
System.out.println(arr);
}
//输出结果
array：2，4，6
arr：2，4，6
看这个代码有什么问题吗？
这个代码固然可行, 但是破坏了原有数组。有时候我们不希望破坏原数组, 就需要在方法内部创建一个新的数组, 并由方法返回出来。
public static void main(String[] args) {
int[] array = {1,2,3};
transform(array);
System.out.println(array);
}
public static void transform(int[] arr) {
int[] ret = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
ret[i] = arr[i] * 2;
}
System.out.println(arr);
}
//输出结果
array：1，2，3
arr：2，4，6
数组转字符串
/**
普通实现版本
*/
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
System.out.println(toString(arr));
}
public static String toString(int[] array) {
String arr1 = "[";
for (int i = 0; i <array.length ; i++) {
arr1 += array[i];
if(i != array.length - 1) {
arr1 += ",";
}
}arr1 += "]";
return arr1;
}
/**
Array 方法版本
*/
import java.util.Arrays
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6};
String newArr = Arrays.toString(arr);
System.out.println(newArr);
}
// 执行结果
[1, 2, 3, 4, 5, 6]
数组拷贝
import java.util.Arrays
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6};
int[] newArr = Arrays.copyOf(arr, arr.length);
System.out.println("newArr: " + Arrays.toString(newArr));
}
public static String toString(int[] array) {
arr[0] = 10;
System.out.println("arr: " + Arrays.toString(arr));
System.out.println("newArr: " + Arrays.toString(newArr));
}
该方法为深拷贝。
深拷贝：在拷贝过程中不会修该原数组的值；
浅拷贝：在拷贝过程中会修改原数组的值；
数组的拷贝共有四种方法：
1、for循环去拷贝
2、System.arraycopy
3、Arrays.copyOf
4、数组名.clone(); clone是Object的方法
返回一个副本
数组名->你要拷贝的数组
二分查找
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6,7,8,9};
int[] newArr = Arrays.copyOf(arr, arr.length);
System.out.println("二分查找:" + binarySearch(newArr,5,arr.length));
}
public static int binarySearch(int[] array,int key,int right) {
int left = 0;
if(left > right) {
return -1;
}
int mid = (left+right) >>> 1;
if(array[mid] == key) {
return mid;
}else if (array[mid] < key) {
return binarySearch(array,key,left = mid+1);
}else {
return binarySearch(array,key,right = mid-1);
}
}
针对有序数组, 使用更高效的二分查找.
啥叫有序数组?
有序分为 “升序” 和 “降序”
如 1 2 3 4 , 依次递增即为升序.
如 4 3 2 1 , 依次递减即为降序.
以升序数组为例, 二分查找的思路是先取中间位置的元素, 看要找的值比中间元素大还是小. 如果小, 就去左边找; 否则就去右边找.代码如上。
学习Arrays类当中的方法：
Arrays.toString();//输出数组
Arrays.copyOf();//拷贝数组
Arrays.copyOfRange();//拷贝部分数组 [ )左闭右开形式
Arrays.binarySearch();//二分查找 [ )左闭右开形式
Arrays.equals();//判断数组是否相同
Arrays.fill(array,9); //数组的填充
Arrays.fill(array,2,7,88);[2,7)//下标填充为88 [ )左闭右开形式
Arrays.sort(array);//将数组进行排序
二维数组
二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组.
public static void main10(String[] args) {
//二维数组
int[][] array = {{1,2,3},{4,5,6}};
int[][] array2 = new int[][]{{1,2,3},{4,5,6}};
int[][] array3 = {{1,2},{4,5,6}};
/**
都可以用以下方式输出二维数组
*/
for (int i = 0; i < array3.length; i++) {
for (int j = 0; j < array3[i].length; j++) {
System.out.print(array3[i][j] + " ");
}
}
小技巧
可变参数编程
public static void main(String[] args) {
System.out.println(sum(1,2,3,4,5));
System.out.println(sum(1,2,3,4,5,6));
}
public static int sum(int... array) {
int ret = 0;
for (int x:array) {
ret += x;
}
return ret;
}
看代码中一个方法就可以完成同类型的多个参数的多次调用,极大的方便了实际的需要。
Java中数组的冒泡排序，二分查找，顺序查找，最大值，最小值，数组逆序，数组数字排列等代码看以下链接：
https://blog.youkuaiyun.com/QDNBD/article/details/102656055
扫一扫
958
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
