Comment retourner plusieurs objets D'une méthode Java?

si vous voulez retourner deux objets, vous voulez généralement retourner un seul objet qui encapsule les deux objets à la place.

vous pouvez retourner une liste des NamedObject objets comme ceci:

public class NamedObject<T> {
  public final String name;
  public final T object;

  public NamedObject(String name, T object) {
    this.name = name;
    this.object = object;
  }
}

, Alors vous pouvez facilement retourner un List<NamedObject<WhateverTypeYouWant>> .

aussi: pourquoi voulez-vous retourner une liste de noms séparés par des virgules au lieu d'un List<String> ? Ou mieux encore, retournez un Map<String,TheObjectType> avec les clés étant les noms et les valeurs des objets (sauf si vos objets ont un ordre spécifié, auquel cas un NavigableMap pourrait être ce que vous voulez.

Si vous savez que vous allez revenir deux objets, vous pouvez également utiliser un générique paire:

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;
    }
};

Modifier plus complètement formé de mise en œuvre de ce qui précède:

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();

    }

}

Notes, principalement autour de rustiness avec Java & generics:

• les deux a et b sont immuables.
• makePair la méthode statique vous aide avec la plaque de chaudière taper, que l'opérateur diamond en Java 7 rendra moins ennuyeux. Il y a du travail à faire pour rendre cela vraiment agréable re: generics, mais il devrait être ok-ish maintenant. (C. F. PECS)
• hashcode et equals sont générés par eclipse.
• la compilation time casting dans la méthode cast est correcte, mais ne semble pas tout à fait correcte.
• Je ne suis pas sûr que les caractères génériques de isInstance soient nécessaires.
• j'ai je viens d'écrire ceci en réponse à des commentaires, à titre d'illustration seulement.

dans le cas où la méthode que vous appelez est privée, ou appelé d'un endroit, essayer

return new Object[]{value1, value2};

l'appelant ressemble à:

Object[] temp=myMethod(parameters);
Type1 value1=(Type1)temp[0];  //For code clarity: temp[0] is not descriptive
Type2 value2=(Type2)temp[1];

L'exemple de la paire par David Hanak n'a aucun avantage syntaxique, et est limité à deux valeurs.

return new Pair<Type1,Type2>(value1, value2);

Et l'appelant ressemble à:

Pair<Type1, Type2> temp=myMethod(parameters);
Type1 value1=temp.a;  //For code clarity: temp.a is not descriptive
Type2 value2=temp.b;

je finis presque toujours par définir les classes n-Tuple quand je code en Java. Par exemple:

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;}
}

je sais que c'est un peu moche, mais ça marche, et tu dois juste définir tes types de tuple une fois. Les Tuples sont quelque chose qui manque vraiment à Java.

EDIT: L'exemple de David Hanak est plus élégant, car il évite de définir getters et garde toujours l'objet immuable.

vous pouvez utiliser l'une des façons suivantes:

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) Utilisant Array

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) Utilisant 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) Utilisant 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) à l'Aide de votre conteneur personnalisé de classe

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) utilisant 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) utilisant paire de Apache Commons

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());
}

avant Java 5, je suis d'accord que la solution Map n'est pas idéale. Cela ne vous permettrait pas de vérifier les types de temps de compilation, ce qui peut causer des problèmes à l'exécution. Cependant, avec Java 5, nous avons des Types génériques.

donc votre méthode pourrait ressembler à ceci:

public Map<String, MyType> doStuff();

MyType bien sûr, étant le type d'objet que vous retournez.

en gros, je pense que retourner une carte est la bonne solution dans ce cas parce que c'est exactement ce que vous voulez retourner - un mappage d'une chaîne Vers un objet.

nous devrions oublier les petites efficacités, disons environ 97% du temps: l'optimisation prématurée est la racine de tout mal.

D. Knuth

alternativement, dans les situations où je veux retourner un certain nombre de choses d'une méthode, je vais parfois utiliser un mécanisme de rappel au lieu d'un conteneur. Cela fonctionne très bien dans les situations où je ne peux pas spécifier à l'avance combien d'objets seront générés.

Avec votre problème particulier, il ressemblerait à quelque chose comme ceci:

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 );
    }
}

en ce qui concerne la question des valeurs de retour multiples en général, j'utilise habituellement une petite classe helper qui enveloppe une valeur de retour simple et est passé comme paramètre à la méthode:

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; }
}

(pour les types de données primitifs, j'utilise des variations mineures pour stocker directement la valeur)

une méthode qui veut retourner plusieurs valeurs serait alors déclarée comme suit:

public void methodThatReturnsTwoValues(ReturnParameter<ClassA> nameForFirstValueToReturn, ReturnParameter<ClassB> nameForSecondValueToReturn) {
    //...
    nameForFirstValueToReturn.set("...");
    nameForSecondValueToReturn.set("...");
    //...
}

peut - être le principal inconvénient est que l'appelant doit préparer les objets de retour à l'avance au cas où il veut les utiliser (et la méthode devrait vérifier les pointeurs null)

ReturnParameter<ClassA> nameForFirstValue = new ReturnParameter<ClassA>();
ReturnParameter<ClassB> nameForSecondValue = new ReturnParameter<ClassB>();
methodThatReturnsTwoValues(nameForFirstValue, nameForSecondValue);

avantages (par rapport aux autres solutions proposées):

• vous n'avez pas à créer une déclaration de classe spéciale pour les méthodes individuelles et ses types de déclaration
• les paramètres obtiennent un nom et sont donc plus faciles à différencier en regardant la méthode signature
• type de sécurité pour chaque paramètre

utilisation de L'objet D'entrée suivant Exemple:

public Entry<A,B> methodname(arg)
{
.......

return new AbstractMap.simpleEntry<A,B>(instanceOfA,instanceOfB);
}

toutes les solutions possibles seront une kludge (comme les objets container, votre idée HashMap, "valeurs de retour multiples" comme réalisé via des tableaux). Je recommande de régénérer la liste séparée par une virgule de la liste retournée. Le code sera beaucoup plus propre.

Apache Commons a tuple et triple pour cela:

• ImmutablePair<L,R> une paire immuable constituée de deux objets élément.
• ImmutableTriple<L,M,R> un triple immuable composé de trois éléments d'Objet.
• MutablePair<L,R> une paire mutable composée de deux éléments d'Objet.
• MutableTriple<L,M,R> Un triple mutable composé de trois éléments Objet.
• Pair<L,R> Une paire composée de deux éléments.
• Triple<L,M,R> un triple composé de trois éléments.

Source: https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/tuple/package-summary.html

Alors que dans votre cas, le commentaire peut être une bonne façon d'aller, dans Android, vous pouvez utiliser Pair . Simplement

return new Pair<>(yourList, yourCommaSeparatedValues);

comme je le vois Il ya vraiment trois choix ici et la solution dépend du contexte. Vous pouvez choisir d'implémenter la construction du nom dans la méthode qui produit la liste. C'est le choix que vous avez choisi, mais je ne pense pas que c'est le meilleur. Vous créez un couplage dans la méthode producer avec la méthode Consumer qui n'a pas besoin d'exister. Il se peut que d'autres appelants n'aient pas besoin de renseignements supplémentaires et vous calculeriez des renseignements supplémentaires pour ces appelants.

alternativement, vous pouvez demander à la méthode d'appel de calculer le nom. S'il n'y a qu'un seul interlocuteur qui a besoin de cette information, vous pouvez vous arrêter là. Vous n'avez aucune dépendance supplémentaire et bien qu'il y ait un petit calcul supplémentaire impliqué, vous avez évité de rendre votre méthode de construction trop spécifique. C'est un bon compromis.

enfin, vous pourriez avoir la liste elle-même être responsable de la création du nom. C'est la route que je suivrais si le le calcul doit être fait par plus d'un appelant. Je pense que cela met la responsabilité de la création des noms avec la classe qui est la plus étroitement liée aux objets eux-mêmes.

dans ce dernier cas, ma solution serait de créer une classe de liste spécialisée qui renvoie une chaîne séparée par des virgules des noms des objets qu'elle contient. Rendre la classe assez intelligente pour qu'elle construise la chaîne de noms à la volée lorsque les objets y sont ajoutés et supprimés. Puis retournez une instance de cette liste et appelez la méthode de génération de noms si nécessaire. Bien qu'il puisse être presque aussi efficace (et plus simple) de simplement retarder le calcul des noms jusqu'à la première fois que la méthode est appelée et stocker alors (chargement paresseux). Si vous ajoutez/supprimez un objet, vous n'avez qu'à supprimer la valeur calculée et la faire recalculer lors du prochain appel.

peut faire quelque chose comme un tuple en langage dynamique (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]);
}
}

et utiliser comme ceci

public Tuple returnMultiValues(){
   return Tuple._t(new ArrayList(),new HashMap())
}


Tuple t = returnMultiValues();
ArrayList list = t.at(0,ArrayList.class);

j'ai suivi une approche similaire à celle décrite dans les autres réponses avec quelques retouches basées sur l'exigence que j'avais, fondamentalement j'ai créé les classes suivantes (juste au cas où, tout est 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);
    }
}

alors, mon exigence était simple, dans la classe de dépôt qui atteint la base de données, pour les méthodes Get que de récupérer des données à partir de la base de données, je dois vérifier si elle a échoué ou réussir, puis, si réussir, je devais jouer avec la liste de retour, si échoué, arrêtez l'exécution et prévenez l'erreur.

Ainsi, par exemple, mes méthodes sont comme ceci:

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
}

où ResultMessage est juste une classe avec deux champs (code/message) et Client est n'importe quelle classe avec un tas de champs qui vient de la DB.

ensuite, pour vérifier le résultat je fais juste ceci:

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!");
    }
}

Keep it simple et de créer une classe pour plusieurs situation. Cet exemple accepte un ArrayList et un texte de message à partir d'un databasehelper getInfo.

où vous appelez la routine qui retourne des valeurs multiples vous code:

multResult res = mydb.getInfo(); 

dans la routine getInfo vous code:

ArrayList<String> list= new ArrayList<String>();
add values to the list...
return new multResult("the message", list);

et définir une classe multResult avec:

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;
}

}

dans C++ (STL) il y a une classe de paire pour regrouper deux objets. En Java Generics une classe de paire n'est pas disponible, bien qu'il y ait quelque demande pour elle. Vous pouvez facilement mettre en œuvre vous-même.

je suis d'accord cependant avec d'autres réponses que si vous devez retourner deux ou plusieurs objets d'une méthode, il serait préférable de les encapsuler dans une classe.

pourquoi ne pas créer un objet WhateverFunctionResult qui contient vos résultats, et la logique nécessaire pour analyser ces résultats, itérer ensuite, etc. Il me semble que soit:

1. ces objets de résultats sont intimement liés / liés et appartiennent ensemble, ou:
2. ils ne sont pas liés, dans ce cas votre fonction n'est pas bien définie en termes de ce qu'elle essaie de faire (c.-à-d. faire deux choses différentes)

je vois ce genre de problème apparaître encore et encore. N'ayez pas peur de créer vos propres classes de conteneurs/résultats qui contiennent les données et les fonctionnalités associées pour gérer cela. Si vous passez simplement la substance dans un HashMap ou similaire, alors vos clients doivent tirer cette carte et grok le contenu chaque fois qu'ils veulent utiliser les résultats.

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]);
    }

}

ce n'est pas exactement répondre à la question, mais puisque chaque solution donnée ici a quelques inconvénients, je suggère d'essayer de reformuler votre code un peu pour que vous ayez besoin de retourner une seule valeur.

Cas.

Vous avez besoin de quelque chose à l'intérieur comme à l'extérieur de votre méthode. Pourquoi ne pas le calculer à l'extérieur et de le passer à la méthode?

au lieu de:

[thingA, thingB] = createThings(...);  // just a conceptual syntax of method returning two values, not valid in Java

, Essayez:

thingA = createThingA(...);
thingB = createThingB(thingA, ...);

cela devrait couvrir la plupart de vos besoins, car dans la plupart des situations une valeur est créée avant l'autre et vous pouvez les diviser en les créant de deux façons. L'inconvénient est que la méthode createThingsB a un paramètre supplémentaire par rapport à createThings , et peut-être vous passez exactement la même Liste de paramètres deux fois à des méthodes différentes.

deuxième affaire.

la solution la plus évidente et une version simplifiée du premier cas. Ce n'est pas toujours possible, mais peut-être que les deux valeurs peuvent être créées indépendamment l'une de l'autre?

au lieu de:

[thingA, thingB] = createThings(...);  // see above

, Essayez:

thingA = createThingA(...);
thingB = createThingB(...);

pour le rendre plus utile, ces deux méthodes peuvent partager une logique commune:

public ThingA createThingA(...) {
    doCommonThings(); // common logic
    // create thing A
}
public ThingB createThingB(...) {
    doCommonThings(); // common logic
    // create thing B
}

passez une liste à votre méthode et peuplez-la, puis retournez la chaîne avec les noms, comme ceci:

public String buildList(List<?> list) {
    list.add(1);
    list.add(2);
    list.add(3);
    return "something,something,something,dark side";
}

alors appelez ça comme ça:

List<?> values = new ArrayList<?>();
String names = buildList(values);

j'ai utilisé une approche très basique pour traiter les problèmes de déclarations multiples. Il sert, et évite la complexité.

je l'appelle le string separator Approche

et il est efficace car il peut même retourner des valeurs de plusieurs Types par exemple int, double, char, chaîne etc

Dans cette approche, nous faire une utilisation d'une chaîne de caractères qui est très peu probable de se produire généralement. On appelle ça un séparateur. Ce séparateur serait utilisé pour séparer diverses valeurs lorsqu'il est utilisé dans une fonction

par exemple, nous aurons notre déclaration finale comme (par exemple) séparateur de double valeur du séparateur intValue... Et puis en utilisant cette chaîne, nous allons récupérer toutes les informations nécessaires, qui peuvent être de types différents ainsi

le code suivant indiquera le fonctionnement de ce concept

le séparateur utilisé est !@ # et 3 valeurs sont retournées intVal,doubleVal et 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);
            }
        }

sortie

5
3.14
hello
BUILD SUCCESSFUL (total time: 2 seconds)

en C, vous le feriez en passant des pointeurs aux placeholders pour les résultats comme arguments:

void getShoeAndWaistSizes(int *shoeSize, int *waistSize) {
    *shoeSize = 36;
    *waistSize = 45;
}
...
int shoeSize, waistSize;
getShoeAndWaistSize(&shoeSize, &waistSize);
int i = shoeSize + waistSize;

essayons quelque chose de similaire, en 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);

PASSER UN HACHAGE DANS LA MÉTHODE ET LE PEUPLER......

public void buildResponse(Chaîne de données, la Carte-réponse);