数组

一、什么是数组

数组是同一种类型数据的集合，其实就是一个容器。运算的时候有很多数据参与运算,那么首先需要做的是什么。不是如何运算而是如何保存这些数据以便于后期的运算，那么数组就是一种用于存储数据的方式，能存数据的地方我们称之为容器，容器里装的东西就是数组的元素,数组可以装任意类型的数据，虽然可以装任意类型的数据,但是定义好的数组只能装一种元素，也就是数组一旦定义，那么里边存储的数据类型也就确定了。

Java 语言中提供的数组是用来存储固定大小的同类型元素。

二、数组的定义

数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中，每一个数据称作一个元素，每个元素可以通过一个索引（下标）来访问它们。

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

dataType[] arrayRefVar;   // 首选的方法   数据类型[] 数组名称
或
dataType arrayRefVar[];  // 效果相同，但不是首选方法    数据类型 数组名称[]

注意: 建议使用 dataType[] arrayRefVar 的声明风格声明数组变量。 dataType arrayRefVar[] 风格是来自 C/C++ 语言，在Java中采用是为了让 C/C++ 程序员能够快速理解java语言。

为了使用数组必须在程序中声明数组，并指定数组的元素类型=左半部分：

先写左边明确了元素类型是int ，容器使用数组，那么如何来标识数组？.那么用一个特殊的符号[]中括号来表示。想要使用数组是需要给数组起一个名字的,那么我们在这里给这个数组起名字为arr .接着跟上等号。

package com.method.augus;

public class Dem04 {
    public static void main(String[] args) {
        int[] arr;

        //声明一个长度为5的string类型的数组
        String[] aArray = new String[5];

        //声明数组，并且赋值
        String[] bArray = {"李慢慢","君陌","于连"};

        //声明数组，并赋值
        String[] cArray = new String[]{"宋远桥","俞莲舟","俞岱岩","张松溪","张翠山","殷梨亭","莫声谷"};
    }
}

三、数组的基本特点

数组的长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
数组中元素的类型必须是相同类型，不允许出现混合类型。
数组类型可以是任何数据类型，包括基本类型和引用类型。
数组有索引的：索引从0开始，到数组.length-1 结束
数组变量属于引用类型，数组也是对象。

注意：数组变量属于引用类型，数组也是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中存储的。

四、数组初始化

数组的初始化方式总共有三种：静态初始化、动态初始化、默认初始化。

静态初始化

除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。

int[] arr = {12,23,95};
int[] arr = new int[]{12,13,15};

注意下面的两种方式都是错误的：

1.new int[3]{12,23,45};-->错误
2.int[] arr ;
   arr = {12,23,45};  --->错误

动态初始化

数组定义与为数组元素分配空间并赋值的操作分开进行。

int[] arr ;
arr = new int[3]
arr[0] = 12;
arr[1] = 73;
arr[2] = 15;

默认初始化

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

int[] arr = new int[3];   ---> 数组有默认的初始化值

需要注意：数组有默认的初始值，初始化值取决于数组的类型

byte[] : 0
short[] :0
int[] :0
long[] :0
float[]: 0.0
double[] :0.0
char[] : '\u0000'
boolean[] : false
引用数据类型的数组: null

五、数组的应用

5.1.最值问题

实现一个功能：给定一个数组int[] arr = {12,3,7,4,888,125,9,45}; ，求出数组中最大的数。实现思路，打擂台的原理，交替上台打擂台

package com.method.augus;

public class Demo05 {
    public static void main(String[] args) {
        //给定一个数组int[] arr = {12,3,7,4,888,125,9,45}; ，求出数组中最大的数
        int[] arr = {12,3,7,4,888,125,9,4500};

        //调用方法求最大值
        int maxArr = getMaxNumber(arr);

        System.out.println("最大值为："+maxArr);
    }

    /**
     * 求数组中的最大值
     * @param arr
     * @return
     */
    public static int getMaxNumber(int[] arr){
        //先取出第一个数，假设为最大值
        int maxArr = arr[0];

        //循环分别取出值，拿过来比较
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]>maxArr){
                //本次循环取出的值大于假设的最大值，则将本次取出的值，赋值给maxArr
                maxArr = arr[i];
            }
        }

        return maxArr;
    }
}

5.2.查询问题

数组中元素的根据索引查找，索引从左往右从0开始，最后一个元素的索引是数组的长度-1

public class Demo06 {
    public static void main(String[] args) {
        //查询指定位置的元素
        //给定一个数组：
        int[] arr = {12,34,56,17,13,10};

        //查找索引为3的元素，其实是第四个元素
        System.out.println(arr[3]);
    }
}

查询指定元素的位置：找出某个元素对应的索引案例如下：

package com.method.augus;

public class Demo07 {
    public static void main(String[] args) {
        //给定一个数组
        int[] arr = {12,34,56,78,3,56};

        //查询78这个元素对应的索引
        int index = getIndex(arr, 78);
        System.out.println(index);
    }

    /**
     * 查看某个值在数组中的索引
     * @param arr 数组
     * @param num 值
     * @return 索引
     */
    public static int getIndex(int[] arr,int num){
        //查询元素在数组中对应的索引

        //定义一个变量，用于保存查找出来的78这个元素的索引
        int idx = -1;

        for (int i = 0; i < arr.length; i++) {
            //取值进行判断
            if(arr[i]==78){
                idx = i;
            }
        }
        return idx;
    }
}

5.3.添加元素

向数组里添加一个元素怎么添加，一般数组是不能添加元素的，因为数组在初始化时就已定好长度了，不能改变长度，所以所谓的添加只是替换

package com.method.augus;

public class Demo08 {
    public static void main(String[] args) {
        //功能：给定一个数组,在数组下标为3的位置上添加一个元素101

        //1.给定一个数组：
        int[] arr = {12,34,56,7,3,10,55,66};


        //添加元素
        arr[3] = 45;

        System.out.print("添加之后的元素信息：");
        for (int i : arr) {
            System.out.print(i+",");
        }
    }
}

5.4.删除元素

java 的数组是固定长度的，无法直接删除，我们可以通过创建一个新数组，把原始数组中要保留的元素放到新数组中即可：

package com.method.augus;

import java.util.Arrays;

public class Demo10 {
    public static void main(String[] args) {
        int[] arr = {3, 4, 5, 6, 7};// 原始数组

        int num = 2;   // 删除索引为 2 的元素，即删除第三个元素 5

        int[] newArray = new int[arr.length-1];// 新数组，长度为原始数组减去 1(因为删除一个长度就变了)

        for (int i = 0; i < newArray.length; i++) {
            //判断元素是否越界
            if(num<0 || num>=arr.length){
                System.out.println("索引越界，无法操作");
            }

            //判断
            if(i<num){
                newArray[i] = arr[i];
            }else {
                //大于num的的时候，num2，那么保存的则是索引3开始的数据，所以加1
                newArray[i] = arr[i+1];
            }
        }

        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(newArray));
    }
}

六、java.util.Arrays

Arrays类是一个非常有用数组工具类，里面有很多工具方法，检索、填充、排序、比较、toString()等。

package com.method.augus;

import java.util.Arrays;

public class Demo11 {
    public static void main(String[] args) {
        //给定一个数组
        int[] arr = {23,12,56,1,5,9,10};

        //toString:对数组进行遍历查看的，返回的是一个字符串
        System.out.println(Arrays.toString(arr));

        //binarySearch:二分法查找：找出指定数组中的指定元素对应的索引：
        //这个方法的使用前提：要查看的是一个有序的数组：
        //sort：排序 -->升序
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.binarySearch(arr,56));//是从排序后的结果中找

        //copyOf:完成数组的复制
        int[] arr2 = {23,12,5,2,78,90};
        //拷贝数组 ,第二个参数指定了拷贝的元素个数
        int[] ints = Arrays.copyOf(arr2, 4);
        System.out.println(Arrays.toString(ints)); //[23, 12, 5, 2]

        //copyOfRange:区间复制, 拷贝一个区间，是左闭右开的区别
        int[] ints1 = Arrays.copyOfRange(arr2, 1, 4); //[12, 5, 2]
        System.out.println(Arrays.toString(ints1));

        //equals:比较两个数组的值是否一样：
        int[] arr3 = {1,3,7,2,4,8};
        int[] arr4 = {1,3,7,2,4,8};

        System.out.println(Arrays.equals(arr3,arr4));//true
        /*
        1、对于对象引用类型：“==”比较的是对象的内存地址。
            所以就算两个对象的值相等，它们也是不等的（因为每个对象的地址都是不一样的）
        2.对于基本类型数据，其实比较的是它的值。
            所以一般用==来比较两个数字大小是不是相等的
         */
        System.out.println(arr3==arr4);//虽然值相同但是在内存中地址是不同的所以返回的flase

        //fill：数组的填充 将指定的值赋给指定数组的每个元素
        int[] arr5 = {1,3,7,2,4,8};
        Arrays.fill(arr5,10);
        System.out.println(Arrays.toString(arr5));//[10, 10, 10, 10, 10, 10]
        
    }
}

七、数组的复制

数组的复制使用arraycopy，源码如下：

java.lang.System
 
public static void arraycopy(Object src,
                             int srcPos,
                             Object dest,
                             int destPos,
                             int length)

参数：

src - 源数组。
srcPos - 源数组中的起始位置。
dest - 目标数组。
destPos - 目标数据中的起始位置。
length - 要复制的数组元素的数量。

package com.method.augus;

import java.util.Arrays;

public class Demo12 {
    public static void main(String[] args) {
        //给定一个数组
        int[] arr1 = {23,12,56,8,16,121,90};
        //给定一个目标数组
        int[] arr2 = new int[10];

        //复制数组
        System.arraycopy(arr1,1,arr2,0,5);

        //输出目标数组
        System.out.println(Arrays.toString(arr2)); //[12, 56, 8, 16, 121, 0, 0, 0, 0, 0]
    }
}

八、Java二维数组

8.1.创建二维数组

在 Java 中二维数组被看作数组的数组，即二维数组为一个特殊的一维数组，其每个元素又是一个一维数组。Java 并不直接支持二维数组，但是允许定义数组元素是一维数组的一维数组，以达到同样的效果。声明二维数组的语法如下：

type array[][];
type[][] array;

其中，type 表示二维数组的类型，array 表示数组名称，第一个中括号表示行，第二个中括号表示列。

下面分别声明 int 类型和 char 类型的数组，代码如下：

int[][] age;
char[][] sex;

8.2.初始化二维数组

二维数组可以初始化，和一维数组一样，可以通过3种方式来指定元素的初始值。这 3 种方式的语法如下：

array=new type[][]{值 1,值 2,值 3,…,值 n};
array=new type[][]{new 构造方法(参数列),…};
type[][] array={{第1行第1列的值,第1行第2列的值,…},{第2行第1列的值,第2行第2列的值,…},…};

静态初始化