JAVA方法返会一个或多个对象或者参数写法实践

JAVA方法返会一个或多个对象写法实践，有时候需要一个方法返回多个对象

但是没办法一次性返回，常见解决方案如下：

1.使用Pair函数可以同时返回2个对象

2.使用Triple函数可以同时返回3个对象

3.定义一个任意对象，函数可以同时返回任意个数对象

4.使用容器集合，Map或者List

Maven仓库地址

https://mvnrepository.com/search?q=jic-starter-mybatis

使用函数需要引入相关包依赖

<!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.12.0</version>
</dependency>

package com.example.demo.controller;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.apache.commons.lang3.tuple.ImmutablePair;
import org.apache.commons.lang3.tuple.ImmutableTriple;
import org.apache.commons.lang3.tuple.Pair;
import org.apache.commons.lang3.tuple.Triple;

import java.util.HashMap;
import java.util.Map;

/**
 * @author lisanwei24282
 */
public class Result {

    public static void main(String[] args) {

        /* 第一种：返回2个对象（仅仅返回两个对象） */
        Pair<ObjectDTO, ResultDTO> objectResultPair = getMultipleObject();
        // 第一个对象
        ObjectDTO left = objectResultPair.getLeft();
        // 第二个对象
        ResultDTO right = objectResultPair.getRight();

        /* 第二种：返回2个对象（仅仅返回三个对象） */
        Triple<ObjectDTO, ResultDTO, NewDTO> tripleObject = getMultipleTripleObject();
        // 第一个对象
        ObjectDTO left1 = tripleObject.getLeft();
        // 第二个对象
        ResultDTO middle = tripleObject.getMiddle();
        // 第三个对象
        ResultDTO right3 = objectResultPair.getRight();

        /* 第三种：创建一个任意对象，定义对象属性（返回任意对象） */
        new Result.ResultDTO(new ObjectDTO(), new ResultDTO(), new NewDTO());

        /* 第四种：使用集合创建任意对象 */
        Map<String, Object> map = new HashMap<>(10);
        map.put("ObjectDTO", new ObjectDTO());
        map.put("ResultDTO", new ResultDTO());
        map.put("NewDTO", new NewDTO());
    }


    /**
     * 使用批量对象数据
     *
     * @return 结果集
     */
    public static Pair<ObjectDTO, ResultDTO> getMultipleObject() {
        return ImmutablePair.of(new ObjectDTO(), new ResultDTO());
    }

    /**
     * 使用批量对象数据
     *
     * @return 结果集
     */
    public static Triple<ObjectDTO, ResultDTO, NewDTO> getMultipleTripleObject() {
        return ImmutableTriple.of(new ObjectDTO(), new ResultDTO(), new NewDTO());
    }

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    static class ObjectDTO {
        private ObjectDTO object1;
        private ObjectDTO object2;
        private ObjectDTO object3;
    }

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    static class ResultDTO {
        private ObjectDTO object1;
        private ResultDTO object2;
        private NewDTO object3;
    }

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    static class NewDTO {
        private NewDTO object1;
        private NewDTO object2;
        private NewDTO object3;
    }

}