了解背景

类和对象这一章中有学习到包这么一个定义，首先了解到Java常用包有下列这些：

上述包中集成了比较多的类库。根据上述内容列了一个知识点的思维导图，需要掌握下列这些具体的实用类库：

数组中会调用Arrays类、System类中的一些方法，从数组的使用开始了解Java的一些实用类库。

一、创建一维数组

1.数组定义

• 数组是指相同类型的数据元素按一定顺序组成的复合数据类型，元素在数组中的相对位置用下标来指明
• 数组可分为一维数组、二维数组
• 一维数组实质是一组相同类型的数据的线性集合

2.数组的特点

• 一个数组中所有的元素都属于同一种类型
• 数组中的所有元素都是有序的
• 元素都是通过数组名和元素下标来确定，元素的下标从0开始

3.创建方式

（1）先声明，再分配内存空间

• 类型由8个基本数据类型和引用类型组成；
• 类型由数组元素的类型决定，数组元素和数组的数据类型要保持一致；
• 单个[]表示一维数组，两个[]表示二维数组

类型 数组名[];
类型[] 数组名;

• 举个例子

int arr[]; //声明int型数组，数组中的每个元素都是int型数据
char cs[]; //声明char型数组，数组中的每个元素都是char
String str[] //声明String型数组，数组中的每个元素都是String型数据

或者写成下面这种，下面这种格式常用

int[] arr; 
char[] cs;
String[] str;

声明数组时只是给出了数组名和元素的数据类型，并没有创建对象本身，只是在内存中创建了一个对象的引用。如上面的代码中声明的arr数组，在声明后，内存示意图如下：

arr中对应一个内存单元，该内存单元用来保存指向数组实体的地址，目前为空（null），要想不为空，则需要给数组元素分配内存空间，即实例化数组：

数组名 = new 类型[数组元素个数];
arr = new int[4];//实例化arr，arr中有4个整数，初始值都为0

该语句执行后，系统会分配4个保存整数的内存空间，并把此内存空间的引用地址赋给arr。假设这个空间的内存地址为0x1000，内存分配过程如下，数组通过下标来区分数组中不同的元素，数组的下标从0开始：

（2）声明的同时为数组分配内存空间

类型 数组名 = new 类型[数组元素个数];
int month[] = new int[12];
int[] month = new int[12]; //month指向一个有12个元素的数组空间

（3）应用
无论使用上述的哪种格式创建数组，数组一旦创建后，其大小是不可逆的，但是我们可以通过操作数组名来引用一个全新的数组空间。如：

public class Example4_1 {
    int[] intArray = new int[5];
    public static void main(String[] args){
        int[] intArray = new int[15];
    }
}

在这种情况下，intArray指向了一个由15个整数元素组成的新内存空间，而第一个由5个整数元素组成的内存空间将被丢弃，如果没有其它引用，此内存将会变成垃圾。

二、初始化一维数组

初始化数组就是在给数组分配完空间后，给数组的各个元素有确定的值，初始化也有两种方法。

1.默认初始化

• 定义：数组实例化后，各元素会获取相同的默认值，默认数据定义数组的不同的数据类型分别如下：

2.显示的初始化

• 定义：即使用列表形式，给各元素赋值
• 赋值形式有两种：大括号中式值列表，此外，声明时不需要指定元素个数

int[] arr1 = new int[]{1,2,3,4,5}
int[] arr2 = {1,2,3}

三、数组的基本操作

1.数组的属性

在掌握数组各操作之前，先了解数组具有的属性和方法：

• length：该属性自动保存数组的长度即元素的个数，数组的下标从0开始，故数组最后一个元素的下标值为length-1，length通常用于判定数组下标是否越界
• sort()：Arrays类中包含的用来操作数组的各种方法，sort()方法提供多种重载形式，可对任意类型的数组进行升序排列
• binarySearch()：属于Arrays类，binarySearch()方法提供多种重载形式，一般配合排序方法使用，此方法主要返回要搜索元素的索引值
• fill()：主要用于替换数组元素

Arrays.fill(int[] a,int value);//将value值赋给a数组中的每个元素
Arrays.fill(int[] a,int from,int to,int value);//将value值赋给数组a中指定范围的元素(范围从下标from到下标to但是不包括下标to)

• copyOf()、copyOfRange()：实现对数组的复制

Arrays.copyOf(arr,int newlenth);//将arr数组中从下标为0的元素开始的newlength个元素复制到一个新数组中。长度不够后面的元素用默认值填充

Arrays.copyOfRange(arr,int from,int to);//把arr数组中下标范围从from一直到to的元素复制到一个新数组中

