Puis-je modifier l'objet String valeur passée à ma méthode?

J'ai trouvé la question suivante Est Java "par référence" ou de "passage par valeur"?.

J'ai presque tout lu de lui, mais ne pouvait pas savoir encore ce que je dois faire si je veux le foo(-) méthode, à modifier mon String's valeur? (peut-être ou pas de référence de trop, il n'est pas question pour moi).

void foo(String errorText){ 
    errorText="bla bla";
}

int main(){ 
    String error="initial"; 
    foo(error); 
    System.out.println(error);
}

Je veux voir bla bla sur la console. Est-il possible?

InformationsquelleAutor merveotesi | 2011-11-21

36

Vous ne pouvez pas modifier la valeur de errorText dans foo que la méthode est déclarée. Même si vous êtes de passage à une référence de la Chaîne errorText en foo, Java Strings sont immuables-vous ne pouvez pas les modifier.

Cependant, vous pouvez utiliser un StringBuffer (ou StringBuilder). Ces classes peuvent être modifiées dans votre foo méthode.
```
public class Test {
    public static void foo(StringBuilder errorText){ 
        errorText.delete(0, errorText.length());
        errorText.append("bla bla");
    }

    public static void main(String[] args) { 
        StringBuilder error=new StringBuilder("initial");
        foo(error); 
        System.out.println(error);
    }
}
```
D'autres solutions sont à utiliser un wrapper de classe (création d'une classe pour tenir votre Chaîne de référence, et changez la référence dans foo), ou tout simplement retourner la chaîne.

InformationsquelleAutor Jack Edmonds

Soit utiliser la valeur de retour de la méthode ou de créer une classe wrapper.

L'ai renvoyer la valeur:

String foo(String errorText){ 
    return "bla bla";
}

int main(){ 
    String error="initial"; 
    error = foo(error); 
    System.out.println(error);
}

Placer la valeur d'un objet:

class StringWrapper {
    private String string;
    public StringWrapper(String s) {
        this.string = s;
    }
    public String getString() {
        return this.string;
    }
    public void setString(String s) {
        this.string = s;
    }
}

void foo(StringWrapper errorText){ 
    errorText.setString("bla bla");
}

int main(){ 
    StringWrapper error=new StringWrapper("initial"); 
    foo(error); 
    System.out.println(error.getString());
}

merci, belle solution

InformationsquelleAutor Erick Robertson

Oui, vous pouvez modifier ce avec l'aide de réflexions, mais c'est contre la règle.

void foo(String errorText) {
    try {
        final Class<String> type = String.class;
        final java.lang.reflect.Field valueField = type.getDeclaredField("value");
        valueField.setAccessible(true);
        valueField.set(errorText, "bla bla".toCharArray());
    } catch (Exception e) {
    }

}

public static void main(String[] args) {
    String error = new String("initial");
    foo(error);
    System.out.println(error);
}

InformationsquelleAutor Saurabh Khare

1

Chaîne de valeurs sont immuables-donc, une fois que vous obtenez une valeur, vous êtes coincé avec elle.

InformationsquelleAutor ryebr3ad
0

Littérale Strings sont spécialement traités par le langage Java; votre code est à peu près équivalent à:
```
void foo(String errorText){ //at this point, errorText refers to the original string
    errorText=new String("bla bla"); //now it refers to a new string
}

int main(){ 
    String error=new String("initial"); //error is a reference to the original string
    foo(error); //pass a *copy* of the reference
    System.out.println(error);
}
```
En d'autres termes, vous êtes simplement en indiquant la référence locale errorText à un autre String objet, ce qui affecte en rien en dehors de la méthode.

Plus généralement, cependant, Strings sont immuables; il n'y a aucun moyen de les modifier.

InformationsquelleAutor Oliver Charlesworth
0

Vous pouvez réattribuer la Chaîne de référence:
```
String foo(String err) {
  return "bla blah"
}

error = foo(error);
```
InformationsquelleAutor sudocode

Vous devez vous connecter pour publier un commentaire.