JAVA学习中之数组

数组

作用：数组用来将相同类型的若干数据组织起来。这个若干数据的集合我们称之为数组

数组的声明

如何定义数组

int[] arr ; //定义一个int类型的数组，名字叫arr
// 如果数组只声明，没有后续操作，那么这个数组相当于没有定义;
int arr2[]; 
// 数组赋值为null和不赋值 不同
int arr3[] = null;

数组的创建

// 给数组开辟一个长度为4的空间
// 编译期声明和创建会被合为一句话： int[] arr = new int[4];
arr = new int[4]

数组的赋值

arr[0] = 12;
arr[1] = 56;
arr[2] = 98;

数组的使用

System.out.println(arr[0] + 100);
System.out.println(arr.length);

数组的基本特点

1. 数组的长度是确定的。数组一旦被创建，它的大小就是不可改变的
2. 数组元素的类型必须是相同类型，不允许出现混合类型
3. 数组类型可以是任何数据类型，包括基本类型和引用类型
4. 数组是有索引的，索引从0开始，到数组.length-1结束
5. 数组变量属于引用类型，数组也是对象。
   ps: 数组变量属于引用类型，数组也是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中存储的。

数组的遍历

1. 方式一：普通for循环
2. 方式二：增强for循环
3. 方式三：普通for循环 逆向遍历
   ps 增强for循环
   优点：代码简单
   缺点：单纯的增强for循环不能涉及跟索引相关的操作

数组的初始化方式

1. 静态初始化

int[] arr = {12,23,45}
int[] arr = new int[]{12,23,45}
注意:
1: new int[3]{12,23,45} 错误
2: int[] arr ;
   arr = {12,23,45}  错误

2. 动态初始化

int[] arr;
arr = new int[3];
arr[0] = 12;
arr[1] = 23;
arr[2] = 45;

3. 默认初始化

int[] arr = new int[3]; --> 数组有默认初始化值

数组中元素的查询

1. 查询指定位置的元素

@Test
    public void test1(){
        int[] arr = {12,45,98,1};
        // 查询索引为0 位置的元素
        System.out.println(arr[0]);
    }

以上代码体现数组优点：
在按照位置查询的时候，效率非常高

2. 查询指定元素的位置 --> 返回对应的索引

@Test
    public void test1(){
        int[] arr = {12,45,98,1};
        int index = -1;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == 98){
                index = i;
                break;
            }
        }
        if(index != -1){
            System.out.println("对应索引为" + index);
        }else {
            System.out.println("查无此数");
        }
    }
    }

数组中元素的添加

public class ArrayTest1 {

    public static void main(String[] args) {
        int[] arr = {12, 34, 56, 7, 3, 10};
        insertEle(2,3,arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void insertEle(int index, int element, int[] arr) {
        for (int i = arr.length - 1; i >= index + 1; i--) {
            arr[i] = arr[i - 1];
        }
        arr[index] = element;
    }
}

数组中元素的删除

删除指定位置上的元素

public class ArrayTest1 {

    public static void main(String[] args) {
        int[] arr = {12, 34, 56, 7, 3, 10};
        deleteEle(2,arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void deleteEle(int index, int[] arr){
        for (int i = index; i < arr.length - 1  ; i++) {
            arr[i] = arr[i + 1];
        }
        arr[arr.length -1] = 0;
    }
}

删除指定元素

public class ArrayTest1 {

    public static void main(String[] args) {
        int[] arr = {12, 34, 56, 7, 3, 10};
        deleteEle(3,arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void deleteEle(int element, int[] arr){

        int index = -1;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] == element){
                index = i;
                break;
            }
        }
        
        if(index != -1){
            for (int i = index; i < arr.length - 1  ; i++) {
                arr[i] = arr[i + 1];
            }
            arr[arr.length -1] = 0;    
        }else {
            System.out.println("查无此元素");
        }
    }
}

Arrays工具类的使用

作为方便我们对数组操作，jdk提供了Arrays工具类

public class ArrayTest2 {
    public static void main(String[] args) {
        int[] arr = {1,3,7,2,4,8};
        System.out.println(Arrays.toString(arr));
        // binarySearch:二分法查找：找出指定数组中的指定元素对应的索引
        // 使用前提：数组必须是有序的数组
        int[] arr1 = {1,2,3,4,5,6};
        Arrays.sort(arr1);
        Arrays.binarySearch(arr1, 3);
        // sort 排序
        Arrays.sort(arr);
        // 数组复制copyOf:将老数组按照新的数组长度复制到新数组
        int[] arr2 = {1,3,7,9,5};
        int[] ints = Arrays.copyOf(arr2, 4);
        // 数组区间复制copyOfRange 区间[1,2) 左包含右不包含
        int[] ints1 = Arrays.copyOfRange(arr2, 1, 2);
        // equals: 比较两个数组的值是否一样
        int[] arr3 = {1,3,7,9,5};
        int[] arr4 = {1,3,7,9,5};
        Arrays.equals(arr3,arr4);
        // fill : 进行数组的填充 也可以区间填充
        int[] arr5 = {1,3,7,9,5};
        Arrays.fill(arr5,2,3,10);
    }
}

数组的复制

src	源数组
srcPos	源数组中的起始位置
dest	目标数组
destPos	目标数据中的起始位置
lengh	要复制的数组元素的数量

@Test
    public void test1(){
        int[] srcArr = {12,45,55,6,6,7};
        int[] destArr = new int[10];
        System.arraycopy(srcArr,1,destArr,3,3);
        System.out.println(Arrays.toString(destArr));
    }