Java数组

前言

如果我要给妹子送10部手机，但是我的双手只能拿2部；

此时我就需要1个袋子，这个袋子可以装下10部手机，我把10部手机装进这1个袋子中；

然后拎起袋子，把这个装有10部手机的袋子，送给妹子；

Java中的数组相当于上文提到的袋子，数组是用于存储相同数据类型的集合；

一、创建数组

在Java中，创建数组有以下3种方式：

方式1：              由于JVM会自动给声明了长度的数组内填充默认值，我们称方式1为动态赋值；

方式2、方式3：我们不仅确定了数组的长度，还确定了数组中所有元素，固称为静态赋值；

package ArryOpration;

public class TestArray {
    public static void main(String[] args) {
        //方式1：只是声明了变量+开辟了存储5个格子大小的内存空间，没有在格子中写入数据
        int[] bag = new int[5];
        for (int i : bag) {
            System.out.println(i);
        }
        //方式2：声明变量+开辟内存空间+写上数据
        int[] bag1 = {1, 2, 3, 4, 5};
        for (int i : bag1) {
            System.out.println(i);
        }

        //方式3：声明变量+开辟内存空间+写入数据
        int[] bag2 = new int[]{6, 7, 8, 9, 10};
        for (int i : bag2) {
            System.out.println(i);
        }


    }

}

 二、使用数组

Java数组在内存中是连续的，所以我们根据索引来查询数组中的元素很快；

然而一旦数组结构需要更改，例如增加、删除元素操作，就需要大量移动元素或者重新创建数组，所以数组查询快、操作比较耗时；

所以一般使用数组储结构基本不会修改的数据；

package ArryOpration;

public class TestArray {
    public static void main(String[] args) {
        int[] bag2 = new int[]{6, 17, 82, 9, 10};
        //索引取值
        System.out.println(bag2[2]);
        //数组遍历
        for (int i = 0; i < bag2.length; i++) {
            System.out.println(bag2[i]);
        }
        for (int i : bag2) {
            System.out.println(i);
        }
        //寻找数组最大的数字
        int max_number = 0;
        for (int i : bag2) {
            if (i >= max_number) {
                max_number = i;
            }
        }
        System.out.println(max_number);

        //数组求和
        int sum_number = 0;
        for (int i : bag2) {
            sum_number += i;
        }
        System.out.println(sum_number);
    }

}

1.append元素

在Python中list类型自带了append、insert、extend方法，方便我们在list中添加元素；

Python 3.7.6 (tags/v3.7.6:43364a7ae0, Dec 19 2019, 00:42:30) [MSC v.1916 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> a=[1,2,3]
>>> id(a)
2680172336136
>>> b=[4,5,6]
>>> id(b)
2680173603592
>>> a.extend(b)
>>> id(a)
2680172336136
>>> a.append(2)
>>> id(a)
2680172336136
>>> a.insert(1,3)
>>> a
[1, 3, 2, 3, 4, 5, 6, 2]
>>> id(a)
2680172336136
>>>

 在Java中数组长度是固定的，我们需要自己去实现；

package ArryOpration;

import java.util.Arrays;

public class TestArray {
    public static void main(String[] args) {
        String[] l1 = {"我", "是"};
        String[] l2 = {"张", "根"};
        String[] l3 = new String[l1.length + l2.length];
        for (int i = 0; i < l1.length; i++) {
            l3[i] = l1[i];
        }
        for (int i = 0; i < l2.length; i++) {
            l3[l1.length + i] = l2[i];
        }
        //把l3的内存地址赋值给l1
        l1=l3;
        System.out.println(Arrays.toString(l1));
    }

}

2.remove元素

re-重新-move移动，重新移动了=删除；

方案1：

package ArryOpration;

import java.util.Arrays;

//删除数组中的某个元素
public class TestArray01 {
    public static void main(String[] args) {
        int[] array1 = {3, 4, 5, 6, 2, 7, 8, 9};
        //删除索引为2的元素
        int del_index = 2;
        //step1:从删除的位置开始，向前移动元素
        for (int i = del_index; i < array1.length - 1; i++) {
            array1[i] = array1[i + 1];
        }
        //step2:将最后1个闲置位的元素，置为0；
        array1[array1.length - 1] = 0;
        System.out.println(Arrays.toString(array1));

    }

}

方案2：

package ArryOpration;

import java.util.Arrays;

public class TestArray02 {
    public static void main(String[] args) {
        int[] array1 = {1, 9, 9, 8, 0, 5, 8, 9};
        //删除索引为5的元素
        int del_index = 5;
        //step1:创建1个新的数组
        int[] new_array = new int[array1.length - 1];
        //step2:移动目标索引之前的元素；
        for (int i = 0; i < del_index; i++) {
            new_array[i] = array1[i];
        }
        System.out.println(Arrays.toString(new_array));
        //step3:移动目标索引之后的元素；
        for (int i = del_index + 1; i < array1.length; i++) {
            new_array[i - 1] = array1[i];
        }
        //step4:使array1栈内存存储的引用地址和new_array相同；
        array1 = new_array;
        System.out.println(Arrays.toString(array1));
    }
}

3.练习

3.1 分类数组中的奇数和偶数

package ArryOpration;
/*
 *@Description: 数组中的奇数和偶数分别存放到2个不同的数组里面；
 *@Author：  Gen.Zhang
 *@CreateDate: 2013.06.25
 */

import java.util.Arrays;

public class Practice {
    public static void main(String[] args) {
        int[] array1 = {12, 4, 5, 6, 85, 54, 74, 95, 65, 82, 26, 34};
        //Step1:统计一下奇数或者偶数的个数，以便确定动态创建存储奇数和偶数的数组长度；
        int odd_counter = 0;
        for (int n : array1) {
            if (n % 2 == 0) {
                odd_counter += 1;
            }
        }
        //Step2:创建存储奇数和偶数的数组
        int[] odd_array = new int[odd_counter];
        int[] even_array = new int[array1.length - odd_counter];
        //Step3:记录奇数数组和偶数数组中当前的索引位置；
        int odd_current_position = 0;
        int even_current_position = 0;
        //Step4:遍历数组array1并判断奇偶；
        for (int n : array1) {
            if (n % 2 == 0) {
                odd_array[odd_current_position] = n;
                odd_current_position++;
            } else {
                even_array[even_current_position] = n;
                even_current_position++;
            }
        }
        System.out.println(Arrays.toString(odd_array));
        System.out.println(Arrays.toString(even_array));
    }
}

二、Arrays数组工具类

JRE提供了1个叫Arrays的工具类，封装了排序、查找极值、遍历输出等功能，可以帮助我们对数组进行操作；

package ArryOpration;

import java.util.Arrays;

public class TestArray {
    public static void main(String[] args) {
        int[] bag2 = new int[]{6, 17, 82, 9, 10};
        //显示数组
        int[][] bag1 = new int[][]{{1, 2}, {3, 4}};
        for (int[] a : bag1) {
            System.out.println(Arrays.toString(a));
        }
        System.out.println(Arrays.toString(bag1));
        System.out.println(Arrays.toString(bag2));
        //通过二分法，对数组进行排序然后再获取元素的索引
        Arrays.sort(bag2);
        System.out.println(Arrays.toString(bag2));
        System.out.println(Arrays.binarySearch(bag2, 9));
        //切片数组中的元素
        int[] new_array = Arrays.copyOf(bag2, 4);
        System.out.println(Arrays.toString(new_array));
        //区间切片
        int[] new_array1 = Arrays.copyOfRange(bag2, 1, 4);
        System.out.println(Arrays.toString(new_array1));
        //判断2个数组中的值是否相等？
        int[] array1 = {1993, 0};
        int[] array2 = new int[]{1993, 0};
        System.out.println(Arrays.equals(array1, array2));
        //从数组1中复制元素到数组2
        int[] src_array = new int[]{1, 2, 3, 4};
        int[] des_array = new int[10];
        //将源数组下标位1开始，复制到目标数组的下标3，一共复制3个元素
        System.arraycopy(src_array, 1, des_array, 3, 3);
        System.out.println(Arrays.toString(des_array));

    }

}

三、二维数组

在机器学习中数据集最终会变成1个数字类型二维数组；

但是我在Python里定义二维数组时，思维是由外至内的；[ [1,2,3],[2,4,5,9] ];

在Java中定义二维数组时思维是由内向外：1个int圈起来=int[]=数组，再把数组圈起来=int[][]=1个二维数组；

package ArryOpration;

import java.util.Arrays;

public class TestArray {
    public static void main(String[] args) {
        String[][][][] a1 = {{{{}}}};
        System.out.println(Arrays.toString(a1));

    }

}

参考