【Java SE】详解数组

前言：在C语言中我们已经学习过数组，接下来，我们再主要学习一下Java中的数组，在Java中，数组变得更加高效和使用。

---

1. 数组的基本概念

1.1 什么是数组？

数组：可以看成是相同类型元素的一个集合。 

1. 数组中存放的元素其类型相同
2. 数组的空间是连在一起的
3. 每个空间有自己的编号，其实位置的编号为0，即数组的下标。

---

 1.2 数组的创建及初始化 

 1.2.1 数组的创建

数据类型[]  数组名称 = new 数据类型[数组的长度]

int[] array1 = new int[10];    // 创建一个可以容纳10个int类型元素的数组
double[] array2 = new double[5];  // 创建一个可以容纳5个double类型元素的数组
String[] array3 = new double[3];  // 创建一个可以容纳3个字符串元素的数组 

  1.2.2 数组的初始化

  数组的初始化主要分为动态初始化以及静态初始化。 

1. 动态初始化：在创建数组时，直接指定数组中元素的个数

int[] array = new int[10]

这种写法就直接固定了数组的个数

 2.静态初始化：在创建数组时不直接指定数据元素个数，而直接将具体的数据内容进行指定

语法格式： 数组类型[] 数组名称 = {data1, data2, data3, ..., datan};

int[] array1 = new int[]{0,1,2,3,4,5,6,7,8,9};
double[] array2 = new double[]{1.0, 2.0, 3.0, 4.0, 5.0};
String[] array3 = new String[]{"hell", "Java", "!!!"};

【注意事项】
静态初始化虽然没有指定数组的长度，编译器在编译时会根据{}中元素个数来确定数组的长度。
静态初始化时, {}中数据类型必须与[]前数据类型一致。
静态初始化可以简写，省去后面的new T[]。

// 注意：虽然省去了new T[], 但是编译器编译代码时还是会还原
int[] array1 = {0,1,2,3,4,5,6,7,8,9};
double[] array2 = {1.0, 2.0, 3.0, 4.0, 5.0};
String[] array3 = {"hell", "Java", "!!!"}; 

一般我们都是以这种方法写出来的，比较高效简洁

注： C语言中 int arr[] = {1,2,3} 这样写法也可以，但是在Java中最好使用 int[] arr = {1,2,3}

 习惯得改掉

 注意事项:

 这个必须得一步到位，

int[] array1;
array1 = new int[10];
int[] array2;
array2 = new int[]{10, 20, 30};
// 注意省略格式不可以拆分, 否则编译失败
// int[] array3;
// array3 = {1, 2, 3}; 

---

如果没有对数组进行初始化，数组中元素有其默认值
如果数组中存储元素类型为基类类型，默认值为基类类型对应的默认值，比如：

 

 在Java中 ，默认值不会存随机值 

如果是整形类型 那个默认就放0

如果是引用类型 默认放得值为null

如果是boolean类型 默认为false

 

 如果数组中存储元素类型为引用类型，默认值为null

---

 1.3 数组的使用

 1.3.1 数组中元素访问

数组在内存中是一段连续的空间，空间的编号都是从0开始的，依次递增，该编号称为数组的下标，数组可以通过下标访问其任意位置的元素。比如： 

 

 【注意事项】
