数组

一维数组

数组声明

• 语法格式：

  数据类型[] 数组名;

  数据类型 数组名[];

• 示例：

  int[] a;
  
  int b[];

数组创建

• 语法格式一：先声明，再创建

  数据类型[] 数组名;

  数组名 = new 数据类型[数组长度];

  示例：

  
  int[] arr;
  
  arr = new int[5];

• 语法格式二：声明的同时创建数组

  数据类型[] 数组名 = new 数据类型[数组长度];

  示例：

  int[] arr = new int[5];

  注意：数组长度必须指定

数组的初始化

• 声明数组的同时给数组赋值，叫做数组的初始化

示例：

int[] arr = {1,2,3,4,5};//常用
//或
int[] arr=new int[]{1,2,3,4,5};

数组访问

• 语法格式：

  数组名[索引值]

  索引值从 0 开始

数组的长度

• 语法格式：

  数组名.length

二维数组

• 语法格式：

  数据类型[][] 数组名;

  示例：

  //创建一个三行三列int类型数组
  int[][] array = new int[3][3];
  //二维数组初始化
  int[][] array = { {1,2,3}, {4,5,6}, {7,8,9} };

数组的默认值

数组的默认值：数组作为引用数据类型 其元素是有默认值的 当我们给数组开辟空间以后 默认值即存在

整数：0

浮点：0.0

字符：\u0000

布尔：false

其他：null (空)

JDK 提供了一个用于操作数组的工具类 java.util.Arrays

此类中提供大量的用于操作数组的各种方法

Arrays.toString(数组名) : 将数组中的元素转换为字符串 返回

import java.util.Arrays;

public class TestArrayDefaultValue {
    public static void main(String[] args) {
        byte [] arr1 = new byte[3];
        String str = Arrays.toString(arr1);
        System.out.println("str = " + str);

        short [] arr2 = new short[4];
        System.out.println(Arrays.toString(arr2));

        System.out.println("----------------------------------------------");

        // 关于null值 以及 空指针异常  NullPointerException
        // 使用一个为null的对象 调用任何的属性 或者 方法 都将出现空指针异常
        String [] arr9 = new String[2];

        System.out.println(Arrays.toString(arr9));// [null, null]
    }
}

数组的复制

复制数组的三种方式：

​ 循环将原数组中所有元素逐一赋值给新数组。

​ System.arraycopy(原数组,原数组起始,新数组,新数组起始,长度);

​ java.util.Arrays.copyOf(原数组, 新长度);//返回带有原值的新数组。

import java.util.Arrays;

/**
 *  复制数组的三种方式：
 *      循环将原数组中所有元素逐一赋值给新数组。
 *      System.arraycopy(原数组,原数组起始,新数组,新数组起始,长度);
 *      java.util.Arrays.copyOf(原数组, 新长度);//返回带有原值的新数组。
 */
public class TestArrayCopy {
    public static void main(String[] args) {
        int [] oldArr = {1,2,3,4,5};

        int [] newArr = new int[10];

        //原数组从下标1开始复制到新数组的下标2位置，复制2个元素
        System.arraycopy(oldArr, 1, newArr, 2, 2);

        System.out.println(Arrays.toString(newArr));//[0, 0, 2, 3, 0, 0, 0, 0, 0, 0]

        System.out.println("-------------------------------------------------");

        int [] nums = {11,22,33,44,55};

        // 第一个参数 原数组
        // 第二个参数 新长度 新长度可以小于等于或者大于原数组的长度
        int [] newNums = Arrays.copyOf(nums, 5);

        System.out.println(Arrays.toString(newNums));
    }
}

冒泡排序

import java.util.Arrays;

/**
 *  冒泡排序：相邻的两个元素比较大小 条件成立 则交换位置 直到数列排列正确
 *
 *  比较的轮数为：n - 1
 *  每一轮比较的次数：n - 1 - ?
 *
 *  外层循环控制比较的轮数：n - 1
 *  内存循环控制每一轮比较的次数：n - 1 - i
 *
 */
public class TestBubbleSort {
    public static void main(String[] args) {
        int[] array = {10, 5, 3, 7, 2, 1, 4, 8, 9, 6};
        int temp;
        for(int i = 0; i < array.length - 1; i++){
            //内层循环控制每趟排序
            for(int j=0; j < array.length - 1 - i; j++){
              if(array[j] > array[j+1]){
                  temp = array[j];
                  array[j] = array[j+1];
                  array[j+1] = temp;
              }
            }
        }
        System.out.println(Arrays.toString(array));
    }
}

