数组概念与Java数组基础操作略解析

见“Java学习”一帖

数组

概念

单个变量无法存储多个数据，亦无法统一操作，故引入数组的概念

数组(Array)：一段连续内存空间+相同类型元素+用下标访问

即：线性表的顺序存储结构

下标：arr[i]里i即为该数组的下标，如0是arr[0]的下标，一切编程语言里数组的下标皆自0起

核心特性：

 ①：连续存储性（※）

内存中是这样的：

arr[0] arr[1] arr[2] arr[3]
1000 1004 1008 1012
地址是连续的

②：随机访问性(O(1))

访问的本质是：
地址 = 起始地址 + index × 元素大小
arr[i]为什么很快的原因
因为它不需要要遍历地址而是直接计算地址！！！！！！！！！！！

③：类型一致性

int[] arr; 只能放 int
float[] arr; 只能放 float
Java是强类型语言，不能混放！

 Java里数组的定义与初始化

数组的声明

声明：指定存储数据的类型和数组名称

int[] arr_1; Java数组的标准声明
int arr_2[]; C语言写法，Java亦可用

数组的初始化

方式一 静态初始化

静态初始化 → 直接给出值列表

int[] arr = {1,2,3,4,5};
int[] arr = new int[]{1,2,3,4,5};
第一个为第二个的简写形式，二者等价

方式二 动态初始化

动态初始化 → 只给长度，值由 JVM 填默认值

引入关键字new 

声明只给变量名，new才给真正的存储空间

语法：数据类型 名称 = new 数据类型 [ ];

int[] arr = new int [5];

默认值

public class Main {
public static void main(String[] args) {
int[] arr = new int[5];
for (int i = 0; i < arr.length; i++) {
System.out.printf("该数组第%d个下标对应的初始值为%d\\n", i, arr[i]);
}
System.out.println("==========================");
float[] arr_1 = new float[10];
for (int i = 0; i < arr.length; i++) {
System.out.printf("该数组第%d个下标对应的初始值为%f\\n", i, arr_1[i]);
}
System.out.println("==========================");
String[] arr_2 = new String[5];
for (int i = 0; i < arr_2.length; i++) {
System.out.printf("该数组第%d个下标对应的初始值为%s\\n", i, arr_2[i]);
}
System.out.println("==========================");
boolean[] arr_3 = new boolean[5];
for (int i = 0; i < arr_3.length; i++) {
System.out.printf("该数组第%d个下标对应的初始值为%b\\n", i, arr_3[i]);
}
}
}

该数组第0个下标对应的初始值为0
该数组第1个下标对应的初始值为0
该数组第2个下标对应的初始值为0
该数组第3个下标对应的初始值为0
该数组第4个下标对应的初始值为0
==========================
该数组第0个下标对应的初始值为0.000000
该数组第1个下标对应的初始值为0.000000
该数组第2个下标对应的初始值为0.000000
该数组第3个下标对应的初始值为0.000000
该数组第4个下标对应的初始值为0.000000
==========================
该数组第0个下标对应的初始值为null
该数组第1个下标对应的初始值为null
该数组第2个下标对应的初始值为null
该数组第3个下标对应的初始值为null
该数组第4个下标对应的初始值为null
==========================
该数组第0个下标对应的初始值为false
该数组第1个下标对应的初始值为false
该数组第2个下标对应的初始值为false
该数组第3个下标对应的初始值为false
该数组第4个下标对应的初始值为false

进程已结束，退出代码为 0

这表明在Java中，数组的确具有初始默认值

 数组的访问

利用 数组名[下标] 访问数组

如：

public class Main {
public static void main(String[] args) {
int [] a = new int [5];
a[0] = 1;
a[1] = 2;
a[2] = 3;
a[3] = 4;
a[4] = 5;
System.out.println(a[0]);
System.out.println(a[1]);
System.out.println(a[2]);
System.out.println(a[3]);
System.out.println(a[4]);
}
}

结果：
1
2
3
4
5

以上过程曰：访问

访问的同时可以修改元素 如可直接修改a[1] = 114514;

访问不能超过数组的最大下标，否则会报错，报错曰：越界

下标区间[0,length – 1]

越界示例：

 数组的遍历

对数组中的数据进行一一访问的过程叫做遍历

两种遍历方法

for循环遍历

最常用的遍历方法

数组名.length         –>此数组的长度

