07.Java数组

Java数组

数组概述

• 数组的定义

  • 数组是相同类型数据的有序集合
  • 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成
  • 每一个数据称作一个数组元素，每个数据元素可以通过一个下标来访问它们

数组声明创建

• 首先必须先声明数组变量，才能在程序中使用数组

  //变量的类型 变量的名字 = 变量的值；
  // 数组类型
  int[] nums; //1.定义 建议如此定义 声明一个数组
  int nums1[];
  
  nums = new  int[10];// 2.创建一个数组
  //3.给数组元素中赋值    获取数组长度 数组名.length
  for (int i = 0; i < nums.length; i++) {
      nums[i] = i;
      System.out.println(nums[i]);
  }
  

public static void main(String[] args) {
    //静态初始化   创建 + 赋值
    int[] a = {1,2,3,4,5};
    //动态初始化: 包含默认初始化
    int[] b = new int[10];
    b[0] = 1;

}

数组的四个基本特点

• 长度是确定的，数组一旦被创建，它的大小就是不可改变的

• 元素必须的相同类型，不允许出现混合类型

• 数组中的元素可以是任何数据类型，包括基本类型和引用类型

• 数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量

  数组本身就是对象，JAVA中对象是在堆中的，因此数组无论保存原始类型还说其他对象类型
  数组对象本身在堆中的

数组边界

• 下标的合法区间：[0, length-1]，如果越界就会报错

小结

• 数组是相同数据类型（数据类型可以为任意类型）的有序集合
• 数组也是对象，数组元素相当于对象的成员变量
• 数组长度确定，不可变

数组的使用

int[] arr = {1,2,3,4,5,6};
int sum = 0;
//打印全部的数组元素
for (int i = 0; i <arr.length ; i++) {
    System.out.println(arr[i]);
    sum += arr[i];
}
System.out.println("sum= " + sum);
//查找最大元素
int max = arr[0];
for (int i = 1; i <arr.length ; i++) {
    if (arr[i]>max){
        max = arr[i];
    }
}
System.out.println("max= "+ max);

• For-Each循环

//JDK1.5 取不到下标
        int[] arr = {1,2,3,4,5,6};
iter 快捷键
//        for (int a : arr){
//            System.out.println(a);
//        }
        int[] rev = reverse(arr);
        printArray(rev);
    }
    //反转数组  数组作为返回值
    public static int[] reverse(int[] arrays){
        int[] result = new  int[arrays.length]; //声明 int[] 数组名 = new int[长度]
        for (int i = 0,j = arrays.length-1; i < arrays.length;j--, i++) {
            result[j] = arrays[i];
        }
        return result;
    }

    //打印数组元素 方法	数组作为方法入参
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print( arrays[i] + " ");
        }
    }

• 数组作方法入参
• 数组作返回值

多维数组

• 多维数组可以看成是数组的数组，比如二维数，每一个元素都是一个一维数组

Arrays类

public static void main(String[] args) {
        int[] a ={8,78,5,4,22,4};
        System.out.println(a); //地址
        //打印数组元素
        System.out.println(Arrays.toString(a));
//        printArrys(a);
        Arrays.sort(a);//数组进行 升序排序
        System.out.println(Arrays.toString(a));
    }
    //重复造轮子
    public static void printArrys(int[] a){
        for (int i = 0; i <a.length ; i++) {
            System.out.print(a[i]+" ," );
        }
    }

冒泡排序

 public static void main(String[] args) {
        int[] a = {88,546,47,2,5,489,1};
        int[] sort = puff(a);//调用自己写的排序方法
        System.out.println(Arrays.toString(sort));

    }

    //冒泡排序
    //1.数组中两个相邻的元素，若第一个数比第二个大 就交换位置
    //2. 每一次比较都会 产生出一个最大 或者 最小的数
    //3. 下一轮则 可以少一次
    public static int[] puff(int[] array){
        //外层循环，判断走多少次
        int temp = 0;   //临时变量
        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;
                }
            }
        }
        return array;
    }

• 两层循环，外层冒泡轮数，里层依次比较
• 时间复杂度

$$时间复杂度O(n^2)$$

稀疏数组

• 稀疏数组的处理方式
  • 记录数据一个有几行几列，有多少不同值
  • 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

public static void main(String[] args) {
    //1.创建一个二位数组 11*11  0： 没有棋子  1：黑棋   2：白棋
    int[][] arr = new  int[11][11];
    arr[1][2] = 1;
    arr[2][3] = 2;
    //输出原始的数组
    System.out.println("输出原始的数组");
    for (int[] ints : arr) {
        for (int anInt : ints) {
            System.out.print(anInt + "\t");
        }
        System.out.println();
    }

    //转换为 稀疏数组 保存
    //获取有效值的个数
    int sum = 0;
    for (int i = 0; i <11 ; i++) {
        for (int j = 0; j <11 ; j++) {
            if (arr[i][j]!=0){
                sum++;
            }
        }
    }
    System.out.println("有效数："+ sum);

    //创建一个稀疏数组
    int[][] arr2 = new int[sum+1][3];
    arr2[0][0] = 11;
    arr2[0][1] = 11;
    arr2[0][2] = sum;
    //遍历二维数组 非零 存放到二位数组中
    int count = 0;
    for (int i = 0; i <arr.length ; i++) {
        for (int j = 0; j <arr[1].length ; j++) {
            if (arr[i][j]!=0){
                count++;
                arr2[count][0] = i;
                arr2[count][1] = j;
                arr2[count][2] = arr[i][j];
            }
        }
    }
    //输出稀疏数组
    for (int i = 0; i <arr2.length ; i++) {
        System.out.println(arr2[i][0]+ "\t"+
                arr2[i][1] + "\t" +
                arr2[i][2]);
    }

    //稀疏数组还原
    System.out.println("还原");
    //1.读取稀疏数组
    int[][] arr3 = new int[arr2[0][0]][arr2[0][1]];
    //2.其中的元素还原 值
    for (int i = 1; i <arr2.length ; i++) {
        arr3[arr2[i][0]][arr2[i][1]] = arr2[i][2];
    }
    //3.输出 还原后的数组
    System.out.println("输出原始后的的数组");
    for (int[] ints : arr3) {
        for (int anInt : ints) {
            System.out.print(anInt + "\t");
        }
        System.out.println();
    }


}