java学习笔记--基础篇07(数组)

JAVA数组

1、数组概述

• 数组是相同类型数据的有序集合

• 每个数组元素可以通过一个下标(索引)来访问，数组下标从0开始

2、数组声明创建

2.1声明

dateType[] array; //首选方法
或
dateType array[]; //效果相同，但不是首选

2.2创建

dateType[] Array = new dateType[arraySize];

3、java内存简单分析

 

 

 

 

int[] array = new int[10];
array[0] = 1;
array[1] = 2;
array[2] = 3;
...

 

 

 

4、数据初始化

• 静态初始化

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

• 动态初始化

int[] array = new int[10];
array[0] = 1;
array[1] = 2;
array[2] = 3;

 

• 数组默认初始化

　　数组是引用类型，它的元素相当于类的实例变量。因此数组一经分配空间，其中每个元素也被按照实例变量同样的方式被隐式初始化

5、数组的基本特点

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

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

• 数组元素可以是任何数据类型，包括基本类型和引用类型（如数组套数组）

• 数组可以看成是对象，数组中每个元素相当于该对象的成员变量，数组对象本身在堆中存储

6、数组边界

• 下标的合法区间[0,length-1],一旦越界就会报错：ArrayIndexOutOfBoundsException

7、数组的使用

• 普通for循环

• 遍历循环 for-each

• 数组可以作为方法的参数和返回值

package array;

public class ArrayDemo02 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5,6};

        //查找最大的元素 普通for循环
        int max = arrays[0];
        for (int i = 1; i < arrays.length; i++) {
            if(max < arrays[i]){
                max = arrays[i];
            }
        }
        System.out.println("max="+max);
        System.out.println("------------------------");
        //计算所有元素的和 foreach
        int sum = 0;
        for (int array : arrays) {
            sum += array;
        }
        System.out.println("sum="+sum);
        System.out.println("------------------------");

        int[] rev =  reverse(arrays);
        arrayPrint(rev);
    }

    public static void arrayPrint(int[] arrays){
        //遍历打印
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i]+" ");
        }
    }
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];
        // 反转数组
        for (int i = 0,j=result.length-1; i < arrays.length; i++,j--) {
            result[j] = arrays[i];
        }
        return result;
    }
}

8、多维数组

• 多维数组可以看成数组的数组

• 二维数组定义

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

 

9、Array 类

• java.util.Arrays 数组的工具类，可以对数组进行一些基本的操作

• 类中的方法都是static的 可以直接调用

• 常用的功能：

  • 给数组赋值，fill方法

  • 对数组进行排序(升序)，sort方法

  • 比较数组，equals方法

  • 查找元素，binarySearch方法

• 学习这个类可以通过jdk文档或者直接查看源码的方式

 

 

 

10、稀疏数组

• 当数组中大部分元素为0，或者为相同元素时，可以用稀疏数组保存该数组元素

• 稀疏数组的处理方式：

• 记录数组一共有几行几列，有多少不同的值

• 把具有不同值的元素的行列下标及值记录在一个小规模的数组中，从而减小该程序的规模

 

 

 

 

package array;

public class ArrayDemo03 {
    public static void main(String[] args) {
        //定义数组
        int[][] array01= new int[6][7];
        array01[0][3] = 22;
        array01[0][6] = 15;
        array01[1][1] = 11;
        array01[1][5] = 17;
        array01[2][3] = -6;
        array01[3][5] = 39;
        array01[4][0] = 91;
        array01[5][2] = 28;

        System.out.println("原始数组--------------");
        printarrays(array01);
        System.out.println("转化后数组-------------");
        int[][] array02 = sparceArrays(array01);
        printarrays(array02);
        System.out.println("还原后数组-------------");
        int[][] array03 = restoreArrays(array02);
        printarrays(array03);

    }

    // 打印数组
    public static void printarrays(int[][] arrays){
        for (int[] array : arrays) {
            for (int i : array) {
                System.out.print(i+"\t");
            }
            System.out.println();
        }
    }

    //转换成稀疏数组
    public static int[][] sparceArrays(int[][] arrays){
//        if (arrays.length==0){
//            System.out.println("数据错误");
//            return null;
//        }else if (arrays[0].length==0){
//            System.out.println("数据错误");
//            return null;
//        }

        //扫描原矩阵获取数据数量count
        int count = 0;
        for (int[] array : arrays) {
            for (int i : array) {
                if(i!=0){
                    count++;
                }
            }
        }

        //定义 多了一行表头
        int[][] result = new int[count+1][3];
        //表头
        result[0][0] = arrays.length;
        result[0][1] = arrays[0].length;
        result[0][2] = count;
        //转换数据
        count = 1;
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j < arrays[i].length; j++) {
                if (arrays[i][j]!=0){
                    result[count][0] = i;
                    result[count][1] = j;
                    result[count][2] = arrays[i][j];
                    count++;
                }
            }
        }
        return result;
    }

    //还原数组
    public static int[][] restoreArrays(int[][] arrays){
        //取表头数据定义数组
        int[][] result = new int[arrays[0][0]][arrays[0][1]];
        for (int i = 1; i < arrays.length; i++) {
            result[arrays[i][0]][arrays[i][1]] = arrays[i][2];
        }
        return result;
    }
}