public class Main {
public static void main(String[] args) {
int [] a = new int [5];
a[0] = 1;
a[1] = 2;
a[2] = 3;
a[3] = 4;
a[4] = 5;
for(int i = 0; i < a.length; i++){
System.out.printf("数组第%d个下标元素的数据为：%d\\n",i,a[i]);
}
}
}

增强for循环

只读，不能修改原数组

语法：for(元素类型 变量名:数组名)

public class Main {
public static void main(String[] args) {
int[] b;
b = new int[3];
b[0] = 1;
b[1] = 2;
b[2] = 3;
for (int j : b) {
System.out.println(j);
}
}
}

结果：
1
2
3

 一维数组的基本应用

倒叙打印

比如有数组 arr = {1,2,3,4,5}

正序打印为：1,2,3,4,5

则倒序打印为：5,4,3,2,1

public class Main {
public static void main(String[] args) {
int [] arr = {1,2,3,4,5};
for(int i = arr.length – 1;i>=0;i–){
System.out.println(arr[i]);
}
}
}

结果
5
4
3
2
1

应当说明长度：length
arr数组下标最大为4
arr数组元素有5个
arr数组长度为5
故：arr数组下标 = arr数组长度 – 1
即：i = arr.length – 1
for循环进行对arr数组的遍历次数i对应arr数组的下标
故有int i = arr.length – 1;
只不过：
int i = 0; i<arr.length – 1;i++ 是自最小下标开始遍历，到最大下标结束遍历
int i = arr.length – 1;i>=0;i– 是自最大下标开始遍历，到最小下标结束遍历

讨论与区分

均设数组 arr = {1,2,3,4,5}
int i = 0; i<arr.length – 1;i++
int i = 0; i<arr.length;i++
int i = 0; i<=arr.length – 1;i++
int i = 0; i<=arr.length;i++

我们知道：arr.length-1表示arr数组的最大下标

此处：arr.length = 5        故arr数组最大下标为4

则 arr.length-1 = 5-1 = 4       

一、i<arr.length-1=4  –>  i<4,则遍历下标0~3

则输出：1，2，3，4

二、i<arr.length –> i<5,则遍历0~4
则输出：1,2,3,4,5

三、i<=arr.length-1 –> i<=4,则遍历0~4 等价于 二
则输出：1,2,3,4,5

四、i<=arr.length –> i<=5超过了最大下标4 越界！
但编译正确，运行会报错！！！！！！！！！！

 求平均值

public class Main {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
int sum=0;
int result = 0;
for(int i=0;i<arr.length;i++)
{
sum+=arr[i];
}
result = sum / arr.length;
System.out.printf("该数组的平均值为：%d",result);
}
}

结果：
该数组的平均值为：3

打印最值

public class Main {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
int max = arr[0];
int min = arr[0];
for(int i=0;i<arr.length;i++)
{
if(arr[i]>max) {
max = arr[i];
}
if(arr[i]<min){
min=arr[i];
}
}
System.out.printf("该数组的最大元素为：%d\\n",max);
System.out.printf("该数组的最小元素为：%d\\n",min);

}
}

结果如下：
该数组的最大元素为：5
该数组的最小元素为：1

public class Main {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
int max = arr[0];
int min = arr[0];
for(int i=0;i<arr.length;i++)
{
if(arr[i]>max) {
max = arr[i];
}
if(arr[i]<min){
min=arr[i];
}
}
for(int i=0;i<arr.length;i++){
if(max>arr[i]){
System.out.printf("除开最大值的其它元素为：%d\\n",arr[i]);
}
}
System.out.println("==========================");
for(int i=0;i<arr.length;i++){
if(min<arr[i]){
System.out.printf("除开最小值的其它元素为：%d\\n",arr[i]);
}
}
System.out.println("==========================");
for(int i=0;i<arr.length;i++){
if(max>arr[i] || max<arr[i]){
System.out.printf("除开最值的其它元素为：%d\\n",arr[i]);
}
}

}
}

结果如下：
除开最大值的其它元素为：1
除开最大值的其它元素为：2
除开最大值的其它元素为：3
除开最大值的其它元素为：4
==========================
除开最小值的其它元素为：2
除开最小值的其它元素为：3
除开最小值的其它元素为：4
除开最小值的其它元素为：5
==========================
除开最值的其它元素为：1
除开最值的其它元素为：2
除开最值的其它元素为：3
除开最值的其它元素为：4