System.arraycopy(src,int srcPos,dest,int destPos,int length);//将数组src中下标从srcPos开始连续的length个数组元素复制下标从destPos开始的dest数组中去

2.数组的基本操作

利用数组的不同方法和属性，可以对数组中的数据进行一些具体的操作来实现目标值

import java.util.Arrays;

/**
 * @Author: 
 * @Time: 2021/7/13 19:22
 * @Description
 */
public class Example4_1 {
    public static void main(String[] args) {
        //创建并初始化一维数组
        int[] day = new int[]{1, 2, 3, 4, 5, 6};
        System.out.println("数值中元素个数：" + day.length);//使用length属性输出数组元素个数
        getArrayDetail(day);
        System.out.println("第5个元素的值为：" + day[4]);//数组的下标从0开始

        int[] arr = new int[]{6, 5, 4, 3, 2, 1};//声明并初始化数组
        Arrays.sort(arr);//对数组进行排序,
        System.out.println("排序后，arr数组各下标对应的值为：");
        getArrayDetail(arr);

        System.out.println("2所在位置："+Arrays.binarySearch(arr,2));//查找元素5所在的位置,返回2所在的数组下标值1

        Arrays.fill(arr,20);//将数组中的所有元素都替换为20
        getArrayDetail(arr);
        Arrays.fill(arr,0,2,0);//从下标0到下标1替换数据，下标2数据不包括
        getArrayDetail(arr);

        getArrayDetail(Arrays.copyOf(arr,7)); //将数组中元素从下标0开始的元素复制到一个型数组中去，若新数组的长度超过原数组的，则用默认值填充；
        System.arraycopy(arr,0,day,0,arr.length);//将数组arr中从下标为0的位置开始复制arr.length个元素到day数组中，位置从day数组下标为0的元素开始
        getArrayDetail(day);


    }


    /**
     * @param array for循环，使用数组下标输出数组对应的元素
     */
    private static void getArrayDetail(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

３.数组的一些排序算法

例１：怎么获取数组中最大的值？
思路：
先定义一个变量保存数组索引为0的元素，然后再使用循环遍历数组，在循环中将遍历到的元素和先前定义的变量比大小，如果大于变量,那就将变量替换为当前元素,直到循环结束，就可以找出最大值了

public static void main(String[] args) {
		int[] arr = {3,5,6,8,9,7};
		int max = arr[0];//定义变量，将数组下标为0的元素存入
		for(int i=1;i<arr.length;i++){//因为下标为0的元素存入到变量中了，所以从下标1开始循环
			if(max < arr[i]){//判断当前遍历到的元素是否大于变量max
				max = arr[i];//如果大于变量max ，那就将当前遍历到的元素替换掉变量原先的值
			}//如果不大于,继续循环
		}
		System.out.println(max);//最后输出结果  结果为：9
}

例２：冒泡排序``：就是使用循环将数组中的元素按从大到小或从小到大排序好
思路：
这里需要使用到两个for循环，外边的循环每循环一次就可以找到一个最大值
里边的循环每循环一次就产生一次对比，在内层循环中在判断前一个元素是否比后一个元素小，是的话互换位置，最后输出

public static void main(String[] args) {
	int[] arr = {3,11,6,20,9,7};
	//外层循环每循环一次确定一个最大的元素
	for(int i=0;i<arr.length;i++){
		//内层循环每循环一次产生一次对比
		for(int j=0;j<arr.length-1;j++){
			//将当前的元素与后一个元素比较
			if(arr[j]<arr[j+1]){
				//如果当前元素小于后一个元素  互换位置
				int temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			}
		}
	}
	//最后循环输出  从大到小排序
	for(int i=0;i<arr.length;i++){
		System.out.print(arr[i]+"\t");
	}
}

四、二维数组的定义

1.定义

二维数组相当于一个x_y坐标轴，分别对其x、y轴赋值

类型 数组名[][];
int[][] a;
a = new int[2][];//初始化时至少要为第1维分配空间，且下标均从0开始
a[0]=new int[2];
a[1] = new int[3];//分别创建空间

2.使用

分别输出二维数组各自对应的具体值时需要用到嵌套for循环：

        int[][] a;
        a = new int[2][3];
//        等价于     
//        a[0]=new int[2];
//        a[1] =new int[3];
        a[0][0]=1;
        a[0][1]=2;
        a[0][2]=3;
        for (int i = 0;i<a.length;i++){
            for(int j=0;j<a[i].length;j++){
                System.out.println(a[i][j]);
            }
        }
        System.out.println(a.length);
        System.out.println(a[0].length);
        System.out.println(a[1].length);

输出结果为：

1
2
3
0
0
0
2
3
3