活动地址：CSDN21天学习挑战赛

---

一、数组是什么？

数组就是用来存储一批同种类型数据的内存区域（可以理解成容器）。们可以把它看作是一个类型的所有数据的一个集合，并用一个数组下标来区分或指定每一个
数。

二、数组声明创建

1、声明数组

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：

dataType[] arrayRefVar; // 首选的方法 
或 dataType arrayRefVar[]; 
// 效果相同，但不是首选方法 
1
2
3

建议使用 dataType [ ] arrayRefVar 的声明风格声明数组变量

2、创建数组

Java语言使用new操作符来创建数组，语法如下：

arrayRefVar = new dataType[arraySize];
1

数组的元素是通过索引访问的。数组索引从 0 开始，所以索引值从 0 到 arrayRefVar.length-1。

• 一、使用 dataType[arraySize] 创建了一个数组。
• 二、把新创建的数组的引用赋值给变量 arrayRefVar。

获取数组长度：

arrays.length
1

3、内存分析

1. 声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM才分配空间，这时才与长度有关。因此，声明数组时不能指定其长度(数组中元素的个数)，例如： int a[5]; //非法
2. 声明一个数组的时候并没有数组被真正的创建。
3. 构造一个数组，必须指定长度

//1.声明一个数组 
int[] myList = null;
1
2

//2.创建一个数组
 myList = new int[10];
1
2

4.三种初始化

• 静态初始化

int[] a = {1,2,3}; 
Man[] mans = {new Man(1,1),new Man(2,2)};
1
2

• 动态初始化

int[] a = new int[2];
 a[0]=1;  a[1]=2;
1
2

• 数组的默认初始化
  数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

public static void main(String[] args) { 
int[] a=new int[2];
 boolean[] b = new boolean[2]; 
 String[] s = new String[2]; 
 System.out.println(a[0]+":"+a[1]); //0,0 
 System.out.println(b[0]+":"+b[1]);//false,false 
 System.out.println(s[0]+":"+s[1]);//null, null 
  }
1
2
3
4
5
6
7
8

5、数组边界

下标的合法区间：[0, length-1]，如果越界就会报错；

ArrayIndexOutOfBoundsException : 数组下标越界异常！

三、Arrays 类

数组的工具类java.util.Arrays，由于数组对象本身并没有什么方法可以供我们调用,但API中提供了一个工具类Arrays供我们使用,从而可以对数据对象进行一些基本的操作。

    import java.util.Arrays;
1

具有以下常用功能：

1. 给数组赋值：通过 fill 方法。

int[] arr = new int [5];
Arrays.fill(arr,4);//给所有值赋予4
String str = Arrays.toString(arr);//将数组的内容全部打印出来
System.out.print(str);//[4,4,4,4,4]
1
2
3
4

可以将下标第几位到第几位输出

Arrays.fill(arr,2,4,5);//给第二位（0位开始）到第4位（不包括）赋值5
String str = Arrays.toString(arr);//将数组的内容全部打印出来
System.out.print(str);//[4,4,5,5,4]
1
2
3

2. 对数组排序：通过 sort 方法,按升序。
   Arrays类中的一个静态sort。

• 数字排序

int [] intArr = new int[] {4, 0,-1,3}
Arrays.sort(intArr);//输出 [-1,0,3,4]
1
2

• 字符串排序，先排大写后排小写

String [] str = new String [] {"z","a","c"，"A","C"};
Arrays.sort(str);//[A,C,a,c,z]
1
2

• 按照字母表顺序排序，忽略大小Case-insensitive sort

Arrays.sort(str,String.CASE_INSENSITIVE_ORDER)
[a,A,c,C,z];
1
2

• 反向排序
  Collections工具类：是一个对集合进行操作的工具类，里面包含静态方法。

Arrays.sort(str,Collections.reverseOrder());
[z,C,c,A,a]
1
2

• 忽略大小写反向排序 Case-insensitive reverse-order sort

Arrays.sort(str,String.CASE_INSENSITIVE_ORDER)
Collections.reverse(Arrays.asList(str));

1
2
3

• 选择数组指定位置进行排序

int [] arr = {2,4,,5,7,,1};
Arrays.sort(arr,0,3);//给第0位开始 到 第3位（不包括）排序
String str = Arrays.toString(arr);//Arrays类的toString方法将数组内容输出
System.out.print(str);//[1,2,4,5,7]
1
2
3
4

3 .比较数组：通过 equals 方法比较数组中元素值是否相等。

int[] arr1 = {2,3,1};
int[] arr2 = {2,3,1};
System.out.print(Arrays.equal(arr1,arr2));//输出 true ，Arrays.equals重写了equals，所以，这里能比较元素是否相等。
// 如果是arr1.equal(arr2),则返回false,因为equal 比较的是两个对象的地址，不是内容。
1
2
3
4

• 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
  Arrays.binarySearch();二分查找指定元素的索引值下标

数组一定是排好序的，找不到元素会输出最后一个位置
int[] arr = {10,20,30,40,50};
System.out.println(Arrays.binarySearch(arr, 36));
//输出：-4 （找不到元素，返回-x，从-1开始数，如题，返回-4）


在区间内查找值
int []arr = {10,20,30,40,50};
System.out.println(Arrays.binarySearch(arr, 0,3,30));
//输出：2 （从0到3位（不包括）找30，找到了，在第2位，返回2）
如果区间内找到，会输出数组最后一个位置
System.out.println(Arrays.binarySearch(arr, 0,3,40));
//输出：-4 （从0到3位（不包括）找40，找不到，从-1开始数，返回-4）

1
2
3
4
5
6
7
8
9
10
11
12
13
14

4.截取数组几个元素 Arrays.copeOf()，

int[] arr = {10,20,30,40,50};
int[] arr1 = Arrays.copyOf(arr, 3);
String str = Arrays.toString(arr1); // Arrays类的toString()方法能将数组中的内容全部打印出来
System.out.print(str);
//输出：[10, 20, 30] （截取arr数组的3个元素赋值给新数组arr1）
1
2
3
4
5

截取其中的几个元素

int []arr = {10,20,30,40,50};
int []arr1 = Arrays.copyOfRange(arr,1,3);
String str = Arrays.toString(arr1); // Arrays类的toString()方法能将数组中的内容全部打印出来
System.out.print(str);
//输出：[20, 30] （从第1位（0开始）截取到第3位（不包括））
1
2
3
4
5

总结

Keep on going Never give up