Java 返回值return用法（用多种方法实现“使用一个方法要如何返回多个对象”）

小咪咪 2023-09-27 14:33 67阅读 0赞

## 一、Java 中return的使用（返回0或1个对象） ##

在Python中，一个函数可以返回多个对象，但是在Java语言中，不支持一个return返回多个对象。当自定义一个Java类的时候，会有自己定义的方法和变量，有的方法有返回值，有的没有用返回值则用void。

方法的定义: public 返回值类型方法名（参数类型参数名，...) {
                                java语句；
                            }

当一个方法有返回值时，就是说这个方法要返回一个对象。（Java一个方法可以有0个或1个返回值。）

那么定义方法时的返回值类型就应该是这个对象类，比如你的方法返回String那么可以写成
            public String aaa (){
                 String b ="aa" ;
                 return b;
               }
        其中的return返回了一个String类型的变量。

当你想应用这个类中的这个方法时比如这个类名是Ss就可以

public Ss ss =new Ss(); 
                    String a =ss.aaa();

这时你定义的方法返回的值就给了a对象，你现在就得到了a，即方法的返回值。

依照情况而定，有两种:

1.在循环中判断条件时使用。帮助当你的需要的条件满足时跳出或中止循环。

2.在方法里，当你定义一个方法，需要它返回一个值给你的时候，在方法最后，将处理的值返回到你需要的地方。

例如：我们做一个加法计算方法: int a=jiafa(1,2)//使用加法方法jiafa，传递两个int型的数值1，2，用a接受方法返回的结果。一个有返回值的加法方法如下：

public int jiafa(int b,int c){ 
                                int d=b+c; 
                                return d;//返回b+c的和 
                        } 
                System.out.print("a="+a);

将会输出: a=3(即你传的参数1+2之合)

## 二、要返回多个对象该怎么办呢？ ##

要实现也不难，有三种可行的方法：1、最常用的就是将返回的对象放在另外一个类（中间类），就将要返回的对象变成新类的变量 ；2、还可以将要返回的对象放进map中去（这个也行，但感觉没有第一种代码简单）。

public class CountNumber {
    
        public static void main(String[] args) {
            ResultDto r =  extracted();
            call(r);
        }
    
        private static ResultDto extracted() {
            int[] arr = {11,22,33,44,55,66,77,88};
            int index = 0;
            int max = arr[0]; // 取数组中的第一个数据为max值
            for (int i = 0; i < arr.length; i++) {
                max = arr[i];
                index = i;
            }
            // 使用中间类返回两个对象
            return new ResultDto(max,index);
            // System.out.println("最大值是" + max + "下标是"+index);
        }
        private static void  call(ResultDto resultDto){
            if(resultDto == null){
                return;
            }
            System.out.println("最大值是" + resultDto.getMax() + "下标是"+resultDto.getIndex());
        }
    }

下面是用map去实现相同的效果。

public class CountNumber {
        public static void main(String[] args) {
            ResultDto extracted = extracted();
            Map<String, Object> map = queryDate(extracted);
            System.out.println("最大值为：" + map.get("最大值"));
            System.out.println("下标是为：" + map.get("下标是"));
        }
    
        private static ResultDto extracted() {
            int[] arr = {11,22,33,44,55,66,77,88};
            int index = 0;
            int max = arr[0]; // 取数组中的第一个数据为max值
            for (int i = 0; i < arr.length; i++) {
                max = arr[i];
                index = i;
            }
            // 使用中间类返回两个对象
            return new ResultDto(max,index);
            // System.out.println("最大值是" + max + "下标是"+index);
        }
    
        private static Map<String,Object> queryDate(ResultDto resultDto){
            Map<String,Object> map = new HashMap<>();
            // map.put("最大值",new ResultDto().getMax());
            map.put("最大值",resultDto.getMax());
            map.put("下标是",resultDto.getIndex());
            return map;
        }
    }

![2c7bb07133c28d55aaae2dd4e12ebcc9.png][]

不过经过查询资料发现Apache 容器类还支持了，保存两个对象的Pair<Object ,Object>和 保存三个对象的 Triple<Object ,Object,Object>。详细情况可以参考这篇文章：

[ Apache工具类Pair和Triple详解][Apache_Pair_Triple]

不过出于学习的目的还是看一下这第三种方法实现方法：

首先需要引入依赖：

<dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-lang3</artifactId>
                <version>3.8.1</version>
            </dependency>

public class CountNumber {
    
        public static void main(String[] args) {
            ResultDto r =  extracted();
    
            Pair<Integer, Integer> call = call(r);
            System.out.println("最大值为"+call.getLeft() +"\n其下标为"+call.getRight());
        }
    
        private static ResultDto extracted() {
            int[] arr = {11,22,33,44,55,66,77,88};
            int index = 0;
            int max = arr[0]; // 取数组中的第一个数据为max值
            for (int i = 0; i < arr.length; i++) {
                max = arr[i];
                index = i;
            }
            // 使用中间类返回两个对象
            return new ResultDto(max,index);
            // System.out.println("最大值是" + max + "下标是"+index);
        }
    
        private static Pair<Integer, Integer> call(ResultDto resultDto){
            return Pair.of(resultDto.getMax(),resultDto.getIndex());
        }
    }

public class CountNumber {
    
        public static void main(String[] args) {
            ResultDto r =  extracted();
    
            Triple<String,Integer, Integer> call = call(r);
            System.out.println(call.getLeft()+"\n最大值为"+call.getMiddle() +"\n下标为"+call.getRight());
        }
    
        private static ResultDto extracted() {
            int[] arr = {11,22,33,44,55,66,77,88};
            int index = 0;
            int max = arr[0]; // 取数组中的第一个数据为max值
            for (int i = 0; i < arr.length; i++) {
                max = arr[i];
                index = i;
            }
            // 使用中间类返回两个对象
            return new ResultDto(max,index);
            // System.out.println("最大值是" + max + "下标是"+index);
        }
    
        private static Triple<String, Integer, Integer> call(ResultDto resultDto){
            return Triple.of("白白白鲤鱼的",resultDto.getMax(),resultDto.getIndex());
        }
    }

![5caf3556c20be16c1c191640a084cea0.png][]

[2c7bb07133c28d55aaae2dd4e12ebcc9.png]: https://img-blog.csdnimg.cn/img_convert/2c7bb07133c28d55aaae2dd4e12ebcc9.png
[Apache_Pair_Triple]: https://blog.csdn.net/swadian2008/article/details/126468437
[5caf3556c20be16c1c191640a084cea0.png]: https://img-blog.csdnimg.cn/img_convert/5caf3556c20be16c1c191640a084cea0.png