Java数组

1.数组概述

定义：数组是相同类型的有序集合，同一组同一类型的数据可以按照先后次序排列组合在一起，其中一个数据可以称为元素，每个数组元素可以通过一个下表访问它们

2.数组声明创建

dataType[] arrayRefVar; //first
dataType arrayRefVar[]; //no first

数组也是一种对象，可以通过new操作符创建数组对象，如下：

dataType[] arrayRefVar = new dataType[arraySize];
//我们可以通过数组.length属性获取其中的arraySize
let leng = arrayRefVar.length;

实例：在Java代码中创建数组

public class Demo3 {
    public static void main(String[] args){
        int[] sums = {}; //定义一个空数组
        int[] sums2 = {1,2,3,53,565,24,6,6,343,664,355};//定义包含1，2，3的数组

        //使用指针定义数组
        int[] sums4 = new int[10];
        int[] sums5 = {3,2,3,2};

        //使用第一种for循环遍历数组 计算总和
        int total = 0;
        System.out.println("==============>第一种");
        for (int i : sums2) {
            total+=i;
        }
        System.out.println("total:"+total);
        System.out.println("==============>第二种");
        //使用第二种for循环遍历数组
        for(int i = 0;i < sums5.length; i++){
            System.out.println(sums5[i]);
        }
    }
}

在Java中如果每给数组元素初始化，那么默认值为0

数组大小是固定的，一旦定义无法改变

3. Java内存分析

数组的3种初始化方式

public class Demo3 {
    public static void main(String[] args){
        //静态初始化 定义+初始化 Java会自动计算数组大小
        int[] dataArr = {2021,5,20};

        //引用类型的数组
        Demo3[] demoData = {new Demo3(),new Demo3()};

        //动态初始化数组,利用new关键词创建 需要后期给他赋值
        //没有初始化默认是0
        int[] dataArr2 = new int[3];
        for (int i = 0; i < dataArr2.length; i++)
            dataArr2[i] = i;//遍历数组 然后主意赋值
        
    }

}

4.数组的基本特点

• 确定的长度 一旦创建无法更改
• 必须是相同类型的有序集合
• 可以是如何数据包括引用类型
• 数组本身属于引用类型，是一种对象，Java对象存放在堆中
  • 只要是new出来的对象都是在堆中

数组边界

数组的合法区间:[0,length-1]

如果越界就会报错

ArrayIndexOutOfBoundsException:数组下标越界异常

public static void main(String[] args){
    int[] ten = new int[10];
    System.out.println(a[10]); //error!!!
}

练习题：数组逆序

public class Demo3 {
    public static void main(String[] args){
        int[] arrays = {1,2,3,4,5,6,7,8,9};
        int[] res = reverse(arrays);
        for (int re : res) {
            System.out.println(re);
        }
    }

    public static int[] reverse(int[] arr){
        int[] temp = new int[arr.length];
        for(int i = arr.length-1,j = 0;i >= 0; i--,j++){
            temp[j] = arr[i];
        }

        return temp;
    }
}

5.二维数组

二维数组的定义方法：

int[][] array = {{123,3},{23,43},{22,544}};

二位数组的调用：

public class Demo3 {
    public static void main(String[] args){
        int[][] ewArr = {{1,23,4,42},
                         {22,54,23,54},
                         {23,43,23,34,54}
                        };
        System.out.println(ewArr[0][1]);//获取第一行第二列的元素
        
    }
}

遍历二维数组：

public class Demo3 {
    public static void main(String[] args){
        int[][] ewArr = {{1,23,4,42},
                         {22,54,23,54},
                         {23,43,23,34,54}
                        };
        for(int i = 0;i < ewArr.length;i++){
            for(int j = 0;j < ewArr[i].length;j++){
                System.out.print(ewArr[i][j]+"\t");
            }
            System.out.println("");
        }
        System.out.println("===============>");
        //利用for-each循环打印
        for(int i = 0;i < ewArr.length;i++){
            for(int item:ewArr[i]){
                System.out.print(item+"\t");
            }
            System.out.println("");
        }
    }

}

6. Arrays类

import java.util.Arrays

import java.util.Arrays;

public class Demo3 {
    public static void main(String[] args){
        int[] arr = {10,23,4,56,34,22,65,32,62};

        //数组排毒
        Arrays.sort(arr);
        //把数组转换为字符串
        String str = Arrays.toString(arr);
        System.out.println(str);
        //通过fill方法快速赋值
        Arrays.fill(arr,0,arr.length,5201314);
        // = Arrays.fill(arr,5201314);
        System.out.println(Arrays.toString(arr));
    }
}

拓展：Java中Arrays类的常用方法

7.冒泡排序

import java.util.Arrays;

public class Demo3 {
    public static void main(String[] args){
        int[] arr = {10,23,4,56,34,22,65,32,62};

        for (int i = 0; i < arr.length; i++) {
            for (int j = i; j < arr.length; j++) {
                if(arr[i] < arr[j] ){
                    arr[i] = arr[i] + arr[j];//4 + 5 = 9
                    arr[j] = arr[i] - arr[j];//9 - 5 = 4
                    arr[i] = arr[i] - arr[j];//9 - 4 = 5
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

冒泡排序的时间复杂度为：O(n^2)