Restituisce diversi tipi di dati da un metodo in java?

Question

public static void main(String args[]) { 
    myMethod(); // i am calling static method from main() 
} 

.

public static ? myMethod(){ // ? = what should be the return type 
    return value;// is String 
    return index;// is int 
} 

myMethod() torneranno String e int value. Quindi prendi questi valori di ritorno da main() ho trovato la seguente soluzione.

creare una classe chiamata ReturningValues

public class ReturningValues { 
private String value; 
private int index; 

// getters and setters here 
} 

e cambiare myMethod() come segue.

public static ReturningValues myMethod() { 
    ReturningValues rv = new ReturningValues(); 
    rv.setValue("value"); 
    rv.setIndex(12); 
    return rv; 
} 

Ora la mia domanda, c'è un modo più semplice per raggiungere questo obiettivo?

Answer 1

Infine ho pensato che il mio modo fosse migliore da quando il numero di tipi di ritorno è più alto questo tipo di implementazione lo fa nel migliore dei modi.

public static ReturningValues myMethod() { 
ReturningValues rv = new ReturningValues(); 
rv.setValue("value"); 
rv.setIndex(12); 
return rv; 
} 

Answer 2

metodi No. Java possono restituire un solo risultato (void, un primitivo, o di un oggetto), e la creazione di una classe struct tipo come questo è esattamente come lo fai.

Come nota, è spesso possibile per rendere le classi come il vostro ReturningValues immutabile come questo:

public class ReturningValues { 
    public final String value; 
    public final int index; 

    public ReturningValues(String value, int index) { 
     this.value = value; 
     this.index = index; 
    } 
} 

Questo ha il vantaggio che un ReturningValues possono essere passati in giro, come ad esempio tra i thread, senza preoccupazioni ottenere accidentalmente cose fuori sincrono.

Answer 3

Questa può essere una delle soluzioni. Ma la tua soluzione attuale è abbastanza buona. È anche possibile aggiungere nuove variabili e mantenerle pulite, cosa che non può essere eseguita con il codice presente.

private static final int INDEX_OF_STRING_PARAM = 0; 
private static final int INDEX_OF_INT_PARAM = 1; 

public static Object[] myMethod() { 
    Object[] values = new Object[2]; 
    values[INDEX_OF_STRING_PARAM] = "value"; 
    values[INDEX_OF_INT_PARAM] = 12; 
    return values; 
} 

Answer 4

Generalmente se non siete sicuri di quale valore si finirà per tornare, si dovrebbe considerare l'utilizzo di ritorno di tipo come super-classe di tutti i valori di ritorno. In questo caso, dove è necessario restituire String o int, prendere in considerazione la restituzione della classe Object (che è la classe base di tutte le classi definite in java).

Ma attenzione all'opzione dell'istanza in cui si sta chiamando questo metodo. Altrimenti potresti finire a ricevere ClassCastException.

public static void main(String args[]) { 
     Object obj = myMethod(); // i am calling static method from main() which return Object 
    if(obj instanceof String){ 
    // Do something 
    }else(obj instance of Integer) { 
    //do something else 
    } 

Answer 5

l'approccio che hai preso è buono. L'implementazione potrebbe dover essere migliore. Ad esempio ReturningValues ​​dovrebbe essere ben definito e È meglio se è possibile rendere ReturningValues ​​come immutabile.

// this approach is better 
public static ReturningValues myMethod() { 
    ReturningValues rv = new ReturningValues("value", 12); 
    return rv; 
} 


public final class ReturningValues { 
    private final String value; 
    private final int index; 


    public ReturningValues(String value, int index) { 
     this.value = value; 
     this.index = index; 
    } 

} 

O se avete un sacco di coppie di valori chiave è possibile utilizzare HashMap poi

public static Map<String,Object> myMethod() { 
    Map<String,Object> map = new HashMap<String,Object>(); 
    map.put(VALUE, "value"); 
    map.put(INDEX, 12); 
    return Collections.unmodifiableMap(map); // try to use this 
} 

Answer 6

@ruchira ur soluzione è di per sé best.But Penso che se si tratta solo di integer e una stringa che abbiamo può farlo in modo molto facile e semplice ..

class B { 
    public String myfun() {   
     int a=2;   //Integer .. you could use scanner or pass parameters ..i have simply assigned 
     String b="hi";  //String 
     return Integer.toString(a)+","+b; //returnig string and int with "," in middle   
    }  
} 

class A {  
    public static void main(String args[]){ 

     B obj=new B(); // obj of class B with myfun() method 
     String returned[]=obj.myfun().split(","); 
      //splitting integer and string values with "," and storing them in array 
     int b1=Integer.parseInt(returned[0]); //converting first value in array to integer.  
     System.out.println(returned[0]); //printing integer  
     System.out.println(returned[1]); //printing String 
    } 
} 

spero sia stato utile ..:)

Answer 7

Creo vari tipi di reso utilizzando enum. Non viene definito automaticamente. Quella implementazione sembra un modello di fabbrica.

public enum SmartReturn { 

    IntegerType, DoubleType; 

    @SuppressWarnings("unchecked") 
    public <T> T comeback(String value) { 
     switch (this) { 
      case IntegerType: 
       return (T) Integer.valueOf(value); 
      case DoubleType: 
       return (T) Double.valueOf(value); 
      default: 
       return null; 
     } 
    } 
} 

Unit Test:

public class MultipleReturnTypeTest { 

    @Test 
    public void returnIntegerOrString() { 
    Assert.assertTrue(SmartReturn.IntegerType.comeback("1") instanceof Integer); 
    Assert.assertTrue(SmartReturn.DoubleType.comeback("1") instanceof Double); 
    } 

} 

Answer 8

overloading dei metodi può tornare utile qui come:

<code> 
public class myClass 
{ 
    int add(int a, int b) 
    { 
     return (a + b); 
    } 

    String add(String a, String b) 
    { 
     return (c + d); 
    } 

    public static void main(String args[]) 
    { 
     myClass ob1 = new myClass); 
     ob1.add(2, 3); 
     //will return 5 
     ob1.add("Hello, ", "World!"); 
     //will return Hello, World! 
    } 

} 

Answer 9

La classe che state cercando esiste già. Map.Entry:

public static Entry<Integer,String> myMethod(){ 
    return new SimpleEntry<>(12, "value"); 
} 

E più tardi:

Entry<Integer,String> valueAndIndex = myMethod(); 
int index = valueAndIndex.getKey(); 
String value = valueAndIndex.getValue(); 

E 'solo una semplice struttura di dati a due campi che memorizza una chiave e valore. Se devi eseguire elaborazioni speciali, archiviare più di due campi o disporre di altri casi marginali, devi creare la tua classe, ma altrimenti, Map.Entry è una delle classi Java meno utilizzate ed è perfetta per situazioni come queste.

Answer 10

So che è tardi, ma ho pensato che sarebbe stato utile a qualcuno che verrà a cercare una risposta a questo. È possibile utilizzare Bundle per restituire più valori di tipo di dati senza creare un altro metodo. L'ho provato e ha funzionato perfettamente.

In Your MainActivity in cui si chiama il metodo:

Bundle myBundle = method(); 
String myString = myBundle.getString("myS"); 
String myInt = myBundle.getInt("myI"); 

Metodo:

public Bundle method() { 
    mBundle = new Bundle(); 
    String typicalString = "This is String"; 
    Int typicalInt = 1; 
    mBundle.putString("myS", typicalString); 
    mBundle.putInt("myI", typicalInt); 
    return mBundle; 
} 

PS: io non sono sicuro se è OK per implementare un Bundle come questo, ma per me ha funzionato alla perfezione.