JavaSE基础(27) 数组

数组的概念

概念：具有一组相同数据类型的数据结构。（理解为容器，就是装数据的）

相同数据类型

数据结构：在内存中是连续的内存空间。

数组的使用

使用：

        step1：创建数组

        step2：操作数据：存储数据，获取数据

数组中可以存储任意类型的数据，但是数组本身是引用类型的。

语法：

动态创建数组：创建和赋值分开写。

数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度];

数组定义格式详解：

数组存储的数据类型： 创建的数组容器可以存储什么数据类型。

[] : 表示数组。

数组名字：为定义的数组起个变量名，满足标识符规范，可以使用名字操作数组。

new ：关键字，创建数组使用的关键字。

数组存储的数据类型： 创建的数组容器可以存储什么数据类型。

[ 长度]：数组的长度，表示数组容器中可以存储多少个元素。

注意：创建数组时要指明数组的大小(长度，容量)，然后再使用,数组有定长特性，长度一旦指定，不可更改。

int [] arr = new int[5]; //先创建
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;

静态创建数组：创建数组和赋值写一起

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

示例：

public class Demo1 {
    public static void main(String[] args) {
        /*
        数组的标识是[];arr=Array
        语法：
        数据类型[] 数组名 = new 数据类型[数组的长度];
        数组是引用类型
        数组声明之后，没有赋值，那么他的默认值和成员变量一样。。。
        */
        
        //第一种定义方式：动态初始化，
        int[] arr = new int[3];
        //System.out.println(arr);
        //方法数组元素的语法：数组名[下标]
        arr[0] =1;//存数据
        arr[1] =2;
        arr[2]= 5;
        
        System.out.println(arr[0]);//取数据
        System.out.println("arr[1]--->"+arr[1]);
        System.out.println("arr[2]---->"+arr[2]);
        //System.out.println("arr[2]---->"+arr[3]);//访问数组的元素的时候，下标超过了边界，那
        //java.lang.ArrayIndexOutOfBoundsException: 3,这个叫数组越界异常
        
        // String[] arr2 = new String[3];
        // System.out.println("arr2[0]---->"+arr2[0]);
        
        //可以新建任意类型的数组，但是数组本身是引用类型
        //Object[] arr2 = new Object[3];
        
        //第二种：静态初始化
        /*
        左边是声明数组，开辟内存；
        右边里面大括号{}包含的元素个数，顺序，会自动计算长度，还有元素的位置
        */
        int[] arr2 = {1,4,5,6,7};
        
        //访问数组的长度:数组名.length
        System.out.println("arr2.length="+arr2.length);
    }
}

数组名(arrName)，数组的类型(type)，长度(容量length)，下标(index)，元素(element)

注意点：

        数组只有一个名称，即标识符

        元素索引标明了元素在数组中的位置，下标从0开始

        数组中的每个元素都可以通过下标来访问

        数组的长度固定不变，避免数组越界

        数组变量属于引用类型

        数组元素的默认值和成员变量的默认值一样

数组的遍历

方法一

普通for循环：

for(int i =0 ;i < arr.length;i++){
    System.out.println(arr[i]);
}

方法二

增强for循环(jdk1.5)：

//语法：
for(type element : array){
    System.out.println(element);
}

//示例代码：
for (int e : arr) {
    System.out.println("--->" + e);
}

缺陷：遍历数组或集合时无法访问索引(下标)值

用途：一般用于遍历显示数组或集合中元素的内容。

增强for能不能给数组赋值？

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

int[] arr2= new int[3];

int i=0;
for(int e:arr){
    //e = 10;//不可以；
    arr2[i] = e;
    i++;
}

for(int a:arr2){
    System.out.println(a);
}

