String-initialisatie in Java

1. Inleiding

Java Draad is een van de belangrijkste lessen en we hebben al veel aspecten ervan behandeld in onze Draad-gerelateerde reeks tutorials.

In deze tutorial zullen we ons concentreren op Draad initialisatie in Java.

2. Creatie

Allereerst moeten we onthouden hoe Draads zijn gemaakt in Java.

We kunnen de nieuw trefwoord of de letterlijke syntaxis:

String usingNew = nieuwe String ("baeldung"); String usingLiteral = "baeldung";

En het is ook belangrijk dat we begrijpen hoe Draads worden beheerd in een gespecialiseerde pool.

3. Draad Alleen verklaring

Laten we eerst maar eens verklaren een Draad, zonder expliciet een waarde toe te kennen.

We kunnen dit lokaal doen of als een lidvariabele:

openbare klasse StringInitialization {String fieldString; ongeldig printDeclaredOnlyString () {String localVarString; // System.out.println (localVarString); -> compilatiefout System.out.println (fieldString); }}

Zoals we kunnen zien, als we proberen te gebruiken localVarString voordat we het een waarde geven, krijgen we een compilatiefout. Aan de andere kant zal de console "nul" voor fieldString‘S waarde.

Zien, lidvariabelen worden geïnitialiseerd met een standaardwaarde wanneer de klas is opgebouwd, nul in Draad‘S geval. Maar, we moeten zelf lokale variabelen initialiseren.

Als we geven localVarString een waarde van nul, we zullen zien dat de twee inderdaad nu gelijk zijn:

String localVarString = null; assertEquals (fieldString, localVarString);

4. Draad Initialisatie met behulp van letterlijke teksten

Laten we er nu twee maken Draads met dezelfde letterlijke:

String literalOne = "Baeldung"; String literalTwo = "Baeldung";

We zullen bevestigen dat er slechts één object is gemaakt door de referenties te vergelijken:

assertTrue (literalOne == literalTwo);

De reden hiervoor is terug te voeren op het feit dat Draads worden opgeslagen in een zwembad. literalOne voegt de Draad "Baeldung" naar het zwembad, en letterlijkTwee hergebruikt het.

5. Draad Initialisatie met nieuw

We zullen echter een ander gedrag zien als we de nieuw trefwoord.

String newStringOne = nieuwe String ("Baeldung"); String newStringTwo = nieuwe String ("Baeldung");

Hoewel de waarde van beide Draads zal hetzelfde zijn als eerder, we zullen deze keer naar verschillende objecten moeten:

assertFalse (newStringOne == newStringTwo);

6. Leeg Draads

Laten we nu drie lege maken Draads:

String emptyLiteral = ""; String emptyNewString = nieuwe String (""); String emptyNewStringTwo = nieuwe String ();

Zoals we inmiddels weten, de emptyLiteral wordt toegevoegd aan de Draad zwembad, terwijl de andere twee direct op de hoop gaan.

Hoewel dit niet dezelfde objecten zijn, hebben ze allemaal dezelfde waarde:

assertFalse (emptyLiteral == emptyNewString) assertFalse (emptyLiteral == emptyNewStringTwo) assertFalse (emptyNewString == emptyNewStringTwo) assertEquals (emptyLiteral, emptyNewString); assertEquals (emptyNewString, emptyNewStringTwo);

7. nul Waarden

Laten we tot slot eens kijken hoe null Draads gedragen zich.

Laten we een null declareren en initialiseren Draad:

String nullValue = null;

Als we afdrukken nullwaarde, zouden we het woord "null" zien, zoals we eerder zagen. En als we probeerden methoden aan te roepen op nullwaarde, we zouden een NullPointerException, zoals verwacht.

Maar, waarom wordt "null" afgedrukt? Wat is nul werkelijk?

Welnu, de JVM-specificatie zegt dat nul is de standaardwaarde voor alle verwijzingen, dus het is niet specifiek gekoppeld aan de Draad. En eigenlijk schrijft de specificatie geen concrete waardecodering voor nul.

Dus, waar komt "null" vandaan voor het afdrukken van een Draad dan?

Als we de PrintStream #println implementatie, we zullen zien dat het belt Tekenreeks # waardeVan:

public void println (Object x) {String s = String.valueOf (x); gesynchroniseerd (dit) {print (s); nieuwe lijn(); }}

En, als we kijken naar Tekenreeks # waardeVan, we krijgen ons antwoord:

openbare statische String valueOf (Object obj) {return (obj == null)? "null": obj.toString (); }

En dat is natuurlijk de reden voor "null".

8. Conclusie

In dit artikel hebben we onderzocht Draad initialisatie. We hebben het verschil tussen aangifte en initialisatie uitgelegd. We hebben ook het gebruik van nieuw en het gebruik van de letterlijke syntaxis.

Ten slotte hebben we gekeken naar wat het betekent om een nul waarde voor een Draad, hoe de nul waarde wordt weergegeven in het geheugen, en hoe het eruit ziet als we het afdrukken.

Alle codevoorbeelden die in het artikel worden gebruikt, zijn beschikbaar op Github.