JavaDay04--数组

自学JavaDay04

数组

定义

相同类型数据（数据类型可以为任意类型）的有序集合

声明创建

• 声明数组变量

  dataType[] arrayRefVar;

  或

  dataType arrayRefVar[]; //不是首选方法

• 使用new操作符来创建数组

  dataType[] arrayRefVar = new dateType[arraysize];

• 获取数组长度

  array.length

内存分析

Java内存

• 堆

  存放new的对象和数组

  可以被所有的线程共享，不会存放别的对象引用

• 栈

  存放基本变量类型（会包含这个基本类型的具体数值）

  引用对象的变量（会存放这个引用在堆里面的具体地址）

• 方法区

  可以被所有的线程共享

  包含了所有的class和static变量

数组边界

下标合法区间：[1,length-1]

常见错误：数组下标越界--java.lang.ArrayIndexOutOfBoundsException

初始化

• 静态初始化

  int[] a = {1,2,3,4,5,6};
  

• 动态初始化

  int[] b = new int[10];
  

• 默认初始化

四个基本特点

• 长度是确定的
• 元素必须是相同类型
• 元素可以是任何数据类型，包含基本类型和引用类型
• 数组本身就是对象，本身是在堆中，元素相当于对象的成员变量

使用

• for-each循环
• 数组作方法入参
• 数组作返回值

多维数组

数组嵌套数组--数组套娃

package com.th1024.array;

public class Demo05 {

    public static void main(String[] args) {

        //多维数组
        int[][] array = {{1,2},{3,4},{5,6}};

        printArray(array[0]);

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

        System.out.println(array[0][0]);
        System.out.println(array[0][1]);
        System.out.println(array[1][0]);
        System.out.println(array[1][1]);
        System.out.println(array[2][0]);
        System.out.println(array[2][1]);

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

        System.out.println(array.length);
        System.out.println(array[0].length);

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

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

        }

    }

    //打印数组元素
    public static void printArray(int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
        System.out.println();
    }
}

Arrays类

• 数组工具类java.util.Arrays
• 类中的方法都是static修饰的静态方法，可直接使用类名调用，而“不用”使用对象调用（注意是“不用”，而不是“不能”。）
• 常用功能
  • 给数组赋值：fill方法
  • 对数组排序：sort方法，升序
  • 比较数组：equals方法比较元素是否相等
  • 查找数组元素：通过binarySearch方法对排序好的数组进行二分法查找

冒泡排序

package com.th1024.array;

import java.util.Arrays;

public class Demo07 {
    
    /*
    冒泡排序
    1.比较数组中两个相邻的元素，如果第一个数比第二个数大，则交换它们的位置
    2.每一次比较，都会产生一个最大，或者最小的数字
    3.下一轮可以减少一次排序
    4.依次循环
     */
    public static void main(String[] args) {
        int[] a = {11,6,4,8,9,5,232,43,7,3,8,9};

        int[] mysort = mysort(a);

        System.out.println(Arrays.toString(mysort));
        
    }
    
    public static int[] mysort (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+1]<array[j]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }                       
        }
        return array;
    }
}

优化问题

当某一次遍历，没有发生数字交换，即认为排序已经完成，终止循环

package com.th1024.array;

import java.util.Arrays;

public class Demo07 {
    
    /*
    冒泡排序
    1.比较数组中两个相邻的元素，如果第一个数比第二个数大，则交换它们的位置
    2.每一次比较，都会产生一个最大，或者最小的数字
    3.下一轮可以减少一次排序
    4.依次循环
     */
    public static void main(String[] args) {
        int[] a = {11,6,4,8,9,5,232,43,7,3,8,9};

        int[] mysort = mysort(a);

        System.out.println(Arrays.toString(mysort));
        
    }
    
    public static int[] mysort (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-i; j++) {
                //发生交换，flag结果为true
                if(array[j+1]<array[j]){
                    temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                    flag = true;
                }
            }
            //当某一次遍历没有发生交换，即认为已排序完成，终止循环
            if(!flag){
                break;
            }
        }
        return array;
    }
}

稀疏数组

• 当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组
• 处理方式
  • 记录数组一共有几行几列，有多少个不同值
  • 把具有不同值的元素和行列及值记录在一个小规模数组中，从而缩小程序的规模
  • 根据记录的信息将有效的值还原到有效的地点