1. 数组是一段连续的内存空间，因此支持随机访问，即通过下标访问快速访问数组中任意位置的元素
2. 下标从0开始，介于[0, N）之间不包含N，N为元素个数，不能越界，否则会报出下标越界异常。

抛出了 java.lang.ArrayIndexOutOfBoundsException 异常. 使用数组一定要下标谨防越界.

---

1.3.2 遍历数组 

所谓 "遍历" 是指将数组中的所有元素都访问一遍, 访问是指对数组中的元素进行某种操作，比如：打印。

这是最基本的打印：

1. 如果数组中增加了一个元素，就需要增加一条打印语句
2. 如果输入中有100个元素，就需要写100个打印语句
3. 如果现在要把打印修改为给数组中每个元素加1，修改起来非常麻烦。

则可以使用循环来进行打印：

这是用的常见的方法：

 int[] array = {10, 20, 30, 40, 50};for (int i = 0 ; i < array.length; i++) {System.out.println(i);}

Java内不需要求数组的长度 里面配置了快捷方法

直接在数组.length  

就可以直接算出数组的长度

也可以使用 for-each 遍历数组 这是Java中有的方法

for-each 是 for 循环的另外一种使用方式，能够更方便的完成对数组的遍历

第一个参数是打印的值

第二个参数是数组名

---

还有一直方法打印成字符串打印出来：Arrays.toString   用String 类型的参数接收

---

2. 数组是引用类型

基本类型变量与引用类型变量的区别：

基本数据类型创建的变量，称为基本变量，该变量空间中直接存放的是其所对应的值；
而引用数据类型创建的变量，一般称为对象的引用，其空间中存储的是对象所在空间的地址。

 在上述代码中，a、b、arr，都是函数内部的变量，因此其空间都在main方法对应的栈帧中分配。
a、b是内置类型的变量，因此其空间中保存的就是给该变量初始化的值。
array是数组类型的引用变量，其内部保存的内容可以简单理解成是数组在堆空间中的首地址。 

从上图可以看到，引用变量并不直接存储对象本身，可以简单理解成存储的是对象在堆中空间的起始地址。通过该地址，引用变量便可以去操作对象。有点类似C语言中的指针，但是Java中引用要比指针的操作更简单。 

---

认识null

null 在 Java 中表示 "空引用" , 也就是一个不指向对象的引用.

 解析：null 的作用类似于 C 语言中的 NULL (空指针), 都是表示一个无效的内存位置. 因此不能对这个内存进行任何读写操作. 一旦尝试读写, 就会抛出 NullPointerException.

注意: Java 中并没有约定 null 和 0 号地址的内存没有任何关联.

---

3. 数组的应用场景 

3.1 保存数据

public class Test {public static void main(String[] args) {int[] array = {1, 2, 3};for(int i = 0; i < array.length; i++){System.out.println(array[i] + " ");}}
}

3.2 作为函数的参数 

public static void main(String[] args) {int[] arr = {1, 2, 3};func(arr);System.out.println("arr[0] = " + arr[0]);}public static void func(int[] a) {a[0] = 10;System.out.println("a[0] = " + a[0]);}

// 执行结果
a[0] = 10
arr[0] = 10

因为数组是引用类型，按照引用类型来进行传递，是可以修改其中存放的内容的。相当于C语言中的传地址参数

---

3.3 作为函数的返回值

在Java中 数组也可以作为返回值被带回来

    public static int[] func(int[] arr) {for (int i = 0; i < arr.length ; i++) {arr[i] *= 2;}return arr;}public static void main(String[] args) {int[] arr = {1,3,5};int[] str = func(arr);for (int x:str) {System.out.print(x+" ");}}

 解析：Java中可以拿数组做为返回值，只需要拿数组接收就行，高效

---

4.数组练习 （重点）

4.1 数组转字符串

 

解析：Java中提供了  Arrays.toString()函数

()里面是数组名就行 

打印的就是字符串

 模拟实现 Arrays.toString()函数:

public class Test {public static String myToString(int[] array) {//判断数组是否为空if (array == null) {return null;}String ret = "[";for (int i = 0; i < array.length ; i++) {ret += array[i];if (i != array.length-1) {ret += ", ";}}ret += "]";return  ret;}public static void main(String[] args) {int[] array = {1,2,3,4,5,6};String ret = myToString(array);System.out.println(ret);}
}

 4.2 数组拷贝(重点)

拷贝：将一个数组的内容拷贝到另一个数组

 这种方法是最基本的拷贝到另一个数组，效率比较低

接下来我们介绍Java中特有的方法 比较高效

高效方法：

 

Java中提供了函数，可以直接进行拷贝

Arrays.copyOf()函数

第一个参数为数组名

第二个参数为你要拷贝的长度 .length可以直接求出长度

这种直接赋值给自己，还可以进行扩大内存

原来的内存空间会消失，会开辟出一块新的内存空间

 Arrays.copyOfRange()函数可以拷贝范围

第一个参数为数组名

第二个参数为拷贝开始的数组下标

第三个参数为拷贝结束的数组下标

from 1 to 3

从1下标到3下标

左闭右开 [ 1 , 3 ); 所以取不到3下标的元素

 

 System.arraycopy()函数 也是拷贝  它一个有5个参数

第一个参数为拷贝的源地址

第二个参数为拷贝开始的下标

第三个参数为拷贝的目标地址

第四个参数为拷贝的目标开始下标

第五个参数为拷贝的长度

注：

这种可不是拷贝，这叫做赋值

因为它们所指向的还是同一块内存 

引用了同一个数组  这不是拷贝

---

4.3 查找数组中指定元素(二分查找)

二分查找的前提是数组已经排序好，不是乱序

这种算法效率较高 不是遍历所有数组去找 

 

代码实现：

public class Test {public static int binarySearch(int[] array,int key) {int left = 0;int right = array.length-1;while (left <= right) {int mid = (left + right) / 2;if (array[mid] < key) {left = mid +1;} else if (array[mid] > key) {right = mid -1;} else {return mid;}}return -1;}public static void main(String[] args) {int[] array = {1,3,44,11,22,145,2};Arrays.sort(array);Scanner scanner = new Scanner(System.in);int key = scanner.nextInt();int ret = binarySearch(array,key);//找到了 ，返回它的下标  找不到返回- 1System.out.println(ret);}
}

接下里Java中内置了二分查找函数，更加方便

Arrays.sort()函数 是给你的数组自动排序

 Array.binarySearch()函数：

 

4.4 数组排序(冒泡排序)

上一篇文章详细讲过

完整代码：

public class Test {public static void bubbleSort(int[] arr) {for (int i = 0; i < arr.length - 1 ; i++) {boolean flag = false;for (int j = 0; j < arr.length - 1 - i; j++) {if (arr[j] > arr[j+1]) {int tmp = arr[j];arr[j] = arr[j+1];arr[j+1] =tmp;flag = true;}}if (flag == false) {return ;//说明已经有序}}}public static void main(String[] args) {int[] arr = {9, 5, 2, 7};bubbleSort(arr);System.out.println(Arrays.toString(arr));}
}

冒泡排序性能较低. Java 中内置了更高效的排序算法

可以直接用 Arrays.sort()函数实现

4.5 介绍Java中几个内置数组的函数 (重点)

 Arrays.equals(arr1,arr2)函数

判断俩个数组是否相等

相等返回ture 反正false

 

---

 Arrays.fill()函数

可以填充数组里面的内容

第一个参数为数组

第二个参数为填充的值

 Arrays.fill()函数也可以进行局部添加 

 

---

5.二维数组

二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组.

 int[][] array1 = {1,2,3,4,5,6};

//这种写法是错误的，在Java中不能这样写

 

正确写法：

int[][] array2 = {{1,2,3},{4,5,6}};

int[][] array3 = new int[2][3]// 默认为0

打印遍历整个数组 ： 

 

 

---

在Java中，定义的时候可以省略列，但不是省略行

int[][] array = new int[2][];

但是我们可以给它new一个一维数组对象出来

array[0] = new int[3];

array[1] = new int[5];

 

注：这个可以打印不规则的数组的，并不会全部补全 

---

总结：  

后期博主会陆续更新Java SE的知识

如有不足之处欢迎补充交流

看到这里的友友们，支持一下博主，来个免费三连，感谢! ! !