前言：数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同,Java 语言中提供的数组是用来存储固定大小的同类型元素。
✨✨✨这里是秋刀鱼不做梦的BLOG
✨✨✨想要了解更多内容可以访问我的主页秋刀鱼不做梦-CSDN博客
先让我们看一下本篇文章的大致内容：
目录
1.数组的定义与创建
（1）数组的定义
（2）数组的创建及初始化
补充：
（1）数组的创建及初始化的分离
（2）数组不进行初始化时会有默认值
2.数组的遍历
（1）使用for循环
（2）使用增强for循环
（3）使用Array.toString方法
3.数组中常用的API
（1）binarySearch
（2）copyOf
（3）copyOfRange
（4）equals
（5）fill
（6）sort
（7）toString
4.二维数组
（1）二维数组的定义
（2）二维数组的遍历
【1】使用for循环
【2】使用增强for循环
【3】使用Array.deepToString方法
1.数组的定义与创建
从前言中我们可以知道数组可以看成是相同类型元素的一个集合，在内存中是一段连续的空间。那么数组是如何定义的呢？
（1）数组的定义
数组的定义如下：
T[] 数组名 = new T[N] ;
其中：
T：表示数组中存放元素的类型。 T[ ]：表示数组的类型。 N：表示数组的长度。
看了上边数组的定义之后还是不太懂到底数组是如何定义的，那么可以看一下下面的案例进一步理解。
int[] array1 = new int[10]; // 一个可以容纳10个int类型元素的数组
double[] array2 = new double[5]; // 一个可以容纳5个double类型元素的数组
String[] array3 = new double[3]; // 一个可以容纳3个字符串元素的数组
这样我们就大致了解了数组的定义形式了，那么数组又该如何去进行创建呢？
（2）数组的创建及初始化
对于数组的创建及初始化大致可以分为两种：动态初始化 和 静态初始化
先来看一下动态创建及初始化：
动态创建及初始化：在创建数组时，直接指定数组中元素的个数。
int[] array = new int[10] ;
细心的读者可以发现，这种初始化和上文数组定义时举出的案例十分相似，是的，在之前的数组定义时举出的案例就是三个动态创建及初始化。（这里在展示一次）
int[] array1 = new int[10]; // 创建一个可以容纳10个int类型元素的数组
double[] array2 = new double[5]; // 创建一个可以容纳5个double类型元素的数组
String[] array3 = new double[3]; // 创建一个可以容纳3个字符串元素的数组
看完动态创建及初始化后，在来看一下静态创建及初始化：
静态创建及初始化：在创建数组时不直接指定数据元素个数，而直接将具体的数据内容进行指定。
T[] 数组名称 = {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", "!!!"};
当然，对于静态创建及初始化java中提供了一种缩写形式，即可以将等号后面的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", "!!!"};
注意：
1. 静态初始化虽然没有指定数组的长度，编译器在编译时会根据{}中元素个数来确定数组的长度。 2. 静态初始化时, {}中数据类型必须与[]前数据类型一致。 3. 静态初始化可以简写，省去后面的new T[]。
这样我们就大致的了解了数组的动态创建及初始化 和 静态创建及初始化
补充：
（1）数组的创建及初始化的分离
对于数组的创建及初始化，我们可以先进行创建，在初始化，将创建和初始化分开，例如：
动态初始化：
//创建和初始化分开
int[] array;
array = new int[10];
//创建和初始化合在一起
int[] array = new int[10];
静态初始化：
//创建和初始化分开
int[] array;
array = new int[]{1, 2, 3, 4, 5};
//创建和初始化合在一起
int[] array = new int[]{1, 2, 3, 4, 5};
但是要注意：当我们将创建和初始化分开写的时候，就不可以写静态初始化的简写形式了！
（2）数组不进行初始化时会有默认值
如果没有对数组进行初始化，数组中元素有其默认值,不同类型的数组默认值如下：
类型默认值byte0short0int0long0float0.0fdouble0.0char/u0000booleanfalse
这样我们就大致的了解了数组的定义与创建了。
2.数组的遍历
我们知道数组在内存中是连续的，那么我们如何去遍历数组中的数据呢？大致有三种方式。
（1）使用for循环
大致代码如下：
//使用for循环
int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
（2）使用增强for循环
大致代码如下：
//使用增强for循环
int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
for(int number : array){
System.out.print(number+" ");
}
在增强for循环的内部int number 为从数组中每次取出的数据，而array及所要遍历的数组。
（3）使用Array.toString方法
大致代码如下：
//导入包
import java.util.Arrays;
//使用Array.toString方法
int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
System.out.println(Arrays.toString(array));
这样我们就了解了java中数组如何进行遍历了。
3.数组中常用的API
说在前面：对于Java中数组的常用API，其方法都在java.util.Arrays包下，所以使用时要进行导包：
import java.util.Arrays;
在 IntelliJ IDEA 编译器中，其会帮助我们自动进行导包。
那么让我们先来看一下有哪些常用的数组API：
我们一个一个进行讲解：
（1）binarySearch
binarySearch方法的作用：binarySearch方法是用来在数组中查找指定数据的，其返回值为想要查找的数据对应的索引值。
例如：
import java.util.Arrays;
public class java2024_5_9 {
public static void main(String[] args) {
int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
//在数组中查找数字5数据的索引值
int index = Arrays.binarySearch(array, 5);
System.out.println(index);
}
}
当然，以上情况是可以在数组中找到找到对应的数据的索引的（数字5在数组中），那么如果数据不在数组中呢？（如下）
import java.util.Arrays;
public class java {
public static void main(String[] args) {
int[] array = {1,2,3,4,5,6,7};
//在数组中查找数字10对应的索引
int index = Arrays.binarySearch(array, 10);
System.out.println(index);
}
}
我们可以发现其返回值为负数，这就代表了数字10不在对应的数组中！
这样我们就大致了解了binarySearch方法的使用了。
（2）copyOf
copyOf方法的作用：用于拷贝数组中的内容的。（可以拷贝全部，也可以拷贝一部分）
例如：
import java.util.Arrays;
public class java {
public static void main(String[] args) {
int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
//拷贝数组array
int[] ret = Arrays.copyOf(array, array.length);
//遍历数组
for (int i = 0; i < ret.length; i++) {
System.out.print(ret[i] + " ");
}
}
}
当然，我们也可以只拷贝从开头的一部分：
import java.util.Arrays;
public class java {
public static void main(String[] args) {
int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
//拷贝数组array，但是只拷贝5个数字
int[] ret = Arrays.copyOf(array, 5);
//遍历数组
for (int i = 0; i < ret.length; i++) {
System.out.print(ret[i] + " ");
}
}
}
这样我们就大致了解了copyOf方法的使用了。
（3）copyOfRange
copyOfRange方法的作用：用于拷贝数组中的内容的。（可以拷贝全部，也可以拷贝一部分）。
我们会发现copyOfRange方法和copyOf方法都是拷贝数组的，那么它们有什么区别呢？
区别——copyOfRange可以拷贝任何一段数组，而copyOf只能从头开始拷贝。
例如：
import java.util.Arrays;
public class java {
public static void main(String[] args) {
int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
//拷贝数组array中索引从3到5的数据
int[] ret = Arrays.copyOfRange(array, 3,6);
//遍历数组
for (int i = 0; i < ret.length; i++) {
System.out.print(ret[i] + " ");
}
}
}
注意：拷贝索引值包括前面的，但是不包括后面的！
这样我们就大致了解了copyOfRange方法的使用了。
（4）equals
equals方法的作用：用于比较两个数组中的数据内容是否相等。
例如：
import java.util.Arrays;
public class java {
public static void main(String[] args) {
int[] array1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int[] array2 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int[] array3 = {1, 2, 3, 4, 5, 6, 7, 8};
//比较array1和array2
System.out.println(Arrays.equals(array1,array2));
//比较array1和array3
System.out.println(Arrays.equals(array1,array3));
}
}
这样我们就大致了解了equals方法的使用了。
（5）fill
fill方法的作用：用于将数组中的所有数据都填充为特定值。
例如：
import java.util.Arrays;
public class java {
public static void main(String[] args) {
int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
//将数组中的所有数字填充为100
Arrays.fill(array, 100);
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
}
这样我们就大致了解了fill方法的使用了。
（6）sort
sort方法的作用：用于排序数组。
例如：
import java.util.Arrays;
public class java {
public static void main(String[] args) {
int[] array = {1, 4, 3, 5, 8, 7, 6, 2, 9, 10};
//对数组进行排序
Arrays.sort(array);
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}
}
当然我们会发现其默认的排序方式为升序，那么如何将其排为降序呢？之后学习了比较器之后才可以进行降序，这里不进行讲解。
这样我们就大致了解了sort方法的使用了。
（7）toString
toString方法的作用：用于将数组打印成字符串的形式。
例如：
import java.util.Arrays;
public class java {
public static void main(String[] args) {
int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
System.out.println(Arrays.toString(array));
}
}
这样我们就大致了解了toString方法的使用了。
4.二维数组
（1）二维数组的定义
二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组，定义二维数组的方式为：
数据类型[][] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 } ;
用一个例子帮助你进一步理解：
//定义一个二维数组
int[][] arr = {{1, 2, 3, 4},{5, 6, 7, 8},{9, 10, 11, 12}};
对于二维数组中的每一个一维数组，数组中的内容要使用{ }括起来，当然二维数组的用法和一维数组并没有明显差别, 因此我们不再赘述。
（2）二维数组的遍历
对于二维数组的遍历，其也分为使用for循环、使用增强for循环和使用Array.deepToString方法。
接下来我们直接使用案例来分别看一下三中遍历方式：
【1】使用for循环
例子：
public class java {
public static void main(String[] args) {
int[][] array = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
//遍历二维数组
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array[i].length; j++) {
System.out.print(array[i][j] + " ");
}
System.out.println();
}
}
}
【2】使用增强for循环
例子：
public class java {
public static void main(String[] args) {
int[][] array = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
//遍历二维数组
for (int[] ret : array) {
for (int number : ret) {
System.out.print(number + " ");
}
System.out.println();
}
}
}
【3】使用Array.deepToString方法
例子：
public class java {
public static void main(String[] args) {
int[][] array = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
//遍历二维数组
System.out.println(Arrays.deepToString(array));
}
}
这样我们就大致了解了二维数组的使用规则。
以上就是本篇文章的所有内容了~~~
文章链接
发表评论