精华内容
下载资源
问答
  • java数组作为参数传递
    万次阅读 多人点赞
    2019-06-01 16:00:18
    package test03;
    
    public class test {
    
        public static void array(int [] arrayA){
            arrayA[0]=0;
        }
        public static void main(String[] args) {
            int [] arrayA = new int []{1,2,3,4};
            array(arrayA);//传递的是地址值
            System.out.printf("%d",arrayA[0]);
    
    
        }
    }
    
    

    在程序中,调用方法并且把数组的名称作为参数传递到方法中。
    本质上是传递数组的地址值。
    既然传递的是数组的地址,那么方法就可以通过数组的地址改变内存中数组的内容。
    类似于C语言中调用函数传递数组的指针一样。可以在函数中通过指针改变数组的内容。
    所以在JAVA当中,数组为引用类型,可以把数组作为参数传递到方法中去改变数组。

    更多相关内容
  • 主要介绍了Java数组传递及可变参数操作,结合实例形式详细分析了java数组参数传递与可变参数相关使用技巧,需要的朋友可以参考下
  • java学习笔记(四)----对象、数组作为参数传递,静态变量、静态方法的使用,内部类,使用文档注释2009-10-1520:21***对象作为参数传递***classpassparam{intx;publicstaticvoidmain(String[]args){passparamobj...

    java

    学习笔记

    (

    )----

    对象、数组作为参数传递,静态变量、静态方法的使用,

    内部类,使用文档注释

    2009-10-15 20:21

    ***对象作为参数传递***

    class passparam

    { int x;

    public static void main(String[] args)

    { passparam obj = new passparam();

    obj.x=5;

    change(obj);

    System.out.println(obj.x);

    //

    如果

    change

    方法不是静态的,想调用它就得写成

    new

    passparam().change(obj);

    }

    public static void change(passparam obj) //

    如果这个函数前面没加

    static

    编译出

    错,因为非静态方法,不能被静态方法直接调用,

    main

    是一个静态方法。

    { obj.x=3;}

    }

    结果:

    3

    ***数组作为参数传递***

    class passparam

    { int x;

    public static void main(String[] args)

    { passparam obj = new passparam();

    int []x=new int[1];

    x[0]=5;

    change(x);

    System.out.println(x[0]);

    }

    public static void change(int[] x)

    { x[0]=3; }

    }

    结果:

    3

    ***静态变量、静态方法的使用***

    静态变量相当于全局变量

    class Chinese

    { static string country="

    中国

    "; //

    如果改为

    private static string country="

    中国

    "

    下面的两处调用,就会出错

    String name;

    int age;

    static void sing()

    { System.out.println("

    ~~")

    展开全文
  • Java数组作为方法参数

    2022-05-10 22:24:50
    // 数组作为方法参数 数组可以作为方法的参数。 当调用方法的时候,向方法的小括号进行传参,传递进去的其实是数组的地址值。 public class Demo06ArrayMin { public static void main(String[] args) { int[] ...

    // 数组作为方法参数
    数组可以作为方法的参数。
    当调用方法的时候,向方法的小括号进行传参,传递进去的其实是数组的地址值。

    public class Demo06ArrayMin {
        public static void main(String[] args) {
            int[] array = {15,25,35,45,55,65,75};

            System.out.println(array); // 地址值

            printArray(array); // 传递进去的就是array当中保存的地址值
            System.out.println("======AAA=====");
            printArray(array); 
            System.out.println("======BBB=====");
            printArray(array); 
        }
        
        /*
        三要素
        返回值类型:只是进行打印而已,不需要进行计算,也没有结果,用void
        方法名称:printArray
        参数列表:必须给其数组,其才能打印其中的元素。int[] array
        */
        public static void printArray(String[] args) {
            System.out.println("printArray方法收到的参数是:"); 
            System.out.println(array); // 地址值
            for (int i = 0;i < array.length;i++) {
                System.out.println(array[i]);
            }
        }
    }

    展开全文
  • Java数组传递及可变参数

    万次阅读 多人点赞 2018-09-02 11:39:20
    方法可以操作传递和返回基本数据类型,但是方法中也可用来传递和返回数组。如果要向方法中传递一个数组,则方法的接收参数处必须是...而数组也是一种对象,当把数组作为参数传递给方法时,传递的实际上就是数组对...

    方法可以操作传递和返回基本数据类型,但是方法中也可用来传递和返回数组。如果要向方法中传递一个数组,则方法的接收参数处必须是符合其类型的数组。而且数组属于引用数据类型,所以在把数组传递进方法之后,如果方法对数组本身做了任何修改,修改结果都是会保存下来的。

     

    向方法中传递数组

    在java中,所有对象都是通过引用进行操作的。而数组也是一种对象,当把数组作为参数传递给方法时,传递的实际上就是数组对象的引用。在方法中对数组的所有操作,都会映射到原数组中。而所谓的"引用",就是java对象在堆内存的地址赋给了多个"栈内存"的变量。

    public class Test {
        public static void main(String[] args) {
            int[] array = { 1, 3, 5 }; // 使用静态初始化定义数组
            method(array); // 传递数组引用
            for (int i = 0; i < array.length; i++) { // 循环输出
                System.out.print(array[i] + "\t");
            }
        }
        public static void method(int[] x) { // 接收整型数组引用
            x[0] = 6; // 修改第一个元素的内容
        }
    }

    执行结果:

    6	3	5	

    我们来看一下其执行时的内存状态:

     

    使用方法返回一个数组

    既然方法可以接收一个数组,那么方法也就可以返回一个数组,则此时,只需要在返回值类型声明处明确的写出返回的数组类型即可。

    public class Test {
        public static void main(String[] args) {
            int[] array = method(); // 通过方法实例化数组
            print(array); // 向print()方法中传递数组
        }
        public static void print(int x[]) { // 接收数组
            for (int i = 0; i < x.length; i++) { // 循环输出
                System.out.print(x[i] + "");
            }
        }
        public static int[] method() { // 此方法返回一个数组引用
            int ss[] = { 1, 3, 5, 7, 9 }; // 定义一个数组
            return ss; // 返回数组
        }
    }
    

    执行结果:

    1 3 5 7 9 

     

    可变参数(JDK 1.5)

    JDK 1.5 开始,Java支持传递同类型的可变参数给一个方法。一个方法中只能指定一个可变参数,它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

    声明方式:

    返回值类型 方法名称(类型…参数名称){ // 在方法声明中,在指定参数类型后加一个省略号(...) 
        // 方法体
    }

    可变参数方法的使用与方法参数部分使用数组是一致的,例如可以循环输出所有的参数值。

    public static void print(String...names) { // 接收数组
        for(String name : names) {
            System.out.print(name + " "); 
        }
        System.out.println();
    }

    调用的时候可以给出任意多个参数也可不给参数,例如:

    public static void main(String[] args) {
        String[] names = {"jerry", "tom", "rose"};
        print(); // 不传递参数
        print("jerry", "tom"); // 传递多个参数
        print(names); // 传递数组
    }

    从以上代码可知,调用使用了可变参数的方法时:

    1)可以不写参数,即传入空参;

    2)可以直接在里边写入参数,参数间用逗号隔开;

    3)可以传入一个数组;

     

     

     

    可变参数的使用规则

    1) 拥有可变参数的方法可以被重载,在调用方法的时候,如果能够和固定参数的方法匹配,也能够与可变长参数的方法匹配,则选择固定参数的方法。

    public class Test {
        public static void main(String[] args) {
            print();
            print("jerry");
            print("jerry", "tom");
        }
        public static void print(String...names) { // 接收数组
            System.out.print("可变参数方法: ");
            for(String name : names) {
                System.out.print(name + " "); 
            }
            System.out.print("\n");
        }
        public static void print(String name) { // 接收一个String类型参数
            System.out.println("固定参数方法: " + name);
        }
    }

    执行结果如下:

    可变参数方法: 
    固定参数方法: jerry
    可变参数方法: jerry tom 

    2)如果要调用的方法可以和两个可变参数匹配,则出现错误。

    public class Test {
        public static void main(String[] args) {
            print();
            print("jerry");  // 编译错误
            print("jerry", "tom"); // 编译错误
        }
        public static void print(String...names) {
            System.out.println("------1------");
        }
        public static void print(String name, String...names) { 
            System.out.println("------2------ ");
        }
    }
    

    main方法中的两个传参的调用都不能编译通过,因为编译器不知道该选哪个方法调用,如下所示:

    3)一个方法只能有一个可变长参数,并且这个可变长参数必须是该方法的最后一个参数

    public class Test {
        public static void print(String name, String...names) {
            System.out.println("------1------");
        }
        public static void print(int[] Ids, String...names) { 
            System.out.println("------2------ ");
        }
    }

    以下的方法定义都是错误的:

    4)可变参数可以兼容数组参数,但数组参数无法兼容可变参数。

    public class Test {
        public static void main(String[] args) {
        }
        public void print(String... names){
            System.out.println("-----1-----");
        } 
        public void print(String[] names){ 
            System.out.println("-----2-----");
        }
    }

    当试图使用数组作为参数去实现重载时,会报错,说明可变参数与数组冲突(两者应该是一方能兼容另一方)。

    public class Test {
        public static void main(String[] args) {
            Test test = new Test();
            test.print("jerry","tom");
        }
        public  void print(String[] namse){ 
            System.out.println("----------");
        }
    }

    如果定义一个参数为数组的方法,像调用可变参数的方法一样调用它是会报错,说明可变参数并不是一个数组。

     

    可变长参数的使用规范

    1) 避免带有可变长参数的方法重载

    例如上面使用规则的第一个例子,编译器虽然知道怎么调用,但人容易陷入调用的陷阱及误区。

    2) 别让null值和空值威胁到变长方法

    public class Test {
        public static void main(String[] args) {
            print("人事部");
            print("jerry", null);
        }
        public static void print(String dept, Integer...Ids) {
        }
        public static void print(String name, String...names ){
        }
    }

    以上main方法里的两个调用编译都不通过:

    因为两个方法都匹配,编译器不知道选哪个,于是报错了,这里同时还有个非常不好的编码习惯,即调用者隐藏了实参类型,这是非常危险的,不仅仅调用者需要“猜测”该调用哪个方法,而且被调用者也可能产生内部逻辑混乱的情况。对于本例来说应该做如下修改:

    public static void main(String[] args) {
        String[] names = null;
        print("jerry", names);
    }

    3)重写(覆写)可变参数方法也要循规蹈矩

    public class Test {
        public static void main(String[] args) {
            // 向上转型
            Base base = new Sub();
            base.print("hello");
            // 不转型
            Sub sub = new Sub();
            sub.print("hello");
        }
    }
    //基类
    class Base {
        void print(String... args) {
            System.out.println("Base......test");
        }
    }
    //子类,覆写父类方法
    class Sub extends Base {
        @Override
        void print(String[] args) {
            System.out.println("Sub......test");
        }
    }

    以上main方法中第二个调用编译不通过:

    第一个能编译通过,这是为什么呢?事实上,base对象把子类对象sub做了向上转型,形参列表是由父类决定的,当然能通过。再看看子类直接调用的情况,这时编译器看到子类覆写了父类的print方法,因此肯定使用子类重新定义的print方法,尽管参数列表不匹配也不会跑到父类再去匹配下,因为找到了就不再找了,因此有了类型不匹配的错误。

    这是个特例,重写的方法参数列表与父类不相同,这违背了重写的定义,并且会引发莫名其妙的错误。在这里,我们再复习下重写必须满足的条件:

    1)重写方法不能缩小访问权限;

    2)参数列表必须与被重写方法相同(包括显示形式);

    3)返回类型必须与被重写方法的相同或是其子类;

    4)重写方法不能抛出新的异常,或者超过了父类范围的异常,但是可以抛出更少、更有限的异常,或者不抛出异常。

     

    最后,我们看下面一个有陷阱的例子:

    public class Test {
        public static void main(String[] args) {
            print("");
            print("jerry");
            print("jerry", "tom");
        }
        public static void print(String name, String... names) {
            for (int i = 0; i < names.length; i++) {
                System.out.println(names[i]);
            }
        }
    }

    以上代码是能够正常编译执行的,它的执行结果如下:

    tom

     

     

    展开全文
  • axios 的post方法向后台传递参数时的代码: var params = new URLSearchParams(); params.append('faultNum',this..fault_num); params.append('far',this.far); this.$Axios.post("/test",params) .then(res => {...
  • java 数组作为方法参数

    千次阅读 2019-12-02 10:30:55
    数组作为方法参数 例:定义方法,打印输出数组元素的值 ...数组作为方法参数,当传参的时候,传递的是数组的名字。而在方法中定义的数组名为arr; package com.javaTest; import java.util.Scanner; public...
  • Java模板上的JS 这个Java项目能够运行javascript文件,并能够传递任何类型的Java数组作为参数
  • 数组可以作为方法的参数。 当调用方法的时候,向方法的小括号进行传参,传递进去的其实是数组的地址值。 */ public class Demo01ArrayParam { public static void main(String[] args) { int[] array = {10,20,...
  • 初学方法数组传值问题,不多废话,直接代码 方法的返回值都为空 所以在main方法中不会有返回值,最后的结果应该在控制台输出10和10 但是        这里还是涉及到java 的内存...
  • 数组可以作为参数传递给方法。 public class Demo03 { public static void main(String[] args) { test01(new int[]{1,4,5,8,33}); } /** * @param array 数组作为参数 */ public static void test01(int...
  • 数组作为参数的样例: public static void main(String[] args) { // 调用方法时传递一个数组 int [] arrayData = {1 ,2 ,3 }; arrayManage(arrayData); } public static void arrayManage(int [] data){ ...
  • } } 扩展资料: 把数组作为参数传入一个方法,在该方法中对数e69da5e887aa3231313335323631343130323136353331333366306464组进行一些操作:如果仅仅是插入数据项等一般操作,那么该操作会影响到数组本身;...
  • 本问题已经有最佳答案,请猛点这里访问。Possible Duplicate:Is Java"pass-by-reference"?数组不是Java中的原始类型,但它们也不是对象...所有参数传递都是按值传递的。在对象的情况下,传递的是对该对象(即指针)的...
  • 二维数组传递参数

    2021-02-12 17:56:00
    二维数组的传参二级数组传递参数时,不能以一个二级指针的方式,以二级指针的方式只传递了这个二级数组的首地址,但没有带出这个二维数组各元素的地址,编译器不能通过二级指针的移动寻找其元素。对于二级数组要用...
  • 对于Array(它只不过是一个对象),数组引用是通过值传递的。(就像通过值传递对象引用一样)。当您将数组传递给其他方法时,实际上复制了对该数组的引用。通过该引用对数组内容的任何更改都将影响原始数组。但是,将...
  • java传入数组参数

    千次阅读 2021-03-15 23:12:49
    8) 向方法传递数组参数时,......Java新特性对数组的支持_信息与通信_工程科技_专业资料。可变参数和增强的for循环是JDK1.5提出的众多特性中的两个新特性,是Java基础编程中用得比较多的特性。本文......Java数组的...
  • 数组在函数定义中的使用格式(int[] OrphanCount)调用的时候一般使用: int[] OrphanCountBefore = new int[2];theCalledMethod(OrphanCountBefore);这是公共函数public void GetOrphanCount(int[] OrphanCount) {int...
  • 题主的例子,我们按顺序说明一下 List list = new ArrayList();... 这也就是为什么,如果有频繁的字符串变化,通常建议使用StringBuilder 总结,在Java中当参数为基本数据类型就是值传递,当参数是引用类型就是引用传递
  • 数组作为方法的参数传递进去的其实是数组的地址值。 数组作为方法的返回值,返回的其实也是数组的地址值。 public class Demo02ArrayReturn { public static void main(String[] args) { i...
  • 数组可以存放多个同一类型的数据。数组也是一种数据类型,是引用类型。 即:数(数据)组(一组)就是一组数据。数组是一种数据结构, 用来存储同一类型值的集合。通过一个整型下标可以访问数组中的每一个值。
  • 填空題一 length 来访问数组Array得长度为 Array!数组得元素通过 下 标 传递给另一个数组将一个数纽得 引用 2数组复制时 中 栈 堆政栈3 JVM...0 o得最E 个参数指明 复制元素得个数 7 arraycopyO 向方法传递数组参数时传
  • Java 传递数组参数给 SQL 进行查询时需要做一些专门处理。比如 SQL 语句 select * from EMP where EID in(?)中,如果要把数组 [1,2,4] 作为参数传入,需要把 SQL 写成 select * from EMP where EID in(?, ?, ?)的...
  • //数组的引用传递public class ArrayTest{//数组可以作为参数//方法public static void printArr(int[] arr){for(int i=0;iSystem.out.print(arr[i]+"\t");}System.out.println();}//数组作为返回值类型public stat....
  • 一、定义Java方法 public int testIntParameter(int[] value) { Log.e(TAG, "C++调用Java value =" + Arrays.toString(value)); return 1; } public int testFloatParameter(float[] value) { Log.e(TAG, ...
  • 1.关于数组的初始化操作: 静态初始化:声明数组同时赋值:int[] arr={1,2,3,3}; 动态初始化:int[] data=new int[]{1,2,3}; 2.关于数组的访问 ...数组作为方法的参数传递: import java.util.Arrays; pu
  • C语言与JAVA数组作为参数传递的区别 首先是C语言 #include <stdio.h> #include <stdlib.h> int main() { int arr[5]; int length = sizeof(arr) / sizeof(int); //求数组长度 printf("数组长度: %d...
  • 数组作为方法参数和返回值 以前的方法中我们学习...数组作为方法参数传递,传递的参数是数组内存的地址。 public static void main(String[] args) { int[] arr = { 1, 3, 5, 7, 9 }; //调用方法,传递数组 printAr...
  • package Code411;//数组作为方法参数传递地址public class DodeArrayParam { public static void main(String[] args) { int[] array={1,2,3,4}; System.out.println(array);//地址值 printArray(array);/...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 272,623
精华内容 109,049
关键字:

java数组作为参数传递