Java教程

Java内存分析及数组

本文主要是介绍Java内存分析及数组,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

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内存分析及数组的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!