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();
}
}
}