Scanner与数组

import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请录入该数组的长度");
int n = sc.nextInt();
int[] arr = new int[n];
for (int i = 0; i < arr.length; i++) {
System.out.printf("该数组第%d个元素为：\\n",i+1);
arr[i] = sc.nextInt();
}
}

结果如下：
请录入该数组的长度
5
该数组第1个元素为：
1
该数组第2个元素为：
2
该数组第3个元素为：
3
该数组第4个元素为：
4
该数组第5个元素为：
5

案例1

import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
float[] score = new float[5];
System.out.println("请录入5份成绩");
for(int i =0;i<score.length;i++){
System.out.printf("请输入第%d份成绩：\\n",i+1);
score[i]=sc.nextFloat();
if(score[i]<0 || score[i]>100){
System.out.println("成绩无效！！！");
i–;
}
}
System.out.println("倒序成绩");
float sum = 0;
for(int i =score.length -1;i>=0;i–){
System.out.println(score[i]);
sum+=score[i];
}
float result = sum / score.length;
System.out.printf("平均成绩为：%f\\n",result);

System.out.println("请输入一个成绩：");
float s = sc.nextFloat();
float[] sss = new float[1];
sss[0] = s;
for(int i =0;i<score.length;i++){
if(sss[0]<score[i])
System.out.printf("比所录入成绩大的有：%d\\n",score[i]);
}
}
}

结果如下：
请录入5份成绩
请输入第1份成绩：
99.5
请输入第2份成绩：
89
请输入第3份成绩：
78
请输入第4份成绩：
66.5
请输入第5份成绩：
46
倒序成绩
46.0
66.5
78.0
89.0
99.5
平均成绩为：75.800003
请输入一个成绩：
67
比所录入成绩大的有：99.5
比所录入成绩大的有：89.0
比所录入成绩大的有：78.0

案例2

import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入数组长度：");
int n = sc.nextInt();
int[] arr = new int[n];
System.out.println("请录入相应的元素");
for(int i =0;i<arr.length;i++) {
System.out.printf("请输入第%d个元素：\\n", i + 1);
arr[i] = sc.nextInt();
}
int max = arr[0];
int min = arr[0];
for(int j =0;j<arr.length;j++){
if(arr[j]>max){
max=arr[j];
}
if(arr[j]<min){
min=arr[j];
}

}System.out.printf("最大值为：%d\\n",max);
System.out.printf("最小值为：%d\\n",min);

}

}

结果如下：
请输入数组长度：
6
请录入相应的元素
请输入第1个元素：
1
请输入第2个元素：
2
请输入第3个元素：
3
请输入第4个元素：
4
请输入第5个元素：
5
请输入第6个元素：
6
最大值为：6
最小值为：1

案例3

import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入该数组的长度");
int n = sc.nextInt();
char[] c = new char[n];
System.out.println("请输入数组存储的数据");
for(int i = 0; i < c.length; i++) {
System.out.printf("第%d个数据为：%c\\n",i+1,n);
c[i] = sc.next().charAt(0);
}
int num = 0;
for(int i = 0; i < c.length; i++) {
if(c[i]>='a' && c[i]<='z') {
num++;
}
}
System.out.printf("统计小写字母的个数为：%d\\n",num);

}
}

结果如下：

请输入该数组的长度
10
请输入数组存储的数据
第1个数据为：

A
第2个数据为：

B
第3个数据为：

C
第4个数据为：

D
第5个数据为：

E
第6个数据为：

f
第7个数据为：

g
第8个数据为：

h
第9个数据为：

i
第10个数据为：

j
统计小写字母的个数为：5

案例4

import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请录入数组的长度：");
int n = sc.nextInt();
int[] arr = new int[n];
System.out.println("请输入数组的元素");
for (int i = 0; i < arr.length; i++) {
System.out.printf("第%d个元素为：",i+1);
arr[i] = sc.nextInt();
}
System.out.println("倒序遍历：");
for(int i = arr.length-1;i>=0;i–){
System.out.println(arr[i]);
}
}
}

结果如下：
请录入数组的长度：
10
请输入数组的元素
第1个元素为：1
第2个元素为：2
第3个元素为：3
第4个元素为：4
第5个元素为：5
第6个元素为：6
第7个元素为：7
第8个元素为：8
第9个元素为：9
第10个元素为：10
倒序遍历：
10
9
8
7
6
5
4
3
2
1

