Java内存分析及数组

堆

存放new的对象和数组（new本质在调用构造方法，初始化对象的值）

• 构造器扩展：定义有参构造之后，若想使用无参构造，需显示的定义一个无参构造

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

栈

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

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

方法区

可以被所有的线程共享

包含了所有的class和static变量

数组的基本特点

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

• 数组是相同类型的有序集合，不允许出现混合类型

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

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

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

数组的三种初始化

//静态初始化：创建+赋值（一经创建不可改变）
int [] a = {1,2,3,4,5};
System.out.println(a[0]);       //1
Man [] men = {new Man(1,1),new Man(2,2)};       //实例化类
?
//动态初始化（包含默认初始化，初始化值由数组数据类型决定）
int [] a = new int[3];
a[0]=1;
a[1]=2;
System.out.println(a[2]);   //0
?
//数组的默认初始化
//数组是引用类型，其元素相当于类的实例变量
//数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化

数组越界

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

public static void main(String[] args){
    int [] a = new a[3];
    System.out.println(a[2]);
}
?
//ArrayIndexOutOfBoundsException：数组下标越界异常

数组打印和反转(小练习，java包中有方法)

public class array {
    public static void main(String[] args) {
?
        int [] arr = {1,2,3,4,5};
        printArray(arr);        
        System.out.println();
        int [] arr1 = reverse(arr);       //反转
        printArray(arr1);
    }
?
    //打印数组          包中打印数组方法：toString
    private static void printArray(int[] arr1) {
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i]+" ");
        }
    }
?
    //数组元素反转        包中反转方法：reverse
    public static int[] reverse(int[] arr){
        int [] arr1 = new int[arr.length];
        for (int i = 0,j=arr.length-1; i < arr.length; i++,j--) {
            arr1[j] = arr[i];
        }
        return arr1;
    }
}

稀疏数组

• 当一个数组中大部分元素为0，或者为同一值的数组是，可以使用稀疏数组来保存该数组

• 稀疏数组的处理方式：

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

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

public class array2 {
    public static void main(String[] args) {
?
        //建立一个11*11的棋盘          0：无子    1：黑子    2：白子
        int [][] arr = new int[11][11];
        arr[1][2] = 1;
        arr[2][3] = 2;
?
        //输出原始数组
        System.out.println("输出原数组：");
        for (int[] i : arr) {
            for (int j : i) {
                System.out.print(j+"\t");
            }
            System.out.println();
        }
        /*
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[0].length; j++) {
                System.out.print(arr[i][j]+"   ");
            }
            System.out.println();
        }
        */
?
?
        //转为稀疏数组
        //获取有效值个数
        int n = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if(arr[i][j]!=0){
                    n += 1;
                }
            }
        }
        System.out.println("有效值个数："+n);
        //创建一个稀疏数组的数组
        int arr2[][] = new int[n+1][3];
        arr2[0][0] = 11;
        arr2[0][1] = 11;
        arr2[0][2] = n;
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                if(arr[i][j]!=0){
                    count++;
                    arr2[count][0] = i;
                    arr2[count][1] = j;
                    arr2[count][2] = arr[i][j];
                }
            }
        }
        //输出稀疏数组
        System.out.println("输出稀疏数组：");
        for (int i = 0; i < arr2.length; i++) {
                System.out.println(arr2[i][0]+"\t"
                        +arr2[i][1]+"\t"+
                        +arr2[i][2]+"\t");
        }
?
?
        //还原数组
        int [][] arr3 = new int[arr2[0][0]][arr2[0][1]];
        for (int i = 1; i < arr2.length; i++) {
            arr3[arr2[i][0]][arr2[i][1]] =arr2[i][2];
        }
        //输出还原数组
        System.out.println("输出还原数组：");
        for (int[] i : arr3) {
            for (int j : i) {
                System.out.print(j+"\t");
            }
            System.out.println();
        }
    }
}
?

Java内存分析及数组

原文：https://www.cnblogs.com/ryan51/p/14897768.html