Cordes de Java: “String s = new String(”idiot“);”

String est un spécial intégré dans la classe de la langue. Il est pour le String classe seulement dans lequel vous devez éviter de le dire

String s = new String("Polish");

Parce que le littéral "Polish" est déjà de type String, et vous êtes en train de créer un inutile à l'objet. Pour toute autre classe, en disant

CaseInsensitiveString cis = new CaseInsensitiveString("Polish");

est la bonne (et seulement dans ce cas) une chose à faire.

Les chaînes de caractères sont traités un peu spécialement en java, ils sont immuables, de sorte qu'il est sûr pour eux d'être manipulés par de comptage de référence.

Si vous écrivez

String s = "Polish";
String t = "Polish";

alors s et t en fait référence à un même objet, et s==t renvoie true, pour "==" pour les objets de lecture "est le même objet" (ou peut, de toute façon, je ne suis pas sûr si c'est la partie de la langue spec ou tout simplement un détail de l'implémentation de compilateur-alors peut-être il n'est pas sûr de s'appuyer sur cette) .

Si vous écrivez

String s = new String("Polish");
String t = new String("Polish");

alors s!=t (parce que vous avez explicitement créé une nouvelle chaîne de caractères) même si l'article.est égal à(t) retourne vrai (car la chaîne ajoute ce comportement est égal).

La chose que vous voulez écrire,

CaseInsensitiveString cis = "Polish";

ne peut pas travailler parce que vous êtes en train de penser que les citations sont une sorte de court-circuit du constructeur de votre objet, alors qu'en fait, cela ne fonctionne que pour plain old java.lang.Les chaînes de caractères.

Strings ont la particularité de Java - ils sont immuables, et des constantes de chaîne sont automatiquement transformés en String objets.

Il n'y a aucun moyen pour votre SomeStringClass cis = "value" exemple, pour appliquer à toute autre catégorie.

Ni étendre String, parce qu'il est déclaré comme final, ce qui signifie pas de sous-classement est autorisé.

Vous ne pouvez pas. Des choses en double-guillemets en Java sont spécialement reconnu par le compilateur comme des Chaînes de caractères, et, malheureusement, vous ne pouvez pas remplacer ce (ou de prolonger java.lang.String - il déclaré final).

- Comment puis-je faire CaseInsensitiveString se comportent comme des Cordes de façon à ce que la déclaration ci-dessus est ok (avec et sans extension de Chaîne)? Quel est-il de Chaîne de fait, il est ok pour simplement être en mesure de passer un littéral comme ça? De ma compréhension, il n'existe pas de constructeur de copie" concept en Java droit?

Assez, il a été dit dès le premier point. "Le polonais" est un littéral de chaîne et ne peut être attribuée à la CaseInsentiviveString classe.

Maintenant sur le deuxième point

Bien que vous ne pouvez pas créer de nouveaux littéraux, vous pouvez suivre le premier élément de ce livre pour un "semblable" approche si les affirmations suivantes sont vraies:

    //Lets test the insensitiveness
    CaseInsensitiveString cis5 = CaseInsensitiveString.valueOf("sOmEtHiNg");
    CaseInsensitiveString cis6 = CaseInsensitiveString.valueOf("SoMeThInG");

    assert cis5 == cis6;
    assert cis5.equals(cis6);

Voici le code.

C:\oreyes\samples\java\insensitive>type CaseInsensitiveString.java
import java.util.Map;
import java.util.HashMap;
public final class CaseInsensitiveString  {
private static final Map<String,CaseInsensitiveString> innerPool 
= new HashMap<String,CaseInsensitiveString>();
private final String s;
//Effective Java Item 1: Consider providing static factory methods instead of constructors
public static CaseInsensitiveString valueOf( String s ) {
if ( s == null ) {
return null;
}
String value = s.toLowerCase();
if ( !CaseInsensitiveString.innerPool.containsKey( value ) ) {
CaseInsensitiveString.innerPool.put( value , new CaseInsensitiveString( value ) );
}
return CaseInsensitiveString.innerPool.get( value );   
}
//Class constructor: This creates a new instance each time it is invoked.
public CaseInsensitiveString(String s){
if (s == null) {
throw new NullPointerException();
}         
this.s = s.toLowerCase();
}
public boolean equals( Object other ) {
if ( other instanceof CaseInsensitiveString ) {
CaseInsensitiveString otherInstance = ( CaseInsensitiveString ) other;
return this.s.equals( otherInstance.s );
}
return false;
}
public int hashCode(){
return this.s.hashCode();
}

//Test de la classe à l'aide de "faire valoir" mot-clé

