精华内容
下载资源
问答
  • java数组输出是内存地址
    2021-03-01 08:23:02

    java数组输出

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

    [java] view plaincopy在CODE上查看代码片派生到我的代码片

    package test;

    public class Test {

    public static void main(String args[]){

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

    System.out.print("[");

    for(int i=0; i

    System.out.print(arr[i]+", ");

    System.out.println(arr[arr.length-1]+"]");

    }

    }

    输出的结果为:[1, 2, 3]。

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

    [java] view plaincopy在CODE上查看代码片派生到我的代码片

    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]。

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

    [java] view plaincopy在CODE上查看代码片派生到我的代码片

    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。比如:

    [java] view plaincopy在CODE上查看代码片派生到我的代码片

    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

    一.数组概述

    1.数组是同一种类型数据的集合,这些数据使用同一个名字命名,并且通过用下标对这些数据进行使用。
    2.数组是一个引用数据类型,他的元素可以是任何数据类型包括基本数据类型,引用数据类型。
    3.数组长度确定的话是不可以修改的。
    4.数组里的数据是有序的排列,创建一个数组时会在内存中开辟连续的空间,数组名是数组的首地址,就是指向数组中第一个元素的地址。

    二.一维数组的使用:

    数组初始化:

    数组的初始化就是开辟一片空间,然后数据放到空间。
    分为静态初始化和动态初始化,两者选其一,给长度就不给{},给{}就不给长度。
    由于数组是引用数据类型,所以当他被没有赋值时,默认的初始化值为null
    静态初始化:int[] array=new int[]{给指定的数值};

     int[] array = new int[]{1, 3, 4, 5};
     //静态数组需要给定数值,系统会自动判断数组长度
    

    动态初始化:int[] array1=new int[给定长度];

    int[] array1 = new int[4];/
    /动态数组只需要给定长度,系统会自动分配初始值。
    

    如何访问数组元素:

    数组名[数组下标]
    注意我们数组是从0开始索引
    在这里插入图片描述

    数组的遍历:

    数组遍历:是获取数组元素的方法。

    for(int i=0;i<array.length;i++){
    array[i]
    }
    

    三.数组的内存解析:

    我们的程序都是运行在内存当中,而我们的Java程序则是编译之后运行在JVM虚拟机中。
    在这里插入图片描述
    JVM的内存划分不同的区域,不同的区域有不同作用。
    主要分为
    :main方法在栈中运行,主要存放局部变量。
    :存放new出来的数组,对象等。
    方法区:存放编译之后的class文件
    在这里插入图片描述
    我们看下面这段代码:

    public class Arraytest {
        public static void main(String[] args) {
            //数组初始化:静态动态两者选其一,给长度不加{},不给长度加{}
            int[] array1 = new int[4];
            //动态数组只需要给定长度,系统会自动分配初始值。
            array1[2]=3;
            System.out.println(array1[2]);
    

    1.执行main方法把main方法压入栈中,执行main方法。
    2.执行main方法中第一句代码,把new出来的数组存储到堆空间中,在堆空间中开辟一片连续的地址,每个元素默认为初始值,数组名为首地址。
    3. 数组名就是首地址,可以直接找到数组在堆空间中的第一个元素,然后通过索引,找到索引为2的元素位置,把2赋值给索引为2的元素位置。
    4. 通过栈空间中的数组名找到array1数组,然后找到索引为2的元素位置,将这个位置的元素输出。

    如有错误,请评论留言,万分感谢。

    展开全文
  • 主要介绍了java数组输出的实例代码,有需要的朋友可以参考一下
  • Java 中的每一个数组存储的数据类型是一致的。 Java数组的确是放在一块连续内存里的,否则...Java 语言是典型的静态语言,因此 Java 数组是静态的,即当数组被初始化之后,该数组 所占的内存空间、数组长度都是不可

    Java 中的每一个数组存储的数据类型是一致的。

    Java 的数组的确是放在一块连续内存里的,否则不可能做到在 O(1) 时间复杂度内存取元素

    基本类型的数据都非常小,可以直接放在数组里,这跟 C 里面的数组是一样的;

    但引用类型的对象就不一样了,存在数组里的都只是引用,不是真正的对象数据。我们通过数组拿到的还是引用,真正的对象分散地存在堆里,并不是连续的。

    数组是静态的

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

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

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

    不管采用哪种方式初始化Java 数组,一旦初始化完成,该数组的长度就不可改变,

    Java 语言允许通过数组的length 属性来访问数组的长度。示例如下。

    1. public class ArrayTest
    2. {
    3. public static void main(String[] args)
    4. {
    5. // 采用静态初始化方式初始化第一个数组
    6. String[] books = new String[]
    7. { "1", "2", "3", "4"
    8. };
    9. // 采用静态初始化的简化形式初始化第二个数组
    10. String[] names =
    11. {
    12. "孙悟空",
    13. "猪八戒",
    14. "白骨精"
    15. };
    16. // 采用动态初始化的语法初始化第三个数组
    17. String[] strArr = new String[5];
    18. // 访问三个数组的长度
    19. System.out.println("第一个数组的长度:" + books.length);
    20. System.out.println("第二个数组的长度:" + names.length);
    21. System.out.println("第三个数组的长度:" + strArr.length);
    22. }
    23. }

    上面程序中的粗体字代码声明并初始化了三个数组。这三个数组的长度将会始终不变,程 序输出三个数组的长度依次为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 ),则数组元素的值是&#39;\u0000&#39;。
    • 数组元素的类型是基本类型中的布尔类型(boolean),则数组元素的值是false 。
    • 数组元素的类型是引用类型(类、接口和数组),则数组元素的值是null 。

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

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

    1. // 让books 数组变量、strArr 数组变量指向names 所引用的数组
    2. books = names;
    3. strArr = names;
    4. System.out.println("--------------");
    5. System.out.println("books 数组的长度:" + books.length);
    6. System.out.println("strArr 数组的长度:" + strArr.length);
    7. // 改变books 数组变量所引用的数组的第二个元素值
    8. books[1] = "唐僧";
    9. 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 数组的第二个元素的值也会随之改变。

    基本类型数组的初始化

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

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

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

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

    执行第一行代码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 对象。其实规则很简单:引用变量本质上只是一个指 针,只要程序通过引用变量访问属性,或者通过引用变量来调用方法,该引用变量就会由它所 引用的对象代替。

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

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

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

    引用类型数组的初始化

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

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

     
    
    1. class Person
    2. {
    3. // 年龄
    4. public int age;
    5. // 身高
    6. public double height;
    7. // 定义一个info 方法
    8. public void info()
    9. {
    10. System.out.println("我的年龄是:" + age
    11. + ",我的身高是:" + height);
    12. }
    13. }
    14. public class ReferenceArrayTest
    15. {
    16. public static void main(String[] args)
    17. {
    18. // 定义一个students 数组变量,其类型是Person[]
    19. Person[] students;
    20. // 执行动态初始化
    21. students = new Person[2];
    22. System.out.println("students所引用的数组的长度是:"
    23. + students.length); //①
    24. // 创建一个Person 实例,并将这个Person 实例赋给zhang 变量
    25. Person zhang = new Person();
    26. // 为zhang 所引用的Person 对象的属性赋值
    27. zhang.age = 15;
    28. zhang.height = 158;
    29. // 创建一个Person 实例,并将这个Person 实例赋给lee 变量
    30. Person lee = new Person();
    31. // 为lee 所引用的Person 对象的属性赋值
    32. lee.age = 16;
    33. lee.height = 161;
    34. // 将zhang 变量的值赋给第一个数组元素
    35. students[0] = zhang;
    36. // 将lee 变量的值赋给第二个数组元素
    37. students[1] = lee;
    38. // 下面两行代码的结果完全一样,
    39. // 因为lee 和students[1]指向的是同一个Person 实例
    40. lee.info();
    41. students[1].info();
    42. }
    43. }

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

    执行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数组内存分配内存结构详解 

    展开全文
  • Java数组阶段的选择题、填空题、编程题、判断题都有,适合想自己测试下的学生以及准备出题的老师
  • Java 数组内存中的存储 数组的常见操作

    万次阅读 多人点赞 2022-04-23 17:44:47
    Java 数组内存中的存储 数组的常见操作

    Java虚拟机的内存划分

    为了提高运算效率,就对空间进行了不同区域的划分,因为每一片区域都有特定的处理数据方式和内存管理方式。

    • JVM的内存划分:
    区域名称作用
    寄存器给CPU使用,和我们开发无关。
    本地方法栈JVM在使用操作系统功能的时候使用,和我们开发无关。
    方法区存储可以运行的class文件。
    堆内存存储对象或者数组,new来创建的,都存储在堆内存。
    方法栈方法运行时使用的内存,比如main方法运行,进入方法栈中执行。

    数组在内存中的存储

    一个数组内存图

    public static void main(String[] args) {
    int[] arr = new int[3];
    System.out.println(arr);//[I@5f150435
    }
    

    以上方法执行,输出的结果是[I@5f150435,这个是什么呢?是数组在内存中的地址。new出来的内容,都是在堆
    内存中存储的,而方法中的变量arr保存的是数组的地址。
    输出arr[0],就会输出arr保存的内存地址中数组中0索引上的元素
    在这里插入图片描述

    两个数组内存图

    public static void main(String[] args) {
    int[] arr = new int[3];
    int[] arr2 = new int[2];
    System.out.println(arr);
    System.out.println(arr2);
    }
    

    在这里插入图片描述

    两个变量指向一个数组

    public static void main(String[] args) {
    // 定义数组,存储3个元素
    int[] arr = new int[3];
    //数组索引进行赋值
    arr[0] = 5;
    arr[1] = 6;
    arr[2] = 7;
    //输出3个索引上的元素值
    System.out.println(arr[0]);
    System.out.println(arr[1]);
    System.out.println(arr[2]);
    //定义数组变量arr2,将arr的地址赋值给arr2
    int[] arr2 = arr;
    arr2[1] = 9;
    System.out.println(arr[1]);
    }
    

    在这里插入图片描述

    数组的常见操作

    public static void main(String[] args) {
    int[] arr = {1,2,3};
    System.out.println(arr[3]);
    }
    

    创建数组,赋值3个元素,数组的索引就是0,1,2,没有3索引,因此我们不能访问数组中不存在的索引,程序运
    行后,将会抛出 ArrayIndexOutOfBoundsException 数组越界异常。在开发中,数组的越界异常是不能出现的,一
    旦出现了,就必须要修改我们编写的代码。
    在这里插入图片描述

    数组空指针异常

    public static void main(String[] args) {
    int[] arr = {1,2,3};
    arr = null;
    System.out.println(arr[0]);

    arr = null 这行代码,意味着变量arr将不会在保存数组的内存地址,也就不允许再操作数组了,因此运行的时候
    会抛出 NullPointerException 空指针异常。在开发中,数组的越界异常是不能出现的,一旦出现了,就必须要修
    改我们编写的代码。

    在这里插入图片描述


    空指针异常在内存图中的表现
    在这里插入图片描述

    数组遍历

    public static void main(String[] args) {
    int[] arr = { 1, 2, 3, 4, 5 };
    for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
    }
    }
    

    数组获取最大值元素

    public static void main(String[] args) {
    int[] arr = { 5, 15, 2000, 10000, 100, 4000 };
    //定义变量,保存数组中0索引的元素
    int max = arr[0];
    //遍历数组,取出每个元素
    for (int i = 0; i < arr.length; i++) {
    //遍历到的元素和变量max比较
    //如果数组元素大于max
    if (arr[i] > max) {
    //max记录住大值
    max = arr[i];
    }
    }
    System.out.println("数组最大值是: " + max);
    }
    

    数组反转

    在这里插入图片描述

    public static void main(String[] args) {
    int[] arr = { 1, 2, 3, 4, 5 };
    /*
    循环中定义变量min=0最小索引
    max=arr.length‐1最大索引
    min++,max‐‐
    */
    for (int min = 0, max = arr.length ‐ 1; min <= max; min++, max‐‐) {
    //利用第三方变量完成数组中的元素交换
    int temp = arr[min];
    arr[min] = arr[max];
    arr[max] = temp;
    }
    // 反转后,遍历数组
    for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
    }
    }
    

    数组作为方法参数

    以前的方法中我们学习了方法的参数和返回值,但是使用的都是基本数据类型。那么作为引用类型的数组能否作为
    方法的参数进行传递呢,当然是可以的。

    • 数组作为方法参数传递,传递的参数是数组内存的地址。
    public static void main(String[] args) {
    int[] arr = { 1, 3, 5, 7, 9 };
    //调用方法,传递数组
    printArray(arr);
    }
    /*
    创建方法,方法接收数组类型的参数
    进行数组的遍历
    */
    public static void printArray(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
    }
    }
    

    在这里插入图片描述


    数组作为方法返回值

    • 数组作为方法的返回值,返回的是数组的内存地址
        public static void main(String[] args) {
            //调用方法,接收数组的返回值
            //接收到的是数组的内存地址
            int[] arr = getArray();
            for (int i = 0; i < arr.length; i++) {
                System.out.println(arr[i]);
            }
        }
    
        /*
            创建方法,返回值是数组类型
            return返回数组的地址
        */
        public static int[] getArray() {
            int[] arr = {1, 3, 5, 7, 9};
            //返回数组的地址,返回到调用者
            return arr;
        }
    

    在这里插入图片描述

    总结:
    方法的参数为基本类型时,传递的是数据值. 方法的参数为引用类型时,传递的是地址值.


    展开全文
  • java 数组内存

    2022-05-08 00:32:52
    public class xingxing { public static void main(String[] args) { int[] arr=new int[3]; /* 左边: int:类型为int []:说明这是一个数组 ... new:为数组申请内存空间 []:说明这是一个数组 .
  • Java数组内存分配1、Java 程序在运行时,需要在内存中分配空间。为了提高运算效率,就对空间进行了不同区域的划分,因为每一片区域都有特定的处理数据和内存管理方式。2、数组基本概念数组是存储同一种数据类型...
  • 数组Java里自带的引用数据类型,是一个同一种数据类型的集合,数组的构成有四大要素:数组的数据类型,数组的长度,数组数组名,数组的下标:语法如int[] a;a = new int[10];String[] s = {"aaa","bbb","ccc"};Student...
  • 一.数组的概念 1.数组无论在哪种编程语言中都算是最重要的数据结构之一,同时不同语言的实现及处理也不尽相同。...最值得注意的是C中的数组Java中的数组的边界检查,c编译器不检查如果程序访问无效的数组索引,而jav
  • 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数组传递及可变参数操作,结合实例形式详细分析了java数组参数传递与可变参数相关使用技巧,需要的朋友可以参考下
  • java数组

    2022-04-23 19:16:21
    目录 一维数组 1.先声明,用new关键字进行内存分配 二维数组 ... //声明int型数组数组中的每个元素都是int型数值 数值名字 = new 数值元素的类型[数组元素的个数]; 数组下标从0开始 publi...
  • Java中有两种类型的数组:基本数据类型数组;对象数组;当一个对象使用关键字“new”创建时,会在堆上分配内存空间,然后返回对象的引用,这对数组来说是一样的,因为数组也是一个对象。一维数组int[] arr = new int...
  • Java字节数组输出

    千次阅读 2021-03-08 05:25:24
    Java ByteArrayOutputStream类字节数组输出流在内存中创建一个字节数组缓冲区,所有发送到输出流的数据保存在该字节数组缓冲区中。创建字节数组输出流对象有以下几种方式。下面的构造方法创建一个32字节(默认大小)的...
  • 1.基本数据类型 ...在堆内存中开辟一块内存空间,把空间的地址返回给当前对象,所以打印出地址值。 可查看当前println方法底层源码 以object类型传入,调用的是object的tostring ②同理,数组也是...
  • Java中其他类型数组打印数组名,输出结果都是内存地址 Java中char类型数组打印数组名,输出结果不是内存地址 char类型的数组就相当于一个字符串。 因为输出流System.out是PrintStream对象,PrintStream有多个重载的...
  • 关于数组中的内存问题,很多人还是不够了解的,本篇我们将就java数组中对内存回收进行讨论,下面就看看具体回收是如何操作的吧。1、内存分析数组引用变量只是一个引用,这个引用变量可以指向任何有效的内存,只有当...
  • 关于数组,我们首先要知道的是,他是引用数据类型,数组是存储同一种数据类型多个元素的容器。...内存,简单说就是存放正在运行的程序,我们知道,java程序运行的载体是JVM,运行环境是JRE,内存分配给JVM空间执...
  • 本章小结了Java数组的基本语法,分享给新学习的小伙伴,分享获取新知大家一起进步。 文章目录一.引言二.数组三.数组的使用四.数组的内存分配 一.引言 回顾数据类型: (1)基本类型 byte short int long float ...
  • 主要介绍了关于Java中char[]输出为什么不是内存地址的原因,文中通过示例代码介绍的很详细,需要的朋友们可以参考学习。
  • Java 数组的使用

    千次阅读 多人点赞 2021-08-14 13:50:26
    Java中,数组的内存在堆上 数组的创建及初始化: 1.数组的创建: 基本语法格式: T[ ] 数组名 = new T[N]; . ① T,即Type,表示:数组中存放元素的类 ② T[ ], 表示:数组的类型 ③ N, 表示:数组的长度 ...
  • 数组内存分析 内存简述 内存是计算机中的重要原件,临时数据存储区域,作用是运行程序。我们编写的程序是存放在硬盘中,在硬盘中的程序是不会运行的,必须放在内存中才能运行,运行完毕后会i清空内存Java虚拟机要...
  • 下面小编就为大家带来一篇Java创建数组的几种方式总结。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • Java数组详解

    千次阅读 2021-09-09 14:10:37
    一、数组概述 1.1 为什么需要数组 如果说现在要求你定义100个整型变量,那么如果按照之前的做法,可能现在定义的的结构如下: int i1, i2, i3, ......如何解决这个问题,Java语言提供了数组(...
  • Java虚拟机在执行Java程序的过程中会把它管理的内存划分成若干个不同的数据区域 A:栈: 存放的是局部变量 局部变量:在方法定义中或者方法声明上的变量都是局部变量。 B:堆: 存放的是所有new出来的东西(比如:int[] ...
  • 1.Java数组是静态的 Java是静态语言,所以Java的数组也是静态的,即:数组被初始化后,长度不可变 静态初始化:显式指定每个数组元素的初始值,系统决定数组长度 String[] books = new String[]{"疯狂Java讲义",...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 240,855
精华内容 96,342
关键字:

java数组输出是内存地址