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);
            }
        }
    }
}

你可能感兴趣的:(JavaSE基础,java)