java返回值b,# java中多返回值的优雅解决方案

一、通过返回数组(或集合)实现

@Test

public void test1(){

int a = 10,b =7;

int[] compute = compute(a,b);

System.out.println("两数之和："+compute[0]);

System.out.println("两数之差:"+compute[1]);

}

private int[] compute(int a,int b){

return new int[]{a+b,a-b};

}

显然这有致命的缺点，你无法通过下标直观的对应[0]是什么含义，[1]是什么含义，特别是别人阅读你的代码可能会有些许的压力。可维护性非常差。

二、通过参数列表带回返回值

同样一种比较常用的方式，参考代码如下

@Test

public void test2(){

int a = 10, b = 7;

IntBox aBox = new IntBox(a);

IntBox bBox = new IntBox(b);

compute2(aBox,bBox);

System.out.println("两数之和：" + aBox);

System.out.println("两数之差:" + bBox);

}

private void compute2(IntBox a,IntBox b){

int diff = a.value - b.value;

int sum = a.value + b.value;

a.value = sum;

b.value = diff;

}

private class IntBox{

private int value;

public IntBox(int value){

this.value = value;

}

@Override

public String toString(){

return String.valueOf(value);

}

}

缺点

基本类型不支持，必须封装成对象，比如上述代码封装了IntBox，造成代码量冗长。

反代码阅读直觉，可读性极差。在别人阅读你的代码时，看到方法调用，一般认为传递了xx参数，获取到xx返回值，而不是参数都甚至被改变，这极大的增加了维护和理解成本，他为了了解参数被发生什么改变，甚至必须深入方法内部逻辑。

>

>

此方法由于过于反直觉、代码量冗长，可读性、可维护性极差，是充满妥协的解决方案。但由于是最简单的方法，所以在新手中不少见，我个人建议不到万万不得已，别使用。

三、通过map实现

比较容易想到的另一种方案，多返回值通过key-value形式返回，示例如下：

@Test

public void test3(){

int a = 10,b =7;

Map resMap = compute3(a,b);

System.out.println("两数之和：" + resMap.get("sum"));

System.out.println("两数之差:" + resMap.get("diff"));

}

private Map compute3(int a,int b){

HashMap hashMap = new HashMap<>();

hashMap.put("diff",a-b);

hashMap.put("sum",a+b);

return hashMap;

}

此方式和数组返回值有相似的地方，可以当做前者的升级版，但map的key是可读的，而数组的下标是没有可读性的。

虽然消除了“数组返回值”时下标不可读性的理解困难问题，但引入的硬编码魔法值已经容易造成维护困难，比如后期可能忘记key的值是sum还是summation，甚至单词拼错都会把bug引入打运行时。这是动态语言常见的问题，在java身上不应该出现。

四、使用枚举作为key消除硬编码

hashMap作为返回值时，最大的缺点就是key的值是string魔法值，消除魔法值常见的办法就是枚举。因此考虑枚举替代String作为key，代码如下

@Test

public void test3(){

int a = 10,b =7;

Map resMap = compute3(a,b);

System.out.println("两数之和：" + resMap.get(ResType.SUM));

System.out.println("两数之差:" + resMap.get(ResType.DIFF));

}

private Map compute3(int a,int b){

HashMap hashMap = new HashMap<>();

hashMap.put(ResType.DIFF,a-b);

hashMap.put(ResType.SUM,a+b);

return hashMap;

}

enum ResType{

SUM,

DIFF

}

emmm，比上述好得多了，但是还是有优化空间。

在方法中必须显式创建一个hashMap比较麻烦。

第9行map的泛型是可以不指定的，如果遇到不规范的队友，依旧存在硬编码问题。

必须多定义一个枚举，一定程度上增加代码量

最终方案：基于enumMap的自定义返回值

创建自定义返回值MutiResult.java代码如下：

public class MutiResult,V>{

private Map resultMap;

private MutiResult(Map resultMap){

this.resultMap = resultMap;

}

/**

* 获取返回值

*

* @param key

* @return

*/

public V get(K key){

return resultMap.get(key);

}

public static ,V> Builder build(){

return new Builder<>();

}

/**

* @param keyClass key的类型

* @param valueClass value类型

* @return 建造者对象

*/

public static ,V> Builder build(Class keyClass,Class valueClass){

return new Builder<>();

}

/**

* 建造者

*

* @param

* @param

*/

public static final class Builder,V>{

private Map resultMap;

Builder(Map resultMap){

this.resultMap = resultMap;

}

Builder(){

this(new ConcurrentHashMap<>());

}

/**

* 生成目标类

*

* @return

*/

public MutiResult build(){

return new MutiResult<>(resultMap);

}

/**

* @param key

* @param value

* @return

* @throws IllegalArgumentException 多次添加同一个key抛出此异常

*/

public Builder add(K key,V value){

if(resultMap.get(key) != null){

throw new IllegalArgumentException("重复添加key：" + key);

}

resultMap.put(key,value);

return this;

}

}

使用方法：

enum ResType{

SUM,

DIFF

}

@Test

public void test4(){

int a = 10,b =7;

MutiResult resMap = compute4(a,b);

System.out.println("两数之和：" + resMap.get(ResType.SUM));

System.out.println("两数之差:" + resMap.get(ResType.DIFF));

}

private MutiResult compute4(int a,int b){

return MutiResult.build(ResType.class,Integer.class)

.add(ResType.SUM,a+b)

.add(ResType.DIFF,a-b)

.build();

}