JAVA中的数组

     ✌️ 在Java中，数组是一种用于存储固定大小的相同类型数据项的数据结构，以下是Java数组的主要知识点：

---

一.声明数组:

数组的4种声明方式：

---

1.先声明再初始化

例如：

//1.声明

int[] nums;

//初始化

nums = new int[5];

2.声明并初始化

例如：

//2.声明、初始化

int[] nums = new int[10];

3.创建数组同时赋值

例如：

//3.创建数组同时赋值

String[] names=new String[]{"大名","小米","夏雨荷"};

int[] ages=new int[]{21,22,21,56,13};

for (int i = 0;i< names.length;i++){

System.out.prinrln(names[i]);

}

for (int i = 0;i< ages.length;i++){

System.out.prinrln(ages[i]);

}

4.创建同时赋值，简写，不能写成两条语句

例如：

//创建同时赋值，简写，不能写成两条语句

String[] cities = {"上海","北京"};

二. 数组的大小：

    Java中数组一旦创建，其大小不可修改，所以数组的扩缩容必须新建一个数组，然后将原来数组的元素复制到新数组中，最后返回新数组即可，然后在调用处用原来数组的引用指向新数组即可。

即可。

例如：

public static int[] resize(int[] arr, int newSize) {
    int[] newArr = new int[newSize];
    for (int i = 0; i < arr.length - 1; i++) {
        newArr[i] = arr[i];
    }
    return newArr;
}

三. 访问数组元素：

获取数组中的值的方法：    
新建一个类，定义一个int 类型的数组。开辟空间3个。然后分别赋值。
然后来获取到数组中，每个索引对应位置的，数据。

---

并输出打印该数组中存储的数据。

1、如何输出数组中元素的值：
(1)第一种方式：通过数组的索引引用，单个输出的方式。
数组名[对应索引]

int[] arr = new int[3];
arr[0] = 234;
arr[1] = 21211;
arr[2] = 54;
System.out.println("--------普通方式，输出数组中的内容--------");
System.out.println(arr[0] +","+arr[1]+","+arr[2]);
System.out.println(arr[1]);
System.out.println(arr[2]);

 （2）、第二钟方式，通过遍历的方式来输出打印。
遍历先要知道数组的知识点：
数组，角标，从0 开始，最大能取到 长度-1
数组的长度，可以用 ：arr.length 来获取。

int[] arr = new int[3];
//遍历，就是循环查询找到数组中的每一个元素。称之为遍历。
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
 

四. 多维数组：

在Java中，可以使用多个中括号表示多维数组。例如，int[][] arr = new int[3][4]。

五. 数组长度:

1. 使用“数组名.length”：

数组有一个属性length，通过给数组名加上.length可以返回数组的长度。但是要注意的是，返回的长度是数组的长度减去一，因为数组的下标从0开始，而数组的长度是从1开始的。

2. 使用 Arrays.asList().size() 方法：

Arrays.asList()方法是数组与集合的转换的一个方法，它把数组中的元素转换为List 集合，而把数组转换为List集合以后，就可以在List集合中使用size()方法获取数组的长度了。

3. 使用集合对象ArrayList.size() 方法。

 

六. 数组的遍历：

可以使用for，for...in循环遍历数组中的所有元素

. for循环

    // 最简单的一种循环遍历方法，也是使用频率最高的一种(可优化);循环过程中支持修改索引（修改 i）
        var arr = [1, 2, 3, 4, 5, 6]
        for(var i = 0; i < arr.length; i++) {
            console.log("普通for循环",arr[i])     //1 2 3 4 5 6
        }
    // 优化：使用临时变量，将长度缓存起来，避免重复获取数组长度，当数组较大时优化效果才会比较明显
        var arr = [1, 2, 3, 4, 5, 6]
        // var len = arr.length
        // for(var i = 0; i < len; i++) {
        //     console.log("优化后for循环",arr[i])     //1 2 3 4 5 6
        // }
        for(var i = 0,len=arr.length; i < len; i++) {
            console.log("优化后for循环",arr[i])     //1 2 3 4 5 6
        }
    // 能正确响应break、continue和return语句

2. for…in…

    // 这个循环效率比较低，适用于少量数据，也有不少人使用
        // 遍历数组，输出的 key 是数组索引
        var arr = ['我', '是', '谁', '我', '在', '哪']
        for(let key in arr) {
            console.log("for...in...遍历数组key",key)  // 0 1 2 3 4 5
            console.log("输出数组中key对应的值",arr[key])
        }
        // 遍历对象，输出的则是对象的属性名
        let obj = { a: 11, b: 22, c: 33 }
        for(let key in obj) {
            console.log("for...in...遍历对象key",key)  // a b c 
            console.log("输出对象中key对应的值",obj[key])
        }
    // 能正确响应break、continue和return语句

七. 数组的复制：

可以使用System.arraycopy()方法或Arrays.copyOf()方法对数组进行复制。

八. 数组排序：

JAVA中在运用数组进行排序功能时，一般有四种方法：快速排序法、冒泡法、选择排序法、插入排序法。

---

• 快速排序法:

主要是运用了Arrays中的一个方法Arrays.sort（）实现。

• 冒泡法:

是运用遍历数组进行比较，通过不断的比较将最小值或者最大值一个一个的遍历出来。

动图演示：

代码实现

import java.util.Arrays;

public class TestDemo {
    public static void main(String[] args) {
        int [] array = {7,14,3,22,1,6,15,60,5};
        for (int i = 0; i < array.length-1; i++) { //控制循环次数，比长度少一次。
            for (int j = 0; j < array.length-i-1; j++) { //后面排好的值不需要进行比较，所以减去i。
                if(array[j]>array[j+1]) {
                    int temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(array));
    }
}

测试结果

• 选择排序法:

是将数组的第一个数据作为最大或者最小的值，然后通过比较循环，输出有序的数组。

动图演示：

 

代码实现

import java.util.Arrays;

public class TestDemo {
    public static void main(String[] args) {
        int [] array = {7,14,3,22,1,6,15,60,5};
        for (int i = 0; i < array.length-1; i++) { //控制循环次数，比长度少一次。
            for (int j = 0; j < array.length-i-1; j++) { //后面排好的值不需要进行比较，所以减去i。
                if(array[j]>array[j+1]) {
                    int temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(array));
    }
}

测试结果

• 插入排序:

是选择一个数组中的数据，通过不断的插入比较最后进行排序。

动图演示：

代码实现

public class TestDemo {
    public static void main(String[] args) {
        int [] array = {7,14,3,22,1,6,15,60,5};
        int temp=0;
        for(int i=1;i<array.length;i++){
            int j=i-1;
            temp=array[i];
        for(;j>=0&&temp<array[j];j--){
            array[j+1]=array[j];//将大于temp的值整体后移一个单位   
        }
            array[j+1]=temp;
        }
        System.out.println(Arrays.toString(array));
    }
}

测试结果

 

九. 数组的引用传递：

数组是对象，在Java中，使用数组作为参数传递时，实际传递的是数组的引用。

十. 数组的初始化：

可以在声明数组时直接初始化数组，或者使用循环语句进行初始化。

---

• 动态初始化：

数据类型[]  数组名 = new 数据类型[数组的开辟空间大小的整数];

int[] arr = new int[3];    
数组的长度:arr.length;
数组的角标从0开始，最大能取到 数组的长度-1

动态初始化的默认值：
创建的int 类型数组，动态初始化，系统给默认值，为0.
创建String 类型，数组，动态初始化的时候，系统给默认值null

小数类型的  数组动态初始化，元素默认值 0.0
boolean 类型，数组动态初始化，元素默认值 false

 

例如: 

String[] names = new String[3];
names[0]=“孙猴子”;
names[1]=“唐僧”;
names[2]=“猪八戒”

• 静态初始化：

初始化时由程序员显示指定每个数组元素的初始值，由系统决定数组的长度
例如:
String[] names = new String[]{“孙猴子”,“唐僧”,“猪八戒”};

十一. Java中的内存分配以及栈和堆的区别和联系:

Java把内存划分成两种：一种是堆内存，一种是栈内存

栈 ：cpu 寄存区

所有的方法，进栈。
所有的局部变量引用，进栈。

栈遵循的存取规则：
先进的，后出
后进的，先出。
存储的时候，使用压栈的方式存储

当栈爆满的时候，优先销毁的是，后进去的。

 

堆 ：内存条，开辟内存区
new 出来的所有东西，进堆。

存储的数据，在堆中，随机开辟空间位置，没有具体的顺序。
内存爆满的时候，随机销毁数据。
电脑关机的时候，内存中所有数据销毁。