夯实Java基础（一）数组

1、数组的介绍

数组(Array)：就是多个相同类型的数据按照一定的顺序排列的集合。简单理解数组就是一个数据容器。

数组是编程中最常见的一种数据结构，可用于存储多个数据，每个数组元素存放一个数据，通常我们可以通过数组元素的索引来访问数组元素。包括为数组元素赋值和取出数组元素的值。

数组的相关概念：数组名,下标（或脚标、索引）(index),元素(element),数组的长度(length)。

数组的基本特性：

• ①、数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
• ②、创建数组对象会在内存中开辟一整块连续的空间，而数组的引用是这块连续空间的首地址。
• ③、数组一旦初始化完成，数组在内存所占用的空间将被固定下来，因此数组的长度不可变。
• ④、数组可以直接通过下标的方式来调用，下标从0开始。

2、数组的声明与初始化

①、数组的声明

注：数组在使用之前需要先进行声明并初始化

2.1、数组的声明

数组的声明比较简单，和变量基本一样，只是多了个括号[]。数组的声明如下：

//推荐
元素的数据类型[] 数组的名称;
int[] age;
//不推荐
元素的数据类型  数组名[];
int age[];

2.2、数组的初始化

数组使用之前需要先初始化，什么是数组初始化？就是给数组分配内存空间，并给元素赋值。数组的初始化有两种：静态初始化和动态初始化。

①、静态初始化：定义数组的同时为数组分配内存空间，并赋值。程序员只给定数组元素的初始值，不指定数组长度，由系统决定数组的长度。

数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};
或
数据类型[] 数组名;
数组名 = new 数据类型[]{元素1,元素2,元素3...};

简化方式：
数据类型[] 数组名 = {元素1,元素2,元素3...};//必须在一个语句中完成，不能分开两个语句写

②、动态初始化：初始化时候程序员只指定数组长度，由系统元素分配初始值(为对应类型的默认值，比如int默认赋值为0)。

数据类型 [ ]  数组名称 = new 数据类型 [数组长度]
或
数据类型  数组名称[ ] = new 数据类型 [数组长度]

③、简单举例代码如下：

//声明一个元素为1,2,3的int型数组
int[] arr=new int[]{1,2,3};
int[] arr1={1,2,3};
//声明一个长度为3的数组
int[] arr2=new int[3];

④、错误写法：

//未指定数组长度
int [] arr1=new int[];
//数组前面[]不能写长度
int [5] arr2=new int[5];
//静态初始化不能写长度
int [] arr3=new int[3]{1,2,3};

上面的代码写法都是错误的，在编译时会报错。

3、数组元素的访问与遍历

①、访问数组元素以及给数组元素赋值

数组是存在下标索引的，索引的范围为[0,数组的length-1]，通过下标可以获取指定位置的元素，数组下标是从0开始的，也就是说下标0对应的就是数组中第1个元素，可以很方便的对数组中的元素进行存取操作。格式为：数组名[索引]。

//声明一个长度为3的数组
int[] arr=new int[3];
//给arr第1个元素赋值1
arr[0]=1;
//给arr第2个元素赋值2
arr[1]=2;
//输出
System.out.println(arr[0]);
System.out.println(arr[1]);

上面的arr数组，我们只能赋值三个元素，也就是下标从0到2，如果你访问 arr[3] ，那么会报数组下标越界异常。

②、数组的遍历

数组遍历： 就是将数组中的每个元素分别获取出来，这就是遍历。遍历也是数组操作中的基石，数组有个 length 属性，是记录数组的长度的，我们可以利用length属性来遍历数组。语句为：数组名.length，返回int类型结果。由次可以推断出，数组的最大索引值为数组名.length-1。

//声明一个元素为1,2,3的int型数组
int[] arr=new int[]{1,2,3};
//遍历arr数组
for (int i = 0; i < arr.length; i++) {
     System.out.println(arr[i]);
}
// 使用增强for循环foreach进行遍历
for (int i : arr) {
      System.out.println(i);
}
//使用Arrays.toSting(数组名)进行遍历
System.out.println(Arrays.toString(arr));

4、数组的内存图

众所周知，程序是运行在内存中的，而Java程序是运行在Java虚拟机(JVM)上的，那么JVM要运行程序，必须要对内存进行空间的分配和管理。JVM的内存是怎么划分的呢？为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

数组内存图分析：

public static void main(String[] args) {
    int[] arr = new int[3];
    int[] arr2 = new int[2];
    System.out.println(arr);
    System.out.println(arr2);
}

5、数组的使用举例

①、将数组元素反转：

public class ArrayTest {
    public static void main(String[] args) {
        String[] str=new String[]{"AA","BB","CC","DD","EE","FF","GG"};
        System.out.println("反转前：");
        for (int i = 0; i < str.length; i++) {
            System.out.print(str[i]+"\t");
        }
        for(int i=0;i<str.length/2;i++){
            String temp=str[i];
            str[i]=str[str.length-i-1];
            str[str.length-i-1]=temp;
        }
        System.out.println();
        System.out.println("反转后：");
        for (int i = 0; i < str.length; i++) {
            System.out.print(str[i]+"\t");
        }
    }
}

②、线性查找：

public class ArrayTest1 {
    public static void main(String[] args) {
        String[] str=new String[]{"AA","BB","CC","DD","EE","FF","GG"};
        String dest="BB";
        boolean isFlag=true;
        for (int i = 0; i < str.length; i++) {
            if (dest.equals(str[i])){
                System.out.println("找到了元素，位置在"+(i+1));
                isFlag=false;
                break;
            }
        }
        if (isFlag) {
            System.out.println("对不起，没有找到");
        }
    }
}

③、提到数组都离不开一个经典的排序——冒泡排序

public class ArrayTest2 {
    public static void main(String[] args) {
        int[] arr=new int[]{56,12,32,98,78,45,-45,3,55,-16};
        for (int i = 0; i < arr.length; i++) {
            for (int j=0;j<arr.length-1-i;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");
        }
    }
}

数组无论在Java，C，C++，PHP等语言中都有着非常重要的地位，所以学号数组基础非常有必要。

6、二维数组（理解）

二维数组：本质上就是数组的元素为一维数组的一个数组。意思就是一个一维数组存储的是另一个数组的地址值，而另一个数组才是真正用来存储值的。

6.1、二维数组的声明

声明语法格式为：

//推荐
元素的数据类型[][] 二维数组的名称;

//不推荐
元素的数据类型  二维数组名[][];
//不推荐
元素的数据类型[]  二维数组名[];

//声明一个二维数组
int[][] arr;

6.2、二维数组的初始化

①、静态初始化，程序员给定元素初始值，由系统决定数组长度。

//1.先声明，再静态初始化
元素的数据类型[][] 二维数组名;
二维数组名 = new 元素的数据类型[][]{
		{元素1，元素2，元素3 。。。},
		{第二行的值列表},
		...
		{第n行的值列表}
	};
//2.声明并同时静态初始化
元素的数据类型[][] 二维数组名 = new 元素的数据类型[][]{
		{元素1，元素2，元素3 。。。},
		{第二行的值列表},
		...
		{第n行的值列表}
	};
//3.声明并同时静态初始化的简化写法
元素的数据类型[][] 二维数组名 = {
		{元素1，元素2，元素3 。。。},
		{第二行的值列表},
		...
		{第n行的值列表}
	};

如果是静态初始化，右边new 数据类型[][]中不能写数字，因为行数和列数，由{}的元素个数决定

简单的示例：

//声明二维数组
int[][] arr;
//静态初始化
arr = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
//arr = new int[3][3]{{1,2,3},{4,5,6},{7,8,9}};//错误，静态初始化，右边new 数据类型[]中不能指定长度

//声明并同时初始化
int[][] arr = new int[][]{{1,2,3},{4,5,6},{7,8,9}};

//声明并同时初始化的简化写法
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};//声明与初始化必须在一句完成

public static void main(String[] args) {
	//定义数组
	int[][] arr = {{1,2,3},{4,5},{6}};
	
	System.out.println(arr);
	System.out.println(arr[0]);
	System.out.println(arr[1]);
	System.out.println(arr[2]);
	
	System.out.println(arr[0][0]); //1
	System.out.println(arr[1][0]); //4
	System.out.println(arr[2][0]); //6
	
	System.out.println(arr[0][1]); //2
	System.out.println(arr[1][1]); //5
	//越界
	System.out.println(arr[2][1]); //错误
}

②、动态初始化（规则二维表）程序员指定数组的长度，后期再赋值（系统会先给定元素默认初始值）。

什么是规则二维表？规则二维表的每一行的列数是相同的。

//（1）确定行数和列数
元素的数据类型[][] 二维数组名 = new 元素的数据类型[m][n];
	m:表示这个二维数组有多少个一维数组。或者说一共二维表有几行
	n:表示每一个一维数组的元素有多少个。或者说每一行共有一个单元格
//此时创建完数组，行数、列数确定，而且元素也都有默认值

//（2）再为元素赋新值
二维数组名[行下标][列下标] = 值;

public static void main(String[] args) {
    //定义一个二维数组
    int[][] arr = new int[3][2];

    //定义了一个二维数组arr
    //这个二维数组有3个一维数组的元素
    //每一个一维数组有2个元素
    //输出二维数组名称
    System.out.println(arr); //地址值	[[I@175078b

    //输出二维数组的第一个元素一维数组的名称
    System.out.println(arr[0]); //地址值	[I@42552c
    System.out.println(arr[1]); //地址值	[I@e5bbd6
    System.out.println(arr[2]); //地址值	[I@8ee016

    //输出二维数组的元素
    System.out.println(arr[0][0]); //0
    System.out.println(arr[0][1]); //0
}

③、动态初始化（不规则二维表）;不规则二维表：每一行的列数可能不一样。

//（1）先确定总行数
元素的数据类型[][] 二维数组名 = new 元素的数据类型[总行数][];

//此时只是确定了总行数，每一行里面现在是null

//（2）再确定每一行的列数，创建每一行的一维数组
二维数组名[行下标] = new 元素的数据类型[该行的总列数];

//此时已经new完的行的元素就有默认值了，没有new的行还是null

//(3)再为元素赋值
二维数组名[行下标][列下标] = 值;

public static void main(String[] args) {
    //定义数组
    int[][] arr = new int[3][];

    System.out.println(arr);	//[[I@175078b

    System.out.println(arr[1][0]);//NullPointerException
    System.out.println(arr[0]); //null
    System.out.println(arr[1]); //null
    System.out.println(arr[2]); //null

    //动态的为每一个一维数组分配空间
    arr[0] = new int[2];
    arr[1] = new int[3];
    arr[2] = new int[1];

    System.out.println(arr[0]); //[I@42552c
    System.out.println(arr[1]); //[I@e5bbd6
    System.out.println(arr[2]); //[I@8ee016

    System.out.println(arr[0][0]); //0
    System.out.println(arr[0][1]); //0
    //ArrayIndexOutOfBoundsException
    //System.out.println(arr[0][2]); //错误

    arr[1][0] = 100;
    arr[1][2] = 200;
}

6.3、二维数组的遍历（两个for循环）

for(int i=0; i<二维数组名.length; i++){
    for(int j=0; j<二维数组名[i].length; j++){
        System.out.print(二维数组名[i][j]);
    }
    System.out.println();
}

6.4、二维数组的内存图分析

int[][] arr = {{1},{2,2},{3,3,3},{4,4,4,4},{5,5,5,5,5}};

7、数组的工具类

在java.util包下提供了一个叫Arrays的工具类，里面提供了很多静态方法来对数组进行操作，而且如下每一个方法都有各种重载形式，以下只列出int[]类型的，其他类型的数组类推：

• static int binarySearch(int[] a, int key) ：要求数组有序，在数组中查找key是否存在，如果存在返回第一次找到的下标，不存在返回负数
• static int[] copyOf(int[] original, int newLength) ：根据original原数组复制一个长度为newLength的新数组，并返回新数组
• static int[] copyOfRange(int[] original, int from, int to) ：复制original原数组的[from,to)构成新数组，并返回新数组
• static boolean equals(int[] a, int[] a2) ：比较两个数组的长度、元素是否完全相同
• static void fill(int[] a, int val) ：用val填充整个a数组
• static void fill(int[] a, int fromIndex, int toIndex, int val)：将a数组[fromIndex,toIndex)部分填充为val
• static void sort(int[] a) ：将a数组按照从小到大进行排序
• static void sort(int[] a, int fromIndex, int toIndex) ：将a数组的[fromIndex, toIndex)部分按照升序排列
• static String toString(int[] a) ：把a数组的元素，拼接为一个字符串，形式为：[元素1，元素2，元素3。。。]

示例代码：

import java.util.Arrays;
import java.util.Random;

public class Test {
    public static void main(String[] args) {
        int[] arr = new int[5];
        //1、打印数组,输出地址值
        System.out.println(arr); // [I@2ac1fdc4
        //2、toString;数组内容转为字符串
        System.out.println("arr数组初始状态：" + Arrays.toString(arr));
        //3、fill
        Arrays.fill(arr, 3);
        System.out.println("arr数组现在状态：" + Arrays.toString(arr));
        //赋值操作
        Random rand = new Random();
        for (int i = 0; i < arr.length; i++) {
            arr[i] = rand.nextInt(100);//赋值为100以内的随机整数
        }
        System.out.println("arr数组现在状态：" + Arrays.toString(arr));
        //4、copyOf
        int[] arr2 = Arrays.copyOf(arr, 10);
        System.out.println("新数组：" + Arrays.toString(arr2));
        //5、equals
        System.out.println("两个数组的比较结果：" + Arrays.equals(arr, arr2));
        //6、sort
        Arrays.sort(arr);
        System.out.println("arr数组现在状态：" + Arrays.toString(arr));
    }
}