Java数组

一、数组概述

• 数组是相同类型数据的有序集合
• 数组描述的是相同类型的若干数据，按照一定的先后次序排列组合而成
• 其中，每一个数据称作一个数组元素，每一个数组元素可以通过一个下标来访问他们
• 数组也是对象。数组元素相当于对象的成员变量。
• 数组对象本身是在堆中的

二、数组声明创建

• 内存分析
  
  
• 三种初始化状态
  • 静态初始化
    • int[] a = {1,2,3,4,5,6,7,8};
    • Man[] mans = {new Man(),new Man()};
  • 动态初始化
    • int[] a = new int[2]; a[0] = 1; a[1] = 2;
  • 数组的默认初始化
    • 数组是引用类型

三、数组使用

1. 普通的for循环
2. For-Each循环
3. 数组作方法入参
4. 数组作返回值

四、多维数组

public static void main(String[] args) {

        //[4][2]
        int[][] array = {{1,2},{2,3},{3,4},{4,5}};

        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.println(array[i][j]);
            }
        }
}

五、Arrays 类

• 数组的工具类java.util.Arrays
• 给数组赋值：fill方法
• 对数组排序：sort方法，按升序
• 比较数组：equals方法比较数组中元素值是否相等
• 查找数组元素：binarySearch方法能对排序好的数组进行二分查找法操作

public static void main(String[] args) {

        int[] a = {1,2,3,4,9599,41544,456,21,3,23};

        System.out.println(a);
        //打印数组元素
        //System.out.println(Arrays.toString(a));

        //printArray(a);

        Arrays.sort(a); //数组进行排序：升序
        System.out.println(Arrays.toString(a));

        Arrays.fill(a,0);   //数组填充
        //Arrays.fill(a,2,4,0);   //数组2~4之间填充
        System.out.println(Arrays.toString(a));

    }

    public static  void printArray(int[] a){
        for (int i = 0; i < a.length; i++) {
            if (i==0){
                System.out.print("[");
            }
            if (i==a.length-1){
                System.out.print(a[i] + "]");
            }else {
                System.out.print(a[i] + ", ");
            }
        }
    }

六、冒泡排序

• 两层循环，外层冒泡轮数，里层依次比较

import java.util.Arrays;

    //冒泡排序
    //1.比较数组中两个相邻的元素，如果第一个数比第二个数大，就交换他们的位置
    //2.每一次比较都会产生出一个最大或者最小的数字
    //3.下一轮则可以少一次排序！
    //4.依次循环，直到结束

public class ArrayDemo07 {
    public static void main(String[] args) {
        int[] a = {1,4,5,6,72,2,2,2,25,5,7};

        int[] sort = sort(a);   //调用完自己写的排序方法后，返回一个排序后的数组

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

    }

    public static int[] sort(int[] array){
        //临时变量
        int temp = 0;

        //外层循环，判断要走多少次
        for (int i = 0; i < array.length - 1; i++) {

            boolean flag = false;   //通过flag标识位减少没有意义的比较

            //内层循环，比较判断两个数，如果第一个数比第二个数大，则交换位置

            for (int j = 0; j < array.length - 1; j++) {
                if (array[j+1]<array[j]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = true;
                }
            }

            //如果flag没有变成true，也就是说，任意相邻的两个数，左边的数小于右边，
            //这时整个数组已经是有序的状态了，所以就不用再进行比较了，就可以break跳出循环了
            if (flag==false){
                break;
            }

        }

        return array;
    }


}

七、稀疏数组（见ArrayDemo08）

• 当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。
• 稀疏数组的处理方式是：
  • 项目记录数组一共有几行几列，有多少个不同值
  • 项目把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模
  • 项目如下图：左边是原始数组，右边是稀疏数组