目录
数组的基本概念
数组可以理解成一个小盒子，里面可以装若干个同类型的元素，每个元素都有唯一的编号（或者标识符）
1.为什么要使用数组
假设有这样一个场景，我们要存放5个学生的考试成绩，我们很快就能写出一个代码，用5个变量分别存放就好了，可是如果有100个学生，或者更多呢？我们难道要100个变量吗？
通过观察这些学生的成绩，数据类型都是一样的，在java中的数组，就可以把这些相同类型的数组存放起来 ，那数组是什么，该怎么去使用呢？请看下文。
2.什么是数组
数组：可以看成是相同类型元素的一个集合。在内存中是一段连续的空间。比如现实中的车库：
从上图中可以看到：
1. 数组中存放的元素其类型相同
2. 数组的空间是连在一起的
3. 每个空间有自己的编号，其实位置的编号为0，即数组的下标
3.数组的创建及初始化
数组的创建
T[] 数组名 = new T[N]; T：表示数组中存放元素的类型
T[]：表示数组的类型
N：表示数组的长度
int[] array1 = new int[10]; //创建了一个可以容纳10个int类型的数组
double[] array2 = new double[5]; //创建一个可以容纳5个double类型的数组
String[] array3 = new String[3]; //创建了一个可以容纳3个字符串类型的数组数组的初始化
1. 动态初始化：在创建数组时，直接指定数组中元素的个数
int[] array = new int[10] ;2. 静态初始化：在创建数组时不直接指定数据元素个数，而直接将具体的数据内容进行指定
语法格式：T[] 数组名称 = {data1, data2, data3, ..., datan};
int[] array1 = new int[]{1,2,3,4,5};
int[] array2 = {1,2,3,4,5};【注意事项】
静态初始化虽然没有指定数组的长度，编译器在编译时会根据{}中元素个数来确定数组的长度。
静态初始化时, {}中数据类型必须与[]前数据类型一致。
也可以分成两步
int[] array ;
array = new int[]{1,2,3,4,5};如果没有对数组进行初始化，数组中元素还有其默认值
如果数组中存储元素类型为基类类型，默认值为基类类型对应的默认值，比如、、
如果数组中存储元素类型为引用类型，默认值为null
4.数组的使用
数组中元素的访问
数组在内存中是一段连续的空间，下标从零开始，依次递增，通过下标可以访问数组的任意元素。
【注意事项】
下标从0开始，介于【0，N ） 之间不包含N，N为元素个数，不能越界，否则会报错。
抛出了 java.lang.ArrayIndexOutOfBoundsException 异常. 使用数组一定要下标谨防越界
遍历数组
方法一
所谓 "遍历" 是指将数组中的所有元素都访问一遍, 访问是指对数组中的元素进行某种操作，比如：打印。
通过循环来遍历数组就好了，在数组中可以通过数组对象.length 来获取数组的长度
方法二
通过for-each 遍历数组，for-each是循环的增强版
语法格式for（数据类型：数组名）
注意：这种方式是适合用来遍历数组
方法三
通过Arrays实现
Arrays是一个操作数组的一个工具类（一个功能非常强大的工具），toSting是这个工具提供的一个方法，他的作用是将数组转换成字符串并且打印。
5. 数组是引用类型
初始JVM的内存分布
java当中的内存划分是什么样子的呢？JVM当中的内存划分。
通过上图可以看到可以分为5个区，划分区域是让我们更好的去管理内存，每一个区都有他自己的独特的功能。
基本类型变量与引用类型变量的区别
基本数据类型创建的变量，称为基本变量，该变量空间中直接存放的是其所对应的值；
而引用数据类型创建的变量，一般称为对象的引用，其空间中存储的是对象所在空间的地址
如果有这样一段代码他们在内存中是怎样存放的呢？
public static void func() {
int a = 10;
int b = 20;
int[] arr = new int[]{1,2,3};
}a和b为基本变量，是存放在栈上的，arr为引用变量虽然也在栈上，但是内部存放的是数组在堆上的地址。
从上图可以看到，引用变量并不直接存储对象本身，可以简单理解成存储的是对象在堆中空间的起始地址。通过该地址，引用变量便可以去操作对象。有点类似C语言中的指针，但是Java中引用要比指针的操作更简单
认识null
null在java中表示“空引用”
注意这样的代码是一定会报一个空指针异常的错误的。
null 的作用类似于 C 语言中的 NULL (空指针), 都是表示一个无效的内存位置.
6.数组的应用场景
保存数据
public static void main(String[] args) {
int[] array = {1, 2, 3};
for(int i = 0; i < array.length; ++i){
System.out.println(array[i] + " ");
}
}作为函数参数
传基本数据类型
通过观察修改形参x的值，不影响实参的值，因为这是两个没有任何关系的值。
传数组类型（引用类型）
发现在func方法内部修改数组的内容, 方法外部的数组内容也发生改变.
因为数组是引用类型，按照引用类型来进行传递，是可以修改其中存放的内容的。
总结: 所谓的 "引用" 本质上只是存了一个地址. Java 将数组设定成引用类型, 这样的话后续进行数组参数传参, 其实只是将数组的地址传入到函数形参中. 这样可以避免对整个数组的拷贝(数组可能比较长, 那么拷贝开销就会很大).
作为函数的返回值
java中的数组是可以作为函数的返回值的，比如：获取斐波那契数列的前N项
7.数组练习
数组拷贝
方法一
newArr和arr引用的是同一个数组
因此newArr修改空间中内容之后，arr也可以看到修改的结果
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
int[] newarr = arr;
System.out.println("newArr: " + Arrays.toString(newarr));
}方法二：
使用Arrays中copyOf方法完成数组的拷贝
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
int[] newarr;
newarr = Arrays.copyOf(arr,arr.length);
System.out.println(Arrays.toString(newarr));
}copyOf使用方法：copyOf（原数组：数组长度）
方法三
拷贝某个范围
使用Arrays中copyOfRange方法完成数组的拷贝
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
int[] newarr ;
newarr = Arrays.copyOfRange(arr,1,3);
System.out.println(Arrays.toString(newarr));
}copyOfRange使用方法：copyOfRange（原数组：数组范围），范围是一个左闭右开的区间。
方法四
实现自己版本的拷贝数组
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5};
int[] newarr = new int[5];
for (int i = 0; i < arr.length; i++) {
newarr[i] = arr[i];
}
System.out.println(Arrays.toString(newarr));
}求数组中元素的平均值
这个代码比较简单，只需要把所有元素加起来除以数组长度即可。
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
double sum = 0;
for (int i = 0; i < arr.length; i++) {
sum+=arr[i];
}
double avg = sum / (arr.length) ;
System.out.println(avg);
}需要注意的是要用浮点型。
查找数组中指定元素(顺序查找)
给定一个数组, 再给定一个元素, 找出该元素在数组中的位置.
代码示例
public static int find(int[] array , int n){
for (int i = 0; i < array.length; i++) {
if(array[i] == n){
return i;
}
}
return -1;
}查找数组中指定元素(二分查找)
针对有序数组, 可以使用更高效的二分查找
以升序数组为例, 二分查找的思路是先取中间位置的元素, 然后使用待查找元素与数组中间元素进行比较：
- 如果相等，即找到了返回该元素在数组中的下标
- 如果小于，以类似方式到数组左半侧查找
- 如果大于，以类似方式到数组右半侧查找
public static int binarySearch(int[] array ,int n){
int i = 0;
int j = array.length-1;
while (i <= j){
int mid = (i+j)/2;
if(array[mid]>n){
j = mid - 1;
} else if (array[mid]<n) {
i = mid + 1;
}else {
return mid;
}
}
return -1 ;
}可以看到, 针对一个长度为 10000 个元素的数组查找, 二分查找只需要循环 14 次就能完成查找. 随着数组元素个数越多, 二分的优势就越大
Arrays工具的查找方法
使用方法Arrays.binarySearch(查找的数组名 , 需要查找的值)
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("请输入你要找的值>: ");
int x = sc.nextInt();
int[] arr = {1,2,3,4,5};
int ret = Arrays.binarySearch(arr,x);
System.out.println(ret);
}数组排序(冒泡排序)
给定一个数组, 让数组升序 (降序) 排序.
算法思路
假设排升序：
1. 将数组中相邻元素从前往后依次进行比较，如果前一个元素比后一个元素大，则交换，一趟下来后最大元素就在数组的末尾
2. 依次从上上述过程，直到数组中所有的元素都排列好
代码示例
public static void main(String[] args) {
int[] arr = {10,9,8,7,6,5,4,3,2,1};
for (int i = 0; i < arr.length-1; i++) {
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;
}
}
}
System.out.println(Arrays.toString(arr));
}Arrays工具的进行排序
public static void main(String[] args) {
int[] arr = {10,9,8,7,6,5,4,3,2,1};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
}数组逆序
给定一个数组, 将里面的元素逆序排列
public static void main(String[] args) {
int[] arr = {10,9,8,7,6,5,4,3,2,1};
int i = 0;
int j = arr.length-1;
while (i<j){
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
i++;
j--;
}
System.out.println(Arrays.toString(arr));
}8.一些Arrays工具的介绍
比较数组Arrays.equals
public static void main(String[] args) {
int[] arr = {1,2,3};
int[] arrs = {1,2,3};
System.out.println(Arrays.equals(arr, arrs));
}里面的参数是要比较的两个数组，如果一样会返回ture，不一样会返回false
填充数组 Arrays.toString
public static void main(String[] args) {
int[] arr = new int[10];
Arrays.fill(arr,99);
System.out.println(Arrays.toString(arr));
}这个代码会给数组的每个元素赋值为99
也可以范围填充
9. 二维数组
二维数组本质上也就是一维数组, 只不过每个元素又是一个一维数组
基本语法
数据类型[][] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 };
int[][] arr1 = {{1,2,3},{4,5,6},{7,8,9}};
int[][] arr2 = new int[3][3];
代码示例
public static void main(String[] args) {
int[][]arr = {{1,2,3},{4,5,6},{7,8,9}};
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[1].length; j++) {
System.out.print(arr[i][j]+" ");
}
System.out.println();
}
}可以通过deepToString来进行打印
public static void main(String[] args) {
int[][] arr1 = {{1,2,3},{4,5,6},{7,8,9}};
System.out.println(Arrays.deepToString(arr1));
}java当中还支持不规则数组，就是每一行的元素个数不一样
二维数组的用法和一维数组并没有明显差别, 因此我们不再赘述
到这里就结束啦！ 喜欢的记得点个赞，有问题可以打在评论区。
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
