精华内容
下载资源
问答
  • Java 语言是典型的静态语言,因此 Java 数组是静态的,即当数组被初始化之后,该数组 所占的内存空间、数组长度都是不可变的。Java 程序中的数组必须经过初始化才可使用。所谓初始化,即创建实际的数组对象,也就是...

    原文:https://m.2cto.com/kf/201611/561021.html

    数组是静态的

    Java 语言是典型的静态语言,因此 Java 数组是静态的,即当数组被初始化之后,该数组 所占的内存空间、数组长度都是不可变的。Java 程序中的数组必须经过初始化才可使用。所谓初始化,即创建实际的数组对象,也就是在内存中为数组对象分配内存空间,并为每个数组 元素指定初始值。

    数组的初始化有以下两种方式。

    • 静态初始化:初始化时由程序员显式指定每个数组元素的初始值,由系统决定数组长度。
    • 动态初始化:初始化时程序员只指定数组长度,由系统为数组元素分配初始值。

    不管采用哪种方式初始化Java 数组,一旦初始化完成,该数组的长度就不可改变,Java 语言允许通过数组的length 属性来访问数组的长度。示例如下。

    public class ArrayTest
    {
    public static void main(String[] args)
    {
    // 采用静态初始化方式初始化第一个数组
    String[] books = new String[]
    { "1", "2", "3", "4"
    };
    // 采用静态初始化的简化形式初始化第二个数组
    String[] names =
    {
    "孙悟空",
    "猪八戒",
    "白骨精"
    };
    // 采用动态初始化的语法初始化第三个数组
    String[] strArr = new String[5];
    // 访问三个数组的长度
    System.out.println("第一个数组的长度:" + books.length);
    System.out.println("第二个数组的长度:" + names.length);
    System.out.println("第三个数组的长度:" + strArr.length);
    }
    }

     

    上面程序中的粗体字代码声明并初始化了三个数组。这三个数组的长度将会始终不变,程 序输出三个数组的长度依次为4 、3 、5 。

    前面已经指出,Java 语言的数组变量是引用类型的变量,books、names 、strArr 这三个变量,以及各自引用的数组在内存中的分配示意图如图1.1 所示。

    \

    从图1.1可以看出,对于静态初始化方式而言,程序员无须指定数组长度,指定该数组的 数组元素,由系统来决定该数组的长度即可。例如 books 数组,为它指定了四个数组元素,它 的长度就是4 ;对于names 数组,为它指定了三个元素,它的长度就是3 。

    执行动态初始化时,程序员只需指定数组的长度,即为每个数组元素指定所需的内存空间, 系统将负责为这些数组元素分配初始值。指定初始值时,系统将按如下规则分配初始值。

    • 数组元素的类型是基本类型中的整数类型(byte 、short、int 和long ),则数组元素的值是0 。
    • 数组元素的类型是基本类型中的浮点类型(float 、double ),则数组元素的值是0.0。
    • 数组元素的类型是基本类型中的字符类型(char ),则数组元素的值是'\u0000'。
    • 数组元素的类型是基本类型中的布尔类型(boolean),则数组元素的值是false 。
    • 数组元素的类型是引用类型(类、接口和数组),则数组元素的值是null 。

      Java 数组是静态的,一旦数组初始化完成,数组元素的内存空间分配即结束,程序只能改变数组元素的值,而无法改变数组的长度。

    需要指出的是,Java 的数组变量是一种引用类型的变量,数组变量并不是数组本身,它 只是指向堆内存中的数组对象。因此,可以改变一个数组变量所引用的数组,这样可以造成数 组长度可变的假象。假设,在上面程序的后面增加如下几行。

    // 让books 数组变量、strArr 数组变量指向names 所引用的数组
    books = names;
    strArr = names;
    System.out.println("--------------");
    System.out.println("books 数组的长度:" + books.length);
    System.out.println("strArr 数组的长度:" + strArr.length);
    // 改变books 数组变量所引用的数组的第二个元素值
    books[1] = "唐僧";
    System.out.println("names 数组的第二个元素是:" + books[1]);

     

    上面程序中粗体字代码将让books 数组变量、strArr 数组变量都指向names 数组变量所引 用的数组,这样做的结果就是books、strArr、names 这三个变量引用同一个数组对象。此时, 三个引用变量和数组对象在内存中的分配示意图如图1.2 所示。

    \

    从图1.2可以看出,此时 strArr、names 和books 数组变量实际上引用了同一个数组对象。 因此,当访问 books 数组、strArr 数组的长度时,将看到输出 3。这很容易造成一个假象:books 数组的长度从4 变成了3。实际上,数组对象本身的长度并没有发生改变,只是 books 数组变 量发生了改变。books 数组变量原本指向图 1.2下面的数组,当执行了books = names;语句之后,books 数组将改为指向图1.2 中间的数组,而原来books 变量所引用的数组的长度依然是4 。

    从图1.2 还可以看出,原来 books 变量所引用的数组的长度依然是 4 ,但不再有任何引用 变量引用该数组,因此它将会变成垃圾,等着垃圾回收机制来回收。此时,程序使用books、 names 和strArr 这三个变量时,将会访问同一个数组对象,因此把 books 数组的第二个元素赋 值为“唐僧”时,names 数组的第二个元素的值也会随之改变。

    与Java 这种静态语言不同的是,JavaScript 这种动态语言的数组长度是可以动态改变的,示例如下。

    <script type="text/javascript">
    var arr = [];
    document.writeln("arr的长度是:" + arr.length + "
    ");
    // 为arr 数组的两个数组元素赋值
    arr[2] = 6;
    arr[4] = "孙悟空";
    // 再次访问arr 数组的长度
    document.writeln("arr的长度是:" + arr.length + "
    ");
    </script>

     

    上面是一个简单的JavaScript 程序。它先定义了一个名为 arr的空数组,因为它不包含任 何数组元素,所以它的长度是0 。接着,为 arr数组的第三个、第五个元素赋值,该数组的长 度也自动变为5 。这就是JavaScript 里动态数组和Java 里静态数组的区别。

    基本类型数组的初始化

    对于基本类型数组而言,数组元素的值直接存储在对应的数组元素中,因此基本类型 数组的初始化比较简单:程序直接先为数组分配内存空间,再将数组元素的值存入对应内 存里。

    下面程序采用静态初始化方式初始化了一个基本类型的数组对象。

    public class PrimitiveArrayTest
    {
    public static void main(String[] args)
    {
    // 定义一个int[] 类型的数组变量
    int[] iArr;
    // 静态初始化数组,数组长度为4
    iArr = new int[]{2 , 5 , -12 , 20};
    }
    }

     

    上面代码的执行过程代表了基本类型数组初始化的典型过程。下面将结合示意图详细介绍这段代码的执行过程。

    执行第一行代码int[] iArr;时,仅定义一个数组变量,此时内存中的存储示意图如图1.4所示。

    \

    执行了int[] iArr; 代码后,仅在 main 方法栈中定义了一个 iArr 数组变量,它是一个引用类 型的变量,并未指向任何有效的内存,没有真正指向实际的数组对象。此时还不能使用该数组 对象。

    当执行iArr = new int[]{2,5,-12,20}; 静态初始化后,系统会根据程序员指定的数组元素来决 定数组的长度。此时指定了四个数组元素,系统将创建一个长度为4 的数组对象,一旦该数组 对象创建成功,该数组的长度将不可改变,程序只能改变数组元素的值。此时内存中的存储示 意图如图1.5 所示。

    静态初始化完成后,iArr 数组变量引用的数组所占用的内存空间被固定下来,程序员只能 改变各数组元素内的值。既不能移动该数组所占用的内存空间,也不能扩大该数组对象所占用 的内存,或缩减该数组对象所占用的内存。

    \

    对于程序运行过程中的变量,可以将它们形容为具体的瓶子——瓶子可以存储 水,而变量用于存储值,也就是数据。对于强类型语言如Java ,它有一个要求: 怎样的瓶子只能装怎样的水,也就是说,指定类型的变量只能存储指定类型的值。

    所有局部变量都是放在栈内存里保存的,不管其是基本类型的变量,还 是引用类型的变量,都是存储在各自的方法栈内存中的;但引用类型的变量所引用的对象(包 括数组、普通的Java 对象)则总是存储在堆内存中。

    对于Java 语言而言,堆内存中的对象(不管是数组对象,还是普通的 Java 对象)通常不允许直接访问,为了访问堆内存中的对象,通常只能通过引用变量。这也是很容易混淆的地方。 例如,iArr 本质上只是main 栈区的引用变量,但使用 iArr.length 、iArr[2] 时,系统将会自动变 为访问堆内存中的数组对象。

    对于很多Java 程序员而言,他们最容易混淆的是:引用类型的变量何时只是栈内存中的 变量本身,何时又变为引用实际的Java 对象。其实规则很简单:引用变量本质上只是一个指 针,只要程序通过引用变量访问属性,或者通过引用变量来调用方法,该引用变量就会由它所 引用的对象代替。

    public class PrimitiveArrayTest2
    {
    public static void main(String[] args)
    {
    // 定义一个int[] 类型的数组变量
    int[] iArr = null;
    // 只要不访问iArr 的属性和方法,程序完全可以使用该数组变量
    System.out.println(iArr); //①
    // 动态初始化数组,数组长度为5
    iArr = new int[5];
    // 只有当iArr 指向有效的数组对象后,下面才可访问iArr 的属性
    System.out.println(iArr.length); //②
    }
    }

     

    上面程序中两行粗体字代码两次访问iArr 变量。对于①行代码而言,虽然此时的iArr 数 组变量并未引用到有效的数组对象,但程序在①行代码处并不会出现任何问题,因为此时并未 通过iArr 访问属性或调用方法,因此程序只是访问iArr 引用变量本身,并不会去访问iArr 所 引用的数组对象。对于②行代码而言,此时程序通过iArr 访问了length 属性,程序将自动变 为访问iArr 所引用的数组对象,这就要求iArr 必须引用一个有效的对象。

    有过一些编程经验,应该经常看到一个Runtime 异常: NullPointerException (空指针异常)。当通过引用变量来访问实例属性,或者调 用非静态方法时,如果该引用变量还未引用一个有效的对象,程序就会引发 NullPointerException 运行时异常。

    引用类型数组的初始化

    引用类型数组的数组元素依然是引用类型的,因此数组元素里存储的还是引用,它指向另一块内存,这块内存里存储了该引用变量所引用的对象(包括数组和Java 对象)。

    为了说明引用类型数组的运行过程,下面程序先定义一个Person 类,然后定义一个 Person[]数组,并动态初始化该Person[]数组,再显式地为数组的不同数组元素指定值。该程序代码如下。

    class Person
    {
    // 年龄
    public int age;
    // 身高
    public double height;
    // 定义一个info 方法
    public void info()
    {
    System.out.println("我的年龄是:" + age
    + ",我的身高是:" + height);
    }
    }
    public class ReferenceArrayTest
    {
    public static void main(String[] args)
    {
    // 定义一个students 数组变量,其类型是Person[]
    Person[] students;
    // 执行动态初始化
    students = new Person[2];
    System.out.println("students所引用的数组的长度是:"
    + students.length); //①
    // 创建一个Person 实例,并将这个Person 实例赋给zhang 变量
    Person zhang = new Person();
    // 为zhang 所引用的Person 对象的属性赋值
    zhang.age = 15;
    zhang.height = 158;
    // 创建一个Person 实例,并将这个Person 实例赋给lee 变量
    Person lee = new Person();
    // 为lee 所引用的Person 对象的属性赋值
    lee.age = 16;
    lee.height = 161;
    // 将zhang 变量的值赋给第一个数组元素
    students[0] = zhang;
    // 将lee 变量的值赋给第二个数组元素
    students[1] = lee;
    // 下面两行代码的结果完全一样,
    // 因为lee 和students[1]指向的是同一个Person 实例
    lee.info();
    students[1].info();
    }
    }

     

    上面代码的执行过程代表了引用类型数组的初始化的典型过程。下面将结合示意图详细介绍这段代码的执行过程。

    执行Person[] students;代码时,这行代码仅仅在栈内存中定义了一个引用变量,也就是一个指针,这个指针并未指向任何有效的内存区。此时内存中的存储示意图如图1.6 所示。

    \

    在图1.6中的栈内存中定义了一个 students 变量,它仅仅是一个空引用,并未指向任何有 效的内存,直到执行初始化,本程序对 students 数组执行动态初始化。动态初始化由系统为数 组元素分配默认的初始值null ,即每个数组元素的值都是 null 。执行动态初始化后的存储示意 图如图1.7 所示。

    从图1.7 中可以看出,students 数组的两个数组元素都是引用,而且这两个引用并未指 向任何有效的内存,因此,每个数组元素的值都是 null 。此时,程序可以通过students 来 访问它所引用的数组的属性,因此在①行代码处通过 students 访问了该数组的长度,此时 将输出2 。

    students 数组是引用类型的数组,因此 students[0] 、students[1] 两个数组元素相当于两个引 用类型的变量。如果程序只是直接输出这两个引用类型的变量,那么程序完全正常。但程序依 然不能通过students[0] 、students[1] 来调用属性或方法,因此它们还未指向任何有效的内存区, 所以这两个连续的Person 变量(students 数组的数组元素)还不能被使用。

    \

    接着,程序定义了zhang 和lee 两个引用变量,并让它们指向堆内存中的两个Person 对象,此时的zhang、lee 两个引用变量存储在 main 方法栈区中,而两个 Person 对象则存储在堆内存中。此时的内存存储示意图如图1.8 所示。

    \

    对于zhang、lee 两个引用变量来说,它们可以指向任何有效的Person 对象,而students[0] 、 students[1] 也可以指向任何有效的Person 对象。从本质上来看,zhang、lee、students[0] 、students[1] 能够存储的内容完全相同。接着,程序执行students[0] = zhang;和students[1] = lee; 两行代码, 也就是让zhang 和students[0] 指向同一个 Person 对象,让 lee 和students[1] 指向同一个Person 对象。此时的内存存储示意图如图1.9 所示。

    \

    从图1.9 中可以看出,此时 zhang 和students[0] 指向同一个内存区,而且它们都是引用类 型的变量,因此通过 zhang 和students[0] 来访问Person 实例的属性和方法的效果完全一样。不 论修改students[0] 所指向的 Person 实例的属性,还是修改 zhang 变量所指向的 Person 实例的 属性,所修改的其实是同一个内存区,所以必然互相影响。同理,lee 和students[1] 也是引用 到同一个Person 对象,也有相同的效果。

    前面已经提到,对于引用类型的数组而言,它的数组元素其实就是一个引用类型的变量, 因此可以指向任何有效的内存——此处“有效”的意思是指强类型的约束。比如,对 Person[] 类型的数组而言,它的每个数组元素都相当于Person 类型的变量,因此它的数组元素只能指 向Person 对象。

     
     
     
    展开全文
  • java数组输出

    万次阅读 2013-12-24 19:30:56
    java数组输出 输出一个数组中的元素,我们通常用for循环来做,比如: package test; public class Test { public static void main(String args[]){ int arr[]={1,2,3}; System.out.print("["); for(int ...

    java数组输出

    输出一个数组中的元素,我们通常用for循环来做,比如:

    package test;
    
    public class Test {
    
    	public static void main(String args[]){
    		int arr[]={1,2,3};
    		System.out.print("[");
    		for(int i=0; i<arr.length-1; i++)
    			System.out.print(arr[i]+", ");
    		System.out.println(arr[arr.length-1]+"]");
    		
    
    	}
    }
    输出的结果为:[1, 2, 3]。


    但是Java提供了更为简单的方法,这就是toString方法。具体做法如下:

    package test;
    
    import java.util.Arrays;
    
    public class Test {
    
    	public static void main(String args[]){
    		int arr[]={1,2,3};
    
    		System.out.println(Arrays.toString(arr));
    	}
    }
    
    输出的结果为:[1, 2, 3]。


    但是如果数组中的元素不是同一类型怎么办呢?比如:

    package test;
    
    import java.util.Arrays;
    
    public class Test {
    
    	public static void main(String args[]){
    		int[] arr={1,2,3};
    		String[] str={"aaa","bbb"}; 
    		Object[] array = {arr,str};
    		System.out.println(Arrays.toString(array));
    	}
    }
    
    输出的结果为:[[I@158f9d3, [Ljava.lang.String;@79a2e7]。


    可以看到打印出来的不是数组元素,而是对象的内存代号。如果要打印出数组元素怎么办呢?这里我们可以用到deepToString。比如:

    package test;
    
    import java.util.Arrays;
    
    public class Test {
    
    	public static void main(String args[]){
    		int[] arr={1,2,3};
    		String[] str={"aaa","bbb"}; 
    		Object[] array = {arr,str};
    		System.out.println(Arrays.deepToString(array));
    	}
    }
    
    输出的结果:[[1, 2, 3], [aaa, bbb]]。



    展开全文
  • 问题:二维数组输出地址而非值 解决:

    问题:二维数组输出是地址而非值
    解决:
    在这里插入图片描述在这里插入图片描述

    展开全文
  • Java 是静态语言,因此 Java 数组是静态的,即当数组初始化之后,该数组所占的内存空间、数组长度都是不变的。1、Java数组初始化的两种方式: 静态初始化:初始化时由程序显示指定每个数组元素的初始值; 动态...

    内容参考《疯狂Java程序员的基本修养》李刚 著

    一、数组初始化

    Java 中的数组变量是引用类型的变量。

    Java 是静态语言,因此 Java 数组是静态的,即当数组初始化之后,该数组所占的内存空间、数组长度都是不变的。

    1、Java 中数组初始化的两种方式:
    - 静态初始化:初始化时由程序显示指定每个数组元素的初始值;
    - 动态初始化:初始化时只指定数组长度,由系统分配初始值。

    public static void main(String[] args) {
        // 静态初始化第一个数组
        String[] books = new String[] {
                "hhh",
                "2333"
        };
    
        // 静态初始化第二个数组
        String[] names = {
                "aaa",
                "bbb",
                "ccc"
        };
    
        // 动态初始化第三个数组
        String[] aStr = new String[5];
    
        System.out.println("books 长度: " + books.length);
        System.out.println("names 长度: " + names.length);
        System.out.println("aStr 长度: " + aStr.length);
    }

    输出:
    例1

    静态初始化方式由系统决定该数组长度;
    而动态初始化方式只需指定数组的长度,由系统按如下规则分配初始值:

    • 整数类型(byte, short, int, long):初始值为 0;
    • 浮点类型(float, double):初始值为 0.0;
    • 字符类型(char):初始值为 ‘\u0000’,即 空格的 Unicode 编码;
    • 布尔类型(boolean):初始值为 false;
    • 引用类型(类,接口和数组):初始值为 null 。

    2、Java 数组长度不可变(即 Java 数组是静态的):

    Java 中一旦数组初始化完成,数组的内存空间分配即结束,程序只能改变数组元素的值,而无法改变数组的长度。但由于 Java 数组是引用类型的变量,因此可以改变一个数组变量所引用的数组,可以造成数组长度可变的假象。

    public static void main(String[] args) {
       String[] books = new String[] {
                "hhh",
                "2333"
        };
    
        String[] names = {
                "aaa",
                "bbb",
                "ccc"
        };
    
        books = names;
    
        // 修改 books 数组变量所引用的数组的第二个元素
        books[1] = "wlm";
    
        System.out.println("names 数组第二个元素: " + names[1]);
    
    }

    输出为:
    例2

    操作说明:

    说明1

    3、使用 Java 数组之前必须进行初始化

    代码说明如下:

    public static void main(String[] args) {
       // 定义并初始化 nums 数组
        int[] nums = new int[] {1, 2, 3, 4};
    
        // 定义 prices 数组变量
        int[] prices;
    
        // prices 数组变量指向 nums 所引用的数组
        prices = nums;
    
        System.out.println("输出 prices 数组: ");
        for (int i = 0; i < prices.length; i ++) {
            System.out.print(prices[i] + " ");
        }
        System.out.println();
    
        // 修改 nums 数组第三个元素
        prices[2] = 111;
        System.out.println("nums 第三个元素: " + nums[2]);
    }

    输出为:
    例2

    这里的 Java 数组的初始化指的是对 Java 对象进行初始化,而不是对数组变量执行初始化。即在 堆内存 中创建数组对象,也就是为该数组对象分配一块连续的内存空间,这块连续空间的长度就是数组的长度。

    即 Java 程序中的引用变量并不需要进行初始化操作,需要进行初始化的是引用变量所引用的对象。

    注:Java 局部变量必须制定初始值,如引用之前未指定,则会报编译错误。

    说明2

    4、基本类型数组初始化

    程序先为数组分配内存空间,再将数组元素的值存入对应内存里。数组变量存于栈内存中,数组对象存于堆内存中。且一旦数组对象创建成功,数组长度不可改变。

    public static void main(String[] args) {
        // 定义 int[] 类型数组变量
        int[] arr;
    
        // 静态初始化数组, 数组长度为 4
        arr = new int[]{1, 2, 3, 4};
    }

    执行代码 int[] arr 时,仅定义一个数组变量,内存分配如下:
    说明3

    仅在main栈区定义了一个 arr 变量。

    执行 arr = new int[]{1, 2, 3, 4} 静态初始化之后,系统根据数组元素来决定数组的长度。此处数组长度为4,一旦数组对象创建成功,该数组长度不可变,程序只能改变数组元素的值。此时内存分配如下:
    说明4

    说明:

    • 所有局部变量都是放在栈内存中的,不管是基本类型的变量,还是引用类型的变量;
    • 但引用类型的变量所引用的对象则总是存储在堆内存中。

      5、引用类型数组初始化

    引用类型的数组元素是引用类型的,因此数组元素里存储的是引用,指向另一块内存,该内存存储了该引用变量所引用的对象(包括数组和java对象)。

    代码说明如下:
    Person 类:

    package com.tide.test;
    
    /**
     * Created by wengliemiao on 16/4/4.
     */
    public class Person {
        private int age; // 年龄
        private double weight; // 身高
    
        // 定义一个 info 方法
        public void info() {
            System.out.println("我的年龄是: " + age + ", 我的身高是: " + weight);
        }
    }
    

    Run 类:

    package com.tide.test;
    
    /**
     * Created by wengliemiao on 16/4/4.
     */
    public class Run {
        public static void main(String[] args) {
            // 定义一个 students 数组变量, 类型是 Person[]
            Person[] students ;
    
            // 动态初始化
            students = new Person[2];
    
            System.out.println("students 引用数组长度是: " + students.length);
    
            // 创建一个 Person 实例, 并将这个 Person 实例赋给 wlm 变量
            Person wlm = new Person();
            wlm.setAge(21);
            wlm.setWeight(70);
    
            // 创建一个 Person 实例, 并将这个 Person 实例赋给 sunlei 变量
            Person sunlei = new Person();
            sunlei.setAge(21);
            sunlei.setWeight(60);
    
            // 将 wlm 变量赋给第一个数组元素
            students[0] = wlm;
            // 将 sunlei 变量赋给第二个数组元素
            students[1] = sunlei;
    
            // 输出
            wlm.info();
            students[0].info();
        }
    }
    

    输出为:
    例3

    上面的代码代表了引用类型数组初始化的典型过程。

    内存分配过程如下:

    执行 Person[] students 时定义一个引用类型的数组变量:
    说明5

    执行动态初始化,由系统为数组元素分配默认的初始值 null:
    说明6

    定义 wlm 和 sunlei 两个引用变量,并指向堆内存中的 Person 对象:
    说明7

    students 数组的元素也是引用类型的变量,也可以指向堆内存中的对象:
    说明8

    此处students[0] 和 wlm 指向同一个 Person 对象,students[1] 和 sunlei 指向同一个 Person 对象,因此 info 输出结果一致。

    二、使用数组

    1. 数组元素就是变量;
    2. Java 中没有多维数组。

    多维数组就是数组元素为数组的一维数组;
    二维数组是数组元素为一维数组的数组;
    三维数组是数组元素为二维数组的数组;
    ……

    Java 允许将多维数组当成一维数组处理。

    package com.tide.test;
    
    /**
     * Created by wengliemiao on 16/4/4.
     */
    public class Run {
        public static void main(String[] args) {
            Object[] objArr = new Object[3];
    
            objArr[1] = new Object[2];
    
            Object[] objArr2 = (Object[]) objArr[1];
    
            objArr2[1] = new Object[3];
    
            Object[] objArr3 = (Object[]) objArr2[1];
    
            objArr3[1] = new int[5];
    
            int[] iArr = (int[]) objArr3[1];
    
            for (int i = 0; i < iArr.length; i ++) {
                iArr[i] = i * 3 + 1;
            }
    
            System.out.println( ((int[]) ((Object[]) ((Object[]) objArr[1]) [1]) [1]) [2]);
        }
    }
    

    输出为:
    例4

    内存分配为:
    说明9

    展开全文
  • 1.原因是object.java类是所有类的基类,称为父类/超类,java中所有的类都会继承该类,而该类的toString方法打印的就是内存地址. 2.list中打印的确是数组类型的字符串,原因是list类继承自下图中的AbstractList类, 该...
  • [精]JAVA数组内存结构详解

    万次阅读 2016-10-31 14:07:32
    Java 数组是静态的Java 语言是典型的静态语言,因此 Java 数组是静态的,即当数组被初始化之后,该数组 所占的内存空间、数组长度都是不可变的。Java 程序中的数组必须经过初始化才可使用。所 谓初始化,即创建实际...
  • java 数组的创建以及数组内存地址

    千次阅读 2018-04-21 11:26:13
    数组:是一种容器,如果数据过多,定义变量就很多 代码重复多,写很麻烦,数据多了存数组 定义数组容器: 定义数组容器,要素,强制数据类型的语言 必须有数据类型,大小,就是存储数据的个数 定义数组公式: ...
  • java数组输出

    2019-10-29 12:05:42
    今天写着程序突然想到了数组输出的问题,我自己都迷糊了,脑子里只有System.out.println(数组名);这种输出,数组的输出很...//只有char型可以用,否则会输出内存地址; 带格式输出:System.out.println(Arrays.toS...
  • 在千峰 "逆战"学习第9天 ...数组时采用内存中的栈区存储,栈区存储的时堆区中的首地址,堆区中存储的是地址对应的数据。输出数组名就是·输出的首地址数组名+数组下标 输出的就是通过相应地址找到的具体数据。 ...
  • 数组作为java中非常常用的一种数据结构,其重要性可想而知。 这篇博客不仅简单详细介绍Java数组的使用,而且图解数组的内存解析。
  • 一.数组的概念 1.数组无论在哪种编程语言中都算是最重要的数据结构之一,同时不同语言的实现及处理也不尽相同。...最值得注意的是C中的数组Java中的数组的边界检查,c编译器不检查如果程序访问无效的数组索引,而jav
  • 1.基本数据类型 ...在堆内存中开辟一块内存空间,把空间的地址返回给当前对象,所以打印出地址值。 可查看当前println方法底层源码 以object类型传入,调用的是object的tostring ②同理,数组也是...
  • Java数组逆序输出

    2020-11-20 12:53:34
    public class Tets { public static void main(String[] args) { int[] lcz={1,2,3,4,5,6,7}; for (int i = lcz.length - 1;...对应内存图: 逆序输出: 因为逆序输出要从索引最后一位输出直到索引第一位为止 所
  • Java数组内存图解练习

    2021-01-05 08:28:19
    数组内存图解练习 练习1: 静态初始化一个数组输出数组名及元素。然后给数组中的元素赋值,再次输出数组名及元素。 练习2: 分别静态、动态初始化两个数组,分别输出数组名及元素 然后分别给数组中的元素...
  • java数组定义、使用、以及数组内存分析详解

    千次阅读 多人点赞 2019-10-04 22:17:30
    旨在全面性了解java数组。 文章目录1、什么是容器2、什么是数组3、数组的三种定义定义方式一定义方式二定义方式三数组定义格式详解:4、数组的访问5、什么是内存5.1 Java虚拟机的内存划分5.2 数组在内存中的存储...
  • Java数组及其内存分配

    千次阅读 2013-03-27 18:10:18
    几乎所有的程序设计语言都支持数组。Java也不例外。当我们需要多个类型相同的变量的...对与Java数组的初始化,有以下两种方式,这也是面试中经常考到的经常题目: 静态初始化:初始化时由程序员显式指定每个数组元素
  • java数组初始化及内存分析

    千次阅读 2015-09-29 09:40:30
    数组:相同类型的、用一个标识符名封装到一起是一个对象序列或基本类型数据序列。 一维数组的声明:1 int[ ] a1; 2 int a1[ ] 两种格式含义一样,第二种符合c和c++程序员的习惯。第一种或许更合理,表明类型是“一个...
  • 1. 数组Java中的数组与C语言的数组不一样,所以这方面要认真对待。 2. 数组(Array):相同类型数据的集合就叫做数组。 【注意】:数组里面存放的一定的相同数据类型的,它是相同类型数据的集合。 3...
  • java数组

    千次阅读 2019-07-18 20:59:36
    java数组 数组是什么呢? 数组是一种最简单的复合数据类型,它是有序数据的集合,数组中的每个元素具有相同的数据类型,可以用一个统一的数组名和不同的下标来唯一确定数组中的元素。根据数组的维度,可以将其分为一...
  • Java中二维数组内存地址详解及数组元素动态初始化 int[][] arr = new int[3][3]; /* *[[I@10f87f48 * *@:分隔符 * 10f87f48:十六进制内存地址 *I:int 数组中存储的数据类型 * [[: 几个中括号就代表几维...
  • Java数组

    千次阅读 2016-07-21 18:49:56
    java数组 java二位数组
  • Java中,声明数组的语法有两种: 1.数据类型 数组名[]; 2.数据类型[] 数组名; 例如: int a[]; 与 int[] a;都是表示声明了一个整型数组a 二维数组的声明也类似。 来看看二维数组存分配方式: 例如:int...
  • 补充笔记,关于数组内存图,三种情况 1、一个数组内存图 2、两个数组内存图 3、两个引用指向同一个数组...数组名代表该数组的首地址,A,B显然不一样 ———————————————————— 3、两个引用指...
  • 首先,讲一下内存中的概念: 栈 用于存储局部变量的引用,注意是存储的引用地址 堆 用于存储new出来的对象 方法区 用于存储代码,也算是代码区,一般用于加载class文件 好,现在开始直接上案例代码 package ...
  • 关于数组,我们首先要知道的是,他是引用数据类型,数组是存储同一种数据类型多个元素的容器。...内存,简单说就是存放正在运行的程序,我们知道,java程序运行的载体是JVM,运行环境是JRE,内存分配给JVM空间执...
  • java数组创建及输出

    2020-02-17 20:19:30
    数组: 是一种最简单的符合数据类型,它是有序数据的集合,数组中的每个元素具有相同的数据类型,可以用一个统一的数组名和不同的下标来,唯一确定数组中的元素。 特征: 数组可以是一维数组,二维数组或多维数组 ...
  • Java数组内存分配 1、Java 程序在运行时,需要在内存中分配空间。为了提高运算效率,就对空间进行了不同区域的划分,因为每一片区域都有特定的处理数据和内存管理方式。 2、数组基本概念 数组是存储同一种数据...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 196,864
精华内容 78,745
关键字:

java数组输出是内存地址

java 订阅