案例5

0

import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
float[] scores = new float[5];
System.out.println("请输入五位评委的分数");
for(int i = 0;i<scores.length;i++){
System.out.printf("第%d个元素分数为：",i+1);
scores[i]=sc.nextFloat();
}
float max = scores[0];
float min = scores[0];
for(float score:scores) {
if (score > max) {
max = score;
}
if (score < min) {
min = score;
}
}
System.out.println("去掉一个最高分和最低分后：");
float sum = 0;
float result = 0;
for(float score:scores) {
if(score!=max && score!=min){
sum+=score;
result = sum / 3;
}
}
System.out.printf("则最终平均分数为：%f\\n",result);
}
}

结果如下：
请输入五位评委的分数
第1个元素分数为：99
第2个元素分数为：88
第3个元素分数为：77
第4个元素分数为：66
第5个元素分数为：55
去掉一个最高分和最低分后：
则最终平均分数为：77.000000

常见算法操作

查找

线性查找(O(n))

二分查找(O(log n))

排序

冒泡排序(O(n²))

选择排序

插入排序

快速排序（※）

归并排序（递归）

插入与删除

 二维数组

在Java中，二维数组不是“真正的二维连续内存”，而是[数组的数组]

二维数组的定义与初始化

二维数组的声明

int[][] arrs;

初始化

静态初始化

int[][] arr = {{1,2,3},{4,5,6},{7,8,9},{10,11,12},{13,14,15}};
或者写成这样：
int[][] arr = {
{1,2,3},
{4,5,6},
{7,8,9},
{10,11,12},
{13,14,15}
};

动态初始化

int[][] arr = new int[3][3];

访问

import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[][] arr = {
{1,2,3},
{4,5,6},
{7,8,9},
{10,11,12},
{13,14,15}};
System.out.println(arr[0][0]);
System.out.println(arr[2][1]);
System.out.println(arr[3][2]);
}
}
结果如下：
1
8
12
对于二维数组int[][] arrs = new int [] [];
左[]元素在x行，右[]在y行 ( x,y!=0 )
设某个元素按行，列的坐标为(x,y)
由于数组的索引皆自0起
“变换”后得到数组坐标(x-1,y-1)
如元素"1",位于(1，1) –>(1-1,1-1)=(0,0)
元素"13",位于(5,1) –>(5-1,1-1)=(4,0)
该数组能存储x * y个元素
若按照x行，y列 允许x,y=0
则按部就班，1在第0行，第0列，则直接有坐标：(0,0)

遍历

import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[][] arr = {
{1,2,3},
{4,5,6},
{7,8,9},
{10,11,12},
{13,14,15}};
for(int i = 0; i < arr.length; i++) {
for(int j = 0; j < arr[i].length; j++) { arr[i].length 表示第i行的长度
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
}

 二维数组的一些基础操作

例1：

一、                二、计算该矩阵元素之和及平均值（浮点型）

打印矩阵

1 2 3

4 5 6

7 8 9

import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[][] arr = new int[3][3];
for(int i = 0; i < arr.length; i++){
for(int j = 0; j < arr[i].length; j++){
System.out.printf("请输入第(%d,%d)个元素",i,j);
arr[i][j] = sc.nextInt();
}
}
System.out.println("打印数组：");
for(int i = 0; i < arr.length; i++){
for(int j = 0; j < arr[i].length; j++){
System.out.print(arr[i][j] + " ");
}
System.out.println();
}
}
}

结果如下：
请输入第(0,0)个元素1
请输入第(0,1)个元素2
请输入第(0,2)个元素3
请输入第(1,0)个元素4
请输入第(1,1)个元素5
请输入第(1,2)个元素6
请输入第(2,0)个元素7
请输入第(2,1)个元素8
请输入第(2,2)个元素9
打印数组：
1 2 3
4 5 6
7 8 9

第二问

import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[][] arr = new int[3][3];
for(int i = 0; i < arr.length; i++){
for(int j = 0; j < arr[i].length; j++){
System.out.printf("请输入第(%d,%d)个元素",i,j);
arr[i][j] = sc.nextInt();
}
}
System.out.println("计算总和");
int sum = 0;
float result = 0;
for(int i = 0;i<arr.length;i++){
for(int j = 0; j<arr[i].length;j++){
sum = sum +arr[i][j];
}
}
System.out.println("结果为："+sum);
System.out.println("计算平均值");
result = (float) sum / 9;
System.out.println("平均值为："+result);

}
}

结果如下：
计算总和
结果为：45
计算平均值
平均值为：5.0

例2：

有一个学生成绩表，每行是一个学生的各科成绩：

85 92 78

90 88 95

76 89 80        计算每个学生的总分

public class Main {
public static void main(String[] args) {
int[][] scores = {{85,92,78},{90,88,95},{76,89,80}};
for(int i = 0;i<scores.length;i++){
int sum_x = 0; 每遍历完一行，均令sum_x = 0
for(int j = 0;j<scores[i].length;j++){
sum_x = sum_x + scores[i][j];
}
System.out.println("第"+i+"行"+"的成绩为"+sum_x);
}
}
}

结果如下：
第0行的成绩为255
第1行的成绩为273
第2行的成绩为245

改行为列，列表总分，求列总分数

public class Main {
public static void main(String[] args) {
int[][] scores = {{85,92,78},{90,88,95},{76,89,80}};
for(int j = 0; j<scores[0].length; j++){
int sum_y = 0;
for(int i = 0;i<scores[j].length;i++){
sum_y = sum_y + scores[i][j];
}
System.out.println("第"+j+"列"+"的成绩为"+ sum_y);
}
}
}

结果如下：
第0列的成绩为251
第1列的成绩为269
第2列的成绩为253

scores[0].length表示第零列的长度，java中列的长度只能间接的表示，规则矩阵一般拿第零行作总列数
若不规则矩阵如：
1
2 3
4 5 6
1对应第0行，其列长度为arr[0].length
2、3对应第1行，其长度为arr[1].length
推广至一般
arr[i].length

Scanner与二维数组

import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("请输入行数 ");
int HangA = sc.nextInt();
System.out.print("请输入列数 ");
int LieA = sc.nextInt();
System.out.printf("已明确矩阵的行数为%d,列数为%d\\n",HangA,LieA);
int[][] JU_Zhen = new int[HangA][LieA];
for (int i = 0; i < HangA; i++) {
for (int j = 0; j < LieA; j++) {
System.out.printf("请输入第(%d,%d)个元素",i,j);
JU_Zhen[i][j] = sc.nextInt();
}
}
System.out.println("打印矩阵");
for (int i = 0; i < HangA; i++) {
for (int j = 0; j < LieA; j++) {
System.out.print(JU_Zhen[i][j] + " ");
}
System.out.println();
}

}
}

结果如下：
请输入行数 4
请输入列数 4
已明确矩阵的行数为4,列数为4
请输入第(0,0)个元素1
请输入第(0,1)个元素2
请输入第(0,2)个元素3
请输入第(0,3)个元素4
请输入第(1,0)个元素5
请输入第(1,1)个元素6
请输入第(1,2)个元素7
请输入第(1,3)个元素8
请输入第(2,0)个元素9
请输入第(2,1)个元素0
请输入第(2,2)个元素9
请输入第(2,3)个元素8
请输入第(3,0)个元素7
请输入第(3,1)个元素6
请输入第(3,2)个元素5
请输入第(3,3)个元素4
打印矩阵
1 2 3 4
5 6 7 8
9 0 9 8
7 6 5 4

函数的调用与二维数组

import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入二维数组的行数：");
int HangB = sc.nextInt();
System.out.println("请输入二维数组的列数：");
int LieB = sc.nextInt();
System.out.printf("已明确二维数组的行数为%d,列数为%d\\n",HangB,LieB);
int[][] A = new int[HangB][LieB]; 主函数定义一个数组A，作实际参数
for (int i = 0; i < HangB; i++) {
for (int j = 0; j < LieB; j++) {
System.out.printf("请输入(%d,%d)的元素\\n",i,j);
A[i][j] = sc.nextInt();
}
}
int[][] result = text(A); 定义一个新数组result接受text(A)返回的值B
System.out.println("将为您打印这个数组…");
for (int i = 0; i < result.length; i++) {
for (int j = 0; j < result[i].length; j++) {
System.out.print(result[i][j] + " ");
}
System.out.println();
}

}
public static int[][] text(int[][] A){
int Hang = A.length;
int Lie = A[0].length;
int[][] B = new int[Hang][Lie];
for (int i = 0; i < Hang; i++) {
for (int j = 0; j < Lie; j++) {
B[i][j] = A[i][j]; 此处可是模板
}
}
return B; 此函数将返回B数组
}
}

注：
public static int[][] text(int[][] A)
此函数的功能是：遍历二维数组->对每个元素做某种处理->放进新数组->返回

结果如下：
1 2 3 4 5 6
7 8 9 0 9 8
7 6 5 4 3 2
1 2 3 4 5 6
7 8 9 0 9 8
7 6 5 4 3 2

 arrays类

Arrays类，即java.util.Arrays 是专门操作数组的“工具箱”,覆盖数组的排序、查找、填充、复制、比较、格式转换等操作。可直接通过Arrays.方法名()调用

要求：使用前必须先导包

import java.util.Arrays;

打印功能

System.out.println(Arrays.toString(arr)); arr为一维数组名
代替：
for(int i = 0; i<arr.length; i++){
System.out.println(arr[i] + " ");
}

System.out.println(Arrays.deepToString(arrs)); arrs为二维数组
代替：
for(int i = 0; i<arrs.length ;i++){
for(int j = 0; j<arrs[i].length ;j++){
System.out.println(arrs[i][j] + " ");
}
System.out.println();
}

例子：

import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
System.out.println("一维数组的Arrays打印");
System.out.println(Arrays.toString(arr));

System.out.println("一维数组的for循环遍历打印");
for(int i=0;i<arr.length;i++){
System.out.println(arr[i] + " ");
}
System.out.println("ending…");

int[][] arrs = {{1,2,3,4},{11,22,33,44}};
System.out.println("二维数组的Arrays打印");
System.out.println(Arrays.deepToString(arrs));

System.out.println("二维数组的for循环打印");
for(int i=0;i<arrs.length;i++){
for(int j=0;j<arrs[i].length;j++){
System.out.println(arrs[i][j] + " ");
}
}
System.out.println("ending…");
}
}

结果如下：
一维数组的Arrays打印
[1, 2, 3, 4, 5]
一维数组的for循环遍历打印
1
2
3
4
5
ending…
二维数组的Arrays打印
[[1, 2, 3, 4], [11, 22, 33, 44]]
二维数组的for循环打印
1
2
3
4
11
22
33
44
ending…

排序功能

Arrays.sort((arr)); 默认升序排列

一维数组arr的升序排列
Arrays.sort(arr);
打印出来：System.out.println(Arrays.toString((arr));

二维数组arrs的升序排列
Arrays.sort(arr,(a,b) -> a[i] – b[i]); 列排序
打印出来：System.out.println(Arrays.deepToString(arrs));

import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int [] arr = {9,8,7,6,5,4,3,2,1,0};
Arrays.sort(arr);
System.out.println("排序：");
System.out.println(Arrays.toString(arr));
System.out.println();
int [][] arrs = {
{12,13},
{23,222},
{1,0},
{61,10}};
Arrays.sort(arrs,(a,b) ->a[1] – b[1]);
System.out.println(Arrays.deepToString(arrs));
}
}

结果如下：

排序：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

[[1, 0], [61, 10], [12, 13], [23, 222]]

填充功能

import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] arr = new int[5];
Arrays.fill(arr, 114514);
System.out.println(Arrays.toString(arr));
System.out.println();

int [][] arrs = new int[5][5];
for (int i = 0; i < arrs.length; i++) {
Arrays.fill(arrs[i], 0);
System.out.println(Arrays.toString(arrs[0]));
}
}
}
结果如下：
[114514, 114514, 114514, 114514, 114514]

[0, 0, 0, 0, 0]
[0, 0, 0, 0, 0]
[0, 0, 0, 0, 0]
[0, 0, 0, 0, 0]
[0, 0, 0, 0, 0]

比较功能

import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int[] brr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int[] crr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};
System.out.println(Arrays.equals(arr,brr));
System.out.println(Arrays.equals(arr,crr));
}
}

结果如下：
true
false

拷贝功能

import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int[] brr = Arrays.copyOf(arr, arr.length);
int[] crr = Arrays.copyOf(arr, 11);
int[] drr = Arrays.copyOf(arr, 5);
System.out.println(Arrays.toString(arr));
System.out.println(Arrays.toString(brr));
System.out.println(Arrays.toString(crr));
System.out.println(Arrays.toString(drr));
}
}

结果如下：
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0]
[1, 2, 3, 4, 5]