我想从Java方法返回两个对象，并且想知道这样做的好方法是什么？
我能想到的可能的方法是：回报HashMap（因为这两个对象是相关的），或者返回ArrayList的Object对象。
更准确地说，我要返回的两个对象是（a）List对象和（b）相同名称的逗号分隔。
我想从一个方法返回这两个对象，因为我不想遍历对象列表以获得逗号分隔的名称（我可以在此方法的同一循环中完成此操作）。
不知何故，返回aHashMap看起来不是很优雅的方式。
我想从Java方法返回两个对象，并且想知道这样做的好方法是什么？
我能想到的可能的方法是：回报HashMap（因为这两个对象是相关的），或者返回ArrayList的Object对象。
更准确地说，我要返回的两个对象是（a）List对象和（b）相同名称的逗号分隔。
我想从一个方法返回这两个对象，因为我不想遍历对象列表以获得逗号分隔的名称（我可以在此方法的同一循环中完成此操作）。
不知何故，返回aHashMap看起来不是很优雅的方式。
Answers:
如果要返回两个对象，通常需要返回一个封装了两个对象的单个对象。
您可以返回这样的NamedObject对象列表：
public class NamedObject<T> {
public final String name;
public final T object;
public NamedObject(String name, T object) {
this.name = name;
this.object = object;
}
}
然后，您可以轻松返回List<NamedObject<WhateverTypeYouWant>>。
另外：为什么要返回逗号分隔的名称列表而不是List<String>？更好的方法是返回a Map<String,TheObjectType>，键为对象的名称和值（除非您的对象已指定顺序，在这种情况下，aNavigableMap可能就是您想要的）。
如果您知道要返回两个对象，则也可以使用通用对：
public class Pair<A,B> {
public final A a;
public final B b;
public Pair(A a, B b) {
this.a = a;
this.b = b;
}
};
编辑以上内容的完整格式的实现：
package util;
public class Pair<A,B> {
public static <P, Q> Pair<P, Q> makePair(P p, Q q) {
return new Pair<P, Q>(p, q);
}
public final A a;
public final B b;
public Pair(A a, B b) {
this.a = a;
this.b = b;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((a == null) ? 0 : a.hashCode());
result = prime * result + ((b == null) ? 0 : b.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
@SuppressWarnings("rawtypes")
Pair other = (Pair) obj;
if (a == null) {
if (other.a != null) {
return false;
}
} else if (!a.equals(other.a)) {
return false;
}
if (b == null) {
if (other.b != null) {
return false;
}
} else if (!b.equals(other.b)) {
return false;
}
return true;
}
public boolean isInstance(Class<?> classA, Class<?> classB) {
return classA.isInstance(a) && classB.isInstance(b);
}
@SuppressWarnings("unchecked")
public static <P, Q> Pair<P, Q> cast(Pair<?, ?> pair, Class<P> pClass, Class<Q> qClass) {
if (pair.isInstance(pClass, qClass)) {
return (Pair<P, Q>) pair;
}
throw new ClassCastException();
}
}
注意事项，主要围绕Java和泛型的生锈：
a和b是不可变的。makePair静态方法可以帮助您进行样板键入，而Java 7中的diamond运算符将减少这种烦恼。有一些工作可以使这个真正的re：generics很好，但是现在应该可以了。（请参阅PECS）hashcode并且equals由蚀产生。cast方法中的编译时转换是可以的，但似乎不太正确。isInstance。Pair实现。我要做的一个小更改：在中添加一条消息ClassCastException。否则，如果由于某种原因失败，调试将成为噩梦。（如果您强制转换为rawtypes，则无需发出警告Pair<?,?>（有效，因为您只需要和中的Object方法）。您介意我对代码进行调整吗？ab
如果您要调用的方法是私有的，或者是从一个位置调用的，请尝试
return new Object[]{value1, value2};
呼叫者看起来像：
Object[] temp=myMethod(parameters);
Type1 value1=(Type1)temp[0]; //For code clarity: temp[0] is not descriptive
Type2 value2=(Type2)temp[1];
David Hanak的Pair对示例没有语法优势，并且被限制为两个值。
return new Pair<Type1,Type2>(value1, value2);
呼叫者看起来像：
Pair<Type1, Type2> temp=myMethod(parameters);
Type1 value1=temp.a; //For code clarity: temp.a is not descriptive
Type2 value2=temp.b;
Pair<T1, T2>，Tuple<T1, T2, T3>，Tuple<T1, T2, T3, T4>等。然后一具体使用节目的数量和类型的参数Pair<int, String> temp = ...或任何。
您可以使用以下任何一种方式：
private static final int RETURN_COUNT = 2;
private static final int VALUE_A = 0;
private static final int VALUE_B = 1;
private static final String A = "a";
private static final String B = "b";
1）使用数组
private static String[] methodWithArrayResult() {
//...
return new String[]{"valueA", "valueB"};
}
private static void usingArrayResultTest() {
String[] result = methodWithArrayResult();
System.out.println();
System.out.println("A = " + result[VALUE_A]);
System.out.println("B = " + result[VALUE_B]);
}
2）使用ArrayList
private static List<String> methodWithListResult() {
//...
return Arrays.asList("valueA", "valueB");
}
private static void usingListResultTest() {
List<String> result = methodWithListResult();
System.out.println();
System.out.println("A = " + result.get(VALUE_A));
System.out.println("B = " + result.get(VALUE_B));
}
3）使用HashMap
private static Map<String, String> methodWithMapResult() {
Map<String, String> result = new HashMap<>(RETURN_COUNT);
result.put(A, "valueA");
result.put(B, "valueB");
//...
return result;
}
private static void usingMapResultTest() {
Map<String, String> result = methodWithMapResult();
System.out.println();
System.out.println("A = " + result.get(A));
System.out.println("B = " + result.get(B));
}
4）使用您的自定义容器类
private static class MyContainer<M,N> {
private final M first;
private final N second;
public MyContainer(M first, N second) {
this.first = first;
this.second = second;
}
public M getFirst() {
return first;
}
public N getSecond() {
return second;
}
// + hashcode, equals, toString if need
}
private static MyContainer<String, String> methodWithContainerResult() {
//...
return new MyContainer("valueA", "valueB");
}
private static void usingContainerResultTest() {
MyContainer<String, String> result = methodWithContainerResult();
System.out.println();
System.out.println("A = " + result.getFirst());
System.out.println("B = " + result.getSecond());
}
5）使用AbstractMap.simpleEntry
private static AbstractMap.SimpleEntry<String, String> methodWithAbstractMapSimpleEntryResult() {
//...
return new AbstractMap.SimpleEntry<>("valueA", "valueB");
}
private static void usingAbstractMapSimpleResultTest() {
AbstractMap.SimpleEntry<String, String> result = methodWithAbstractMapSimpleEntryResult();
System.out.println();
System.out.println("A = " + result.getKey());
System.out.println("B = " + result.getValue());
}
6）利用一对的Apache的百科全书
private static Pair<String, String> methodWithPairResult() {
//...
return new ImmutablePair<>("valueA", "valueB");
}
private static void usingPairResultTest() {
Pair<String, String> result = methodWithPairResult();
System.out.println();
System.out.println("A = " + result.getKey());
System.out.println("B = " + result.getValue());
}
当我用Java编写代码时，我几乎总是最终定义n-Tuple类。例如：
public class Tuple2<T1,T2> {
private T1 f1;
private T2 f2;
public Tuple2(T1 f1, T2 f2) {
this.f1 = f1; this.f2 = f2;
}
public T1 getF1() {return f1;}
public T2 getF2() {return f2;}
}
我知道这有点丑陋，但是可以用，您只需要定义一次元组类型。元组是Java真正缺少的东西。
编辑：David Hanak的示例更加优雅，因为它避免了定义getters并仍然保持对象不变。
在Java 5之前，我会同意Map解决方案不是理想的选择。它不会给您编译时类型检查，因此会在运行时引起问题。但是，对于Java 5，我们具有泛型类型。
因此，您的方法可能如下所示：
public Map<String, MyType> doStuff();
MyType当然是您要返回的对象的类型。
基本上，我认为在这种情况下返回Map是正确的解决方案，因为这正是您要返回的内容-字符串到对象的映射。
Apache Commons为此提供了元组和三元组：
ImmutablePair<L,R> 由两个Object元素组成的不可变对。ImmutableTriple<L,M,R> 一个不变的三元组，由三个Object元素组成。MutablePair<L,R> 由两个Object元素组成的可变对。MutableTriple<L,M,R> 可变的三元组，由三个Object元素组成。Pair<L,R> 一对，由两个元素组成。Triple<L,M,R> 由三个元素组成的三元组。来源：https : //commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/tuple/package-summary.html
另外，在要从方法返回许多东西的情况下，有时会使用回调机制而不是容器。在无法提前指定要生成多少个对象的情况下，这非常有效。
对于您的特定问题，它看起来像这样：
public class ResultsConsumer implements ResultsGenerator.ResultsCallback
{
public void handleResult( String name, Object value )
{
...
}
}
public class ResultsGenerator
{
public interface ResultsCallback
{
void handleResult( String aName, Object aValue );
}
public void generateResults( ResultsGenerator.ResultsCallback aCallback )
{
Object value = null;
String name = null;
...
aCallback.handleResult( name, value );
}
}
java，如果您有对象A调用objectB.getResult()并将其作为aB.getResult()调用，则该对象会被垃圾回收还是会一直存在直到A完成？可能是一个愚蠢的问题，但我有一个根本的困惑！A.finishResult()callbackB
使用以下Entry对象示例：
public Entry<A,B> methodname(arg)
{
.......
return new AbstractMap.simpleEntry<A,B>(instanceOfA,instanceOfB);
}
通常，关于多个返回值的问题，我通常使用一个小的帮助程序类，该类包装单个返回值并将其作为参数传递给方法：
public class ReturnParameter<T> {
private T value;
public ReturnParameter() { this.value = null; }
public ReturnParameter(T initialValue) { this.value = initialValue; }
public void set(T value) { this.value = value; }
public T get() { return this.value; }
}
（对于原始数据类型，我使用较小的变化形式来直接存储值）
然后，要声明一个要返回多个值的方法，如下所示：
public void methodThatReturnsTwoValues(ReturnParameter<ClassA> nameForFirstValueToReturn, ReturnParameter<ClassB> nameForSecondValueToReturn) {
//...
nameForFirstValueToReturn.set("...");
nameForSecondValueToReturn.set("...");
//...
}
可能的主要缺点是调用者必须提前准备返回对象，以防他想要使用它们（并且该方法应检查空指针）
ReturnParameter<ClassA> nameForFirstValue = new ReturnParameter<ClassA>();
ReturnParameter<ClassB> nameForSecondValue = new ReturnParameter<ClassB>();
methodThatReturnsTwoValues(nameForFirstValue, nameForSecondValue);
优点（与提出的其他解决方案相比）：
保持简单，并为多种结果情况创建一个类。本示例接受ArrayList和来自数据库助手getInfo的消息文本。
在调用返回多个值的例程的地方，编写代码：
multResult res = mydb.getInfo();
在例程getInfo中，您可以编写以下代码：
ArrayList<String> list= new ArrayList<String>();
add values to the list...
return new multResult("the message", list);
并使用以下内容定义一个multResult类：
public class multResult {
public String message; // or create a getter if you don't like public
public ArrayList<String> list;
multResult(String m, ArrayList<String> l){
message = m;
list= l;
}
}
正如我所看到的，这里确实有三个选择，解决方案取决于上下文。您可以选择在生成列表的方法中实现名称的构造。这是您选择的选择，但我认为这不是最好的选择。您正在使用生产者方法与不需要使用的消费方法建立耦合。其他呼叫者可能不需要这些额外信息，您将在为这些呼叫者计算额外信息。
或者，您可以让调用方法计算名称。如果只有一个呼叫者需要此信息，则可以在此停止。您没有额外的依赖关系，虽然涉及到一些额外的计算，但避免了使构造方法过于具体。这是一个很好的权衡。
最后，您可以让列表本身负责创建名称。如果需要多个呼叫者完成计算，这就是我要走的路线。我认为，这就是使用与对象本身最密切相关的类来创建名称的责任。
在后一种情况下，我的解决方案是创建一个专门的List类，该类返回一个逗号分隔的字符串，其中包含该对象的名称。使类足够聪明，以便在添加和删除对象时动态构造名称字符串。然后返回此列表的一个实例，并根据需要调用名称生成方法。尽管将名称的计算延迟到第一次调用该方法并存储然后再存储（延迟加载）可能几乎一样有效（并且更简单）。如果添加/删除对象，则只需删除计算出的值，并在下一次调用时重新计算它。
可以在动态语言（Python）中执行类似元组的操作
public class Tuple {
private Object[] multiReturns;
private Tuple(Object... multiReturns) {
this.multiReturns = multiReturns;
}
public static Tuple _t(Object... multiReturns){
return new Tuple(multiReturns);
}
public <T> T at(int index, Class<T> someClass) {
return someClass.cast(multiReturns[index]);
}
}
像这样使用
public Tuple returnMultiValues(){
return Tuple._t(new ArrayList(),new HashMap())
}
Tuple t = returnMultiValues();
ArrayList list = t.at(0,ArrayList.class);
我根据其他要求采用了与其他答案中所述类似的方法，并进行了一些调整，基本上我创建了以下类（以防万一，所有内容都是Java）：
public class Pair<L, R> {
final L left;
final R right;
public Pair(L left, R right) {
this.left = left;
this.right = right;
}
public <T> T get(Class<T> param) {
return (T) (param == this.left.getClass() ? this.left : this.right);
}
public static <L, R> Pair<L, R> of(L left, R right) {
return new Pair<L, R>(left, right);
}
}
然后，我的要求很简单，在到达DB的存储库Class中，对于Get Methods而不是从DB检索数据，我需要检查它是否失败或成功，然后，如果成功，则需要处理返回列表，如果失败，则停止执行并通知错误。
因此，例如，我的方法如下：
public Pair<ResultMessage, List<Customer>> getCustomers() {
List<Customer> list = new ArrayList<Customer>();
try {
/*
* Do some work to get the list of Customers from the DB
* */
} catch (SQLException e) {
return Pair.of(
new ResultMessage(e.getErrorCode(), e.getMessage()), // Left
null); // Right
}
return Pair.of(
new ResultMessage(0, "SUCCESS"), // Left
list); // Right
}
其中ResultMessage只是具有两个字段（代码/消息）的类，而Customer是具有来自数据库的一堆字段的任何类。
然后，要检查结果，我只是这样做：
void doSomething(){
Pair<ResultMessage, List<Customer>> customerResult = _repository.getCustomers();
if (customerResult.get(ResultMessage.class).getCode() == 0) {
List<Customer> listOfCustomers = customerResult.get(List.class);
System.out.println("do SOMETHING with the list ;) ");
}else {
System.out.println("Raised Error... do nothing!");
}
}
为什么不创建一个WhateverFunctionResult包含您的结果的对象，以及解析这些结果所需的逻辑，然后进行迭代等等。在我看来，要么：
我看到这种问题反复出现。不要害怕创建自己的包含数据和相关功能的容器/结果类。如果您只是简单地将内容传递给HashMap，则您的客户每次想使用结果时都必须将地图分开，并查看内容。
public class MultipleReturnValues {
public MultipleReturnValues() {
}
public static void functionWithSeveralReturnValues(final String[] returnValues) {
returnValues[0] = "return value 1";
returnValues[1] = "return value 2";
}
public static void main(String[] args) {
String[] returnValues = new String[2];
functionWithSeveralReturnValues(returnValues);
System.out.println("returnValues[0] = " + returnValues[0]);
System.out.println("returnValues[1] = " + returnValues[1]);
}
}
这并不能完全回答问题，但是由于此处给出的每种解决方案都有一些缺点，因此我建议尝试稍微重构代码，以便仅返回一个值。
情况一。
您需要方法的内部和外部。为什么不在外部进行计算并将其传递给方法呢？
代替：
[thingA, thingB] = createThings(...); // just a conceptual syntax of method returning two values, not valid in Java
尝试：
thingA = createThingA(...);
thingB = createThingB(thingA, ...);
这应该可以满足您的大多数需求，因为在大多数情况下，一个值先于另一个值创建，您可以将创建值分为两种方法。缺点是，与createThingsB相比，方法有一个额外的参数createThings，并且可能两次将完全相同的参数列表两次传递给不同的方法。
情况二。
有史以来最明显的解决方案和案例一的简化版本。并非总是可能的，但是也许两个值可以彼此独立创建？
代替：
[thingA, thingB] = createThings(...); // see above
尝试：
thingA = createThingA(...);
thingB = createThingB(...);
为了使其更有用，这两种方法可以共享一些共同的逻辑：
public ThingA createThingA(...) {
doCommonThings(); // common logic
// create thing A
}
public ThingB createThingB(...) {
doCommonThings(); // common logic
// create thing B
}
您可以利用HashMap<String, Object>以下
public HashMap<String, Object> yourMethod()
{
.... different logic here
HashMap<String, Object> returnHashMap = new HashMap<String, Object>();
returnHashMap.put("objectA", objectAValue);
returnHashMap.put("myString", myStringValue);
returnHashMap.put("myBoolean", myBooleanValue);
return returnHashMap;
}
然后，在不同范围内调用该方法时，可以将每个对象强制转换回其初始类型：
// call the method
HashMap<String, Object> resultMap = yourMethod();
// fetch the results and cast them
ObjectA objectA = (ObjectA) resultMap.get("objectA");
String myString = (String) resultMap.get("myString");
Boolean myBoolean = (Boolean) resultMap.get("myBoolean");
我一直在使用一种非常基本的方法来处理多重收益问题。它达到了目的，并避免了复杂性。
我把它称为串分离方法
它非常有效，因为它甚至可以返回多种类型的值，例如int，double，char，string等
在这种方法中，我们使用了通常不太可能出现的字符串。我们称其为分隔符。当在函数中使用时，此分隔符将用于分隔各种值
例如，我们将得到最终的返回值，例如intValue分隔符doubleValue分隔符...然后，使用此字符串，我们将检索所需的所有信息，这些信息也可以是不同的类型
以下代码将显示此概念的工作原理
使用的分隔符为！@＃，并返回3个值intVal，doubleVal和stringVal
public class TestMultipleReturns {
public static String multipleVals() {
String result = "";
String separator = "!@#";
int intVal = 5;
// Code to process intVal
double doubleVal = 3.14;
// Code to process doubleVal
String stringVal = "hello";
// Code to process Int intVal
result = intVal + separator + doubleVal + separator + stringVal + separator;
return (result);
}
public static void main(String[] args) {
String res = multipleVals();
int intVal = Integer.parseInt(res.split("!@#")[0]);
// Code to process intVal
double doubleVal = Double.parseDouble(res.split("!@#")[1]);
// Code to process doubleVal
String stringVal = res.split("!@#")[2];
System.out.println(intVal+"\n"+doubleVal+"\n"+stringVal);
}
}
输出值
5
3.14
hello
BUILD SUCCESSFUL (total time: 2 seconds)
在C语言中，您可以通过将指向结果的占位符的指针作为参数传递来实现：
void getShoeAndWaistSizes(int *shoeSize, int *waistSize) {
*shoeSize = 36;
*waistSize = 45;
}
...
int shoeSize, waistSize;
getShoeAndWaistSize(&shoeSize, &waistSize);
int i = shoeSize + waistSize;
让我们在Java中尝试类似的方法。
void getShoeAndWaistSizes(List<Integer> shoeSize, List<Integer> waistSize) {
shoeSize.add(36);
waistSize.add(45);
}
...
List<Integer> shoeSize = new List<>();
List<Integer> waistSize = new List<>();
getShoeAndWaistSizes(shoeSize, waistSize);
int i = shoeSize.get(0) + waistSize.get(0);
List引用和某种查找表的对象。