public class ArrayDemo2 {
    public static void main(String[] args) {
        int[] arr = {1,5,4,3,46};//定义一个数组
        System.out.println("数组的长度："+arr.length);
        System.out.println("访问数组的元素arr[0]:"+arr[0]);

        //第一种方式：for循环，通过下标。。。
        for(int i=0;i

可变参数

一个方法中，参数的类型确定，但是数量不确定。就可以使用可变参数。

方法当中可变参数，就是数组。

语法： 参数类型 ... 参数名

调用：参数的数量：0-多个

public class ArrayDemo3 {

    //求不确定个数int类型的数字的和
    //可变参数:可以是0个~多个
    public static int getSum(double d,int... nums){
        int sum = 0;
        for (int e:nums){
            sum +=e;
        }
        return sum;
    }

    public static void main(String[] args) {

        int sum = getSum(1,3,56);
        System.out.println("sum:"+sum);

    }
}

注意事项：

1.一个方法最多只能有一个可变参数。

2.如果形参列表中，除了可变参数，还有其他的参数，可变参数要位于参数列表的末尾。

数组拷贝

浅拷贝：拷贝的是内存地址，

深拷贝：拷贝的是数值。

public class ArrayDemo4 {
    public static void main(String[] args) {

        int[] arr = {3,4,67,3,12};

        int[] arr2 = arr;//浅拷贝：拷贝的是内存地址
        arr2[0] = 100;
        System.out.println("arr[0]:"+arr[0]);

        System.out.println("arr2[0]:"+arr2[0]);

        System.out.println("----------------------");

        //深拷贝：拷贝的是内容
        int[] arr3 = new int[arr.length];
        for (int i = 0; i < arr3.length; i++) {
            int num = arr[i];
            arr3[i] = num;
        }

        arr3[0] = 30;
        System.out.println("arr[0]:"+arr[0]);

        System.out.println("arr3[0]:"+arr3[0]);

    }
}

Arrays数组的工具类

常用方法：

        binarySearch(数组，key)-->int，二分搜索

        sort(数组)-->void，排序

        toString(数组)-->String，按照字符串打印数组中的内容

        copyOf(原始数组，新数组长度)-->新数组，数组拷贝

        equals(数组1，数组2)-->boolean

示例：

import java.util.Arrays;

public class ArraysDemo {
    public static void main(String[] args) {

        //binarySearch(数组，key)-->int，二分搜索
        int[] arr = {4,5,12,76,23};
        //注意：搜索方法一定要先排序
        //排序
        Arrays.sort(arr);

        System.out.println("arr:"+Arrays.toString(arr));//按照字符串打印数组中的内容
        System.out.println("-------------------");
        int index = Arrays.binarySearch(arr, 23);//找到要查找的值所在的下标
        System.out.println("5所在的下标是："+index);

        //数组的拷贝
        int[] newArr = Arrays.copyOf(arr, 5);//这个拷贝是深拷贝
        System.out.println("newArr:"+Arrays.toString(newArr));

        System.out.println("----------------------");
        //boolean equals = arr.equals(newArr);//这个equals调用的是Object类的equals方法，比较的是内存地址
        //只比较数组的内容
        boolean equals = Arrays.equals(arr, newArr);
        System.out.println("equals:"+equals);
    }
}

二维数组

一维数组，容器，存储了一组数据。数组名配合下标获取到的就是元素数据了，也就是数值。

二维数组，容器，存储一维的一维。二维数组中的元素，而是一维数组。

public class ArrayDemo5 {
    public static void main(String[] args) {
        int[] arr = {5,4,2,15,45};

        //二维数组里面的元素就是一维数组
        //动态声明：
        int[][] arrEle = new int[3][4];//第一个长度3：表示的这个二维数组存放了3个一维数组；第二个长度4:表示每个一维数组存放多少个数字
        arrEle[0][0] = 23;
        arrEle[0][1] = 1;

        System.out.println("arrEle:"+arrEle);//二维数组的地址
        System.out.println("arrEle[0]:"+arrEle[0]);//第一个一维数组的地址
        System.out.println("arrEle[0][0]:"+arrEle[0][0]);//第一个一维数组的第一个元素
        System.out.println("===================================");
        //静态初始化：
        int[][] newArr = {{2,3},{4,23},{98,54,123}};//这个叫锯齿数组

        //遍历：
        for (int i = 0; i < newArr.length; i++) {
            //先获取每一个一维数组
            int[] ints = newArr[i];
            //再遍历这个一维数组
            for (int j = 0; j < ints.length; j++) {
                int ele = ints[j];
                System.out.println("ele:"+ele);
            }
            System.out.println("-----------------");
        }
        //
        System.out.println("=====================");
        //foreach快捷键：iter+tab键
        for (int[] ints : newArr) {
            for (int ele : ints) {
                System.out.println("ele:"+ele);
            }
        }
    }
}