Arrays 工具类

java.util.Arrays 是 JDK 提供的一个用于操作数组的工具类

toString(数组名) : 将数组中的元素转换为字符串

copyOf(数组名,新长度) : 复制数组

sort(数组名) : 将数组按照升序排序 属于快速排序 实现原理为 递归

fill(数组名,填充元素) : 将数组按照指定元素进行填充

binarySearch(数组名,元素) : 使用二分查找法查找某个元素在数组中的下标（数组必须先升序排序）

import java.util.Arrays;

public class TestArrays {
    public static void main(String[] args) {
        int [] nums = {56,12,22,41,85,99};

        Arrays.sort(nums);

        System.out.println(Arrays.toString(nums));

        int [] newArr = new int[nums.length];

        for(int i = 0,j = nums.length -1;i < nums.length;i++,j--){
            newArr[i] = nums[j];
        }

        System.out.println(Arrays.toString(newArr));

        System.out.println("--------------------------------------------");

        Arrays.fill(newArr, 666);

        System.out.println(Arrays.toString(newArr));

        System.out.println("--------------------------------------------");

        int index = Arrays.binarySearch(nums, 999);

        System.out.println("index = " + index);

    }
}

数组插入元素

编写方法实现在数组中插入元素

扩展：可以使用 System.arraycopy 方法 实现插入效果

import java.util.Arrays;

/**
 *  编写方法实现在数组中插入元素
 *  扩展：可以使用System.arraycopy方法 实现插入效果
 */
public class TestArrayInsert {
    public static void main(String[] args) {
        int [] nums = {1,2,3,4,5};
        int[] newArray = insert(nums, -8, 666);
        System.out.println(Arrays.toString(newArray));
    }
    /**
     *
     * @param oldArray 操作的数据
     * @param index 插入元素的位置
     * @param num 插入的元素
     * @return 新的数组
     */
    public static int[] insert(int [] oldArray,int index,int num){
        // 下标不能小于0 或者 不能大于数组的长度
        if(index < 0 || index > oldArray.length){
            System.out.println("下标不合法");
            // 如果下标不合法 则将传入的数组 直接返回 表示没有做任何操作
            return oldArray;
        }

        // 代码执行到这里 表示下标没问题
        // 准备一个长度+1的数组 用于插入元素
        int [] newArray = new  int[oldArray.length + 1];

        // 遍历开始移动元素
        for(int i = 0;i < oldArray.length;i++){
            // 情况1 小于插入下标 则直接复制到新数组中
            if(i < index){
                newArray[i] = oldArray[i];
            }else{ // 情况2  大于或者等于插入下标 则移动到新数组的+1位置
                newArray[i + 1] = oldArray[i];
            }
        }
        // 空缺位插入指定的元素
        newArray[index] = num;
        return newArray; // 将新数组返回
    }
}

数组删除元素

编写方法实现删除数组中的元素

扩展：可以使用 System.arraycopy 方法 实现删除效果

import java.util.Arrays;

/**
 *  编写方法实现删除数组中的元素
 *  扩展：可以使用System.arraycopy方法 实现删除效果
 */
public class TestArrayDelete {
    public static int[] delete(int [] oldArray,int index){
        // 判断下标 如果小于0 或者 大于等于数组长度 表示不合法 因为删除 只能删除有效范围以内的
        if(index < 0 || index >= oldArray.length){
            System.out.println("下标不合法");
            return oldArray; // 直接将传入的原数组返回 表示没有做任何操作
        }

        // 准备一个长度-1的数组 用于删除之后复制元素
        int [] newArray = new int[oldArray.length - 1];
        // 循环遍历开始复制元素
        for(int i = 0;i < newArray.length;i++){
            if(i < index){ // 情况1 小于删除的下标 直接复制
                newArray[i] = oldArray[i];
            }else{ // 情况2 大于等于删除下标 则直接将原数组的+1位置 移动到新数组的后续位置 属于向左移动覆盖
                newArray[i] = oldArray[i +1];
            }
        }
        return newArray; // 将新数组返回
    }

    public static void main(String[] args) {
        int [] nums = {1,2,3,4,5};
        int[] delete = delete(nums, -5);
        System.out.println(Arrays.toString(delete));
    }

}

增强型 for 循环

• 语法格式： for(数据类型 变量名 : 数组名)

• 示例：

int[] arr = {1,2,3,4,5};
for(int a : arr) {
	System.out.println(a);
}