    public static void main( String [] args ) {
//Creating two different objects as in new String("Polish") == new String("Polish") is false
CaseInsensitiveString cis1 = new CaseInsensitiveString("Polish");
CaseInsensitiveString cis2 = new CaseInsensitiveString("Polish");
//references cis1 and cis2 points to differents objects.
//so the following is true
assert cis1 !=  cis2;      //Yes they're different
assert cis1.equals(cis2);  //Yes they're equals thanks to the equals method
//Now let's try the valueOf idiom
CaseInsensitiveString cis3 = CaseInsensitiveString.valueOf("Polish");
CaseInsensitiveString cis4 = CaseInsensitiveString.valueOf("Polish");
//References cis3 and cis4 points to same  object.
//so the following is true
assert cis3 == cis4;      //Yes they point to the same object
assert cis3.equals(cis4); //and still equals.
//Lets test the insensitiveness
CaseInsensitiveString cis5 = CaseInsensitiveString.valueOf("sOmEtHiNg");
CaseInsensitiveString cis6 = CaseInsensitiveString.valueOf("SoMeThInG");
assert cis5 == cis6;
assert cis5.equals(cis6);
//Futhermore
CaseInsensitiveString cis7 = CaseInsensitiveString.valueOf("SomethinG");
CaseInsensitiveString cis8 = CaseInsensitiveString.valueOf("someThing");
assert cis8 == cis5 && cis7 == cis6;
assert cis7.equals(cis5) && cis6.equals(cis8);
}
}
C:\oreyes\samples\java\insensitive>javac CaseInsensitiveString.java
C:\oreyes\samples\java\insensitive>java -ea CaseInsensitiveString
C:\oreyes\samples\java\insensitive>

Qui est, de créer un pool interne de CaseInsensitiveString objets, et le retour de la corrensponding exemple à partir de là.

De cette façon, le "==" opérateur retourne vrai pour deux objets de références, ce qui représente la même valeur.

Ceci est utile lorsque des objets semblables sont utilisés très fréquemment et en créant le coût est cher.

La classe string documentation indique que la classe utilise un pool interne

La classe n'est pas complète, quelques questions intéressantes se pose lorsque nous essayons de marcher le contenu de l'objet à la mise en œuvre de la CharSequence interface, mais ce code est assez bon pour montrer comment cet élément dans le Livre pourrait être appliquée.

Il est important de noter qu'en utilisant le internalPool objet, les références ne sont pas libérés et donc pas de garbage collector, et qui peut devenir un problème si beaucoup d'objets sont créés.

Il travaille pour la Chaîne de la classe parce qu'il est utilisé de manière intensive et la piscine est constituée de "internés" objet.

Il fonctionne bien pour la classe Boolean trop, parce qu'il y a seulement deux valeurs possibles.

Et enfin c'est aussi la raison pour laquelle valueOf(int) dans la classe Integer est limitée à -128 à 127 valeurs int.

Juste parce que vous avez le mot String dans votre classe, ne signifie pas que vous obtenez toutes les caractéristiques particulières de l'intégré dans String classe.

CaseInsensitiveString et String sont des objets différents. Vous ne pouvez pas faire:

CaseInsensitiveString cis = "Polish";

parce que "polonais" est une Chaîne de caractères, pas un CaseInsensitiveString. Si la Chaîne étendue CaseInsensitiveString Chaîne, alors vous seriez OK, mais de toute évidence il ne l'est pas.

Et ne vous inquiétez pas à propos de la construction ici, vous ne serez pas en faire des objets inutiles. Si vous regardez le code du constructeur, tout ce qu'il fait c'est de stocker une référence à la chaîne de caractères passée dans. Rien de plus est en cours de création.

Dans la String s = new String("toto") cas c'est de faire quelque chose de différent. Vous êtes le premier de la création de la chaîne littérale "foobar", puis la création d'une copie de celui-ci par la construction d'une nouvelle chaîne d'elle. Il n'y a pas besoin de créer cette copie.

Si j'ai bien compris, votre question signifie pourquoi on ne peut pas créer un objet directement en lui assignant une valeur, permet de ne pas le restreindre à un Wrapper de la classe String en java.

Pour répondre, je dirais simplement, purement langages de Programmation Orientés Objet ont des constructions et il est dit, que tous les littéraux de les écrire, seul, peut être directement transformée en un objet d'un type donné.

Que signifie précisément, si l'interprète voit 3 il sera converti en un objet Integer parce que entier est le type est défini pour ces littéraux.

Si l'interprète voit quelque chose entre guillemets simples, comme "un", il permettra de créer directement un objet de type personnage, vous n'avez pas besoin de spécifier que c'est la langue définit la valeur par défaut de l'objet de type personnage pour elle.

De même, si l'interprète voit quelque chose de "", il sera considéré comme un objet de son type par défaut c'est à dire de la chaîne. C'est du code natif de travail en arrière-plan.

Grâce à MIT la vidéo cours magistral 6.00 où j'ai eu l'allusion à cette réponse.

Tout d'abord, vous ne pouvez pas faire une classe qui étend la classe de Chaîne, parce que String est une classe finale. Java et de gérer les Chaînes de caractères différent de celui des autres classes, donc uniquement avec de la Ficelle que vous pouvez faire

String s = "Polish";

Mais de pentecôte de votre classe, vous devez appeler le constructeur. Donc, que le code est bien.

Dans la plupart des versions du JDK, les deux versions sera le même:

String s = new String("idiot");

String s = "N'est plus ridicule";

Parce que les chaînes sont immuables, le compilateur gère une liste de constantes de chaîne et si vous essayez de faire une nouvelle on va d'abord vérifier si la chaîne est déjà défini. Si c'est une référence à l'actuel immuable la chaîne renvoyée est.

À préciser - quand vous dites "String s =" vous êtes la définition d'une nouvelle variable qui prend de la place sur la pile, puis si vous dites "Non plus idiot" ou de new String("idiot") exactement la même chose se produit - une nouvelle chaîne constante est compilé dans votre application et les points de référence pour qui.

Je ne vois pas la distinction ici. Cependant, pour votre propre classe, qui n'est pas immuable, ce comportement est hors de propos et vous devez appeler votre constructeur.

Mise à JOUR: j'ai eu tort!
Basée sur une baisse de vote et de commentaire ci-joints j'ai testé ce et de réaliser que ma compréhension est erronée - new String("Idiot"), en effet, créer une nouvelle chaîne plutôt que de réutiliser l'existant. Je ne sais pas pourquoi cela serait, quel est l'avantage?) mais le code parle plus fort que les mots!

C'est une loi fondamentale que les Chaînes de caractères en java sont immuables et sensibles à la casse.

Java crée un objet String pour chaque littéral de chaîne que vous utilisez dans votre code. Tout moment "" est utilisé, il est le même que l'appel à la new String().

Les chaînes de caractères sont des données complexes que simplement "agissent comme des données primitifs. Les littéraux de chaîne sont en fait des objets, même si nous faisons semblant qu'ils sont primitifs littéraux, comme 6, 6.0, 'c', etc. Ainsi, la Chaîne "littérale" "text" renvoie un nouvel objet de type String avec la valeur char[] value = {'t','e','x','t}. Par conséquent, l'appel

new String("text"); 

est en fait ressemble à l'appel de

new String(new String(new char[]{'t','e','x','t'}));

Espérons-le, à partir d'ici, vous pouvez voir pourquoi votre manuel considère cette redondance.

Pour référence, voici la mise en œuvre de la Chaîne: http://www.docjar.com/html/api/java/lang/String.java.html

C'est un plaisir de lire et pourrait inspirer d'une idée. Il est également idéal pour les débutants à lire et à essayer de comprendre, comme le code montre très professionnelle et de la convention-code compatible.

Une autre bonne référence est le Java tutoriel sur les Chaînes:
http://docs.oracle.com/javase/tutorial/java/data/strings.html