Gemaksklassen voor het werken met strings in Java

1. StringTokenizerklasse

En nu een paar meer voorkomende scenario's met betrekking tot het werken met tekenreeksen. Hoe splits je een string in meerdere delen? Er zijn verschillende manieren om dit te doen.

split()methode

De eerste manier om een ​​string in meerdere delen te splitsen is door de split()methode te gebruiken. Een reguliere expressie die een speciale begrenzende tekenreeks definieert, moet als argument worden doorgegeven. Je leert wat een reguliere expressie is in de Java Multithreading- zoektocht.

Voorbeeld:

String str = "Good news everyone!";
String[] strings = str.split("ne");
System.out.println(Arrays.toString(strings));

["Good ", "ws everyo", "!"]

Eenvoudig, maar soms is deze aanpak overdreven. Als er veel scheidingstekens zijn (bijvoorbeeld spaties, tekens voor nieuwe regels, tabs, punten), dan moet u een vrij complexe reguliere expressie maken. Het is moeilijk te lezen en daarom moeilijk te wijzigen.

StringTokenizerklas

Java heeft een speciale klasse wiens taak het is om een ​​string op te splitsen in substrings.

Deze klasse gebruikt geen reguliere expressies: in plaats daarvan geeft u gewoon een string door die bestaat uit scheidingstekens. Het voordeel van deze benadering is dat de hele reeks niet in één keer in stukken wordt gebroken, maar in plaats daarvan stap voor stap van het begin naar het einde wordt verplaatst.

De klasse heeft een constructor en twee belangrijke methoden. We geven de constructor een tekenreeks door die we in delen splitsen, en een tekenreeks die bestaat uit een reeks begrenzingstekens.

String nextToken()

boolean hasMoreTokens()

Deze klasse doet op de een of andere manier denken aan de klasse Scanner, die ook methoden nextLine()en heeft hasNextLine().

U kunt een StringTokenizerobject maken met deze opdracht:

StringTokenizer name = new StringTokenizer(string, delimiters);

Waar stringis de string die in delen moet worden verdeeld. En delimitersis een tekenreeks en elk teken erin wordt behandeld als een scheidingsteken. Voorbeeld:

String str = "Good news everyone!";

StringTokenizer tokenizer = new StringTokenizer(str,"ne");
while (tokenizer.hasMoreTokens())
{
   String token = tokenizer.nextToken();
   System.out.println(token);
}

Good 
ws 
v
ryo
!

Merk op dat elk teken in de tekenreeks die als tweede tekenreeks aan de StringTokenizerconstructor wordt doorgegeven, wordt beschouwd als een scheidingsteken.

2. String.format()methode en StringFormatterklasse

Een andere interessante methode van de klasse String is format().

Stel dat u verschillende variabelen hebt die gegevens opslaan. Hoe geef je ze in één regel op het scherm weer? We hebben bijvoorbeeld enkele gegevens (linkerkolom) en gewenste uitvoer (rechterkolom):

String name = "Amigo";
int age = 12;
String friend = "Diego";
int weight = 200;

User = {name: Amigo, age: 12 years, friend: Diego, weight: 200 kg.}

Je code ziet er waarschijnlijk ongeveer zo uit:

String name = "Amigo";
int age = 12;
String friend = "Diego";
int weight = 200;

System.out.println("User = {name: " + name + ", age:" + age + " years, friend: " + friend+", weight: " + weight + " kg.}");

Dergelijke code is niet erg leesbaar. En als de variabelenamen langer waren, zou de code nog moeilijker worden:

class User {
    ......
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public List<String> getFriends() {
        return friends;
    }

    public ExtraInformation getExtraInformation() {
        return extraInformation;
    }
}

User user = new User();

System.out.println("User = {name: " + user.getName() + ", age:" + user.getAge() + " years, friend: " + user.getFriends().get(0) + ", weight: " + user.getExtraInformation().getWeight() + " kg.}");

Niet erg leesbaar, is het?

Maar dit is een veel voorkomende situatie in real-world programma's, dus ik wil je vertellen over een manier om deze code eenvoudiger en beknopter te schrijven.

String.format

De klasse String heeft een statische format()methode: hiermee kunt u een patroon specificeren voor het samenstellen van een string met gegevens. Het algemene uiterlijk van de opdracht is als volgt:

String name = String.format(pattern, parameters);

Voorbeeld:

String.format("Age=%d, Name=%s", age, name);

Age=12, Name=Amigo

String.format("Width=%d, Height=%d", width, height);

Width=20, Height=10

String.format("Fullname=%s", name);

Fullname=Diego

De format()eerste parameter van de methode is een opmaaktekenreeks die alle gewenste tekst bevat, samen met speciale tekens die opmaakspecificaties worden genoemd (zoals %den %s) op de plaatsen waar u gegevens moet invoegen.

De format()methode vervangt deze %sen %dformaatspecificaties door de parameters die volgen op de formaattekenreeks in de parameterlijst. Als we een string willen invoegen, schrijven we %s. Als we een getal willen invoegen, dan is de formaatspecificatie %d. Voorbeeld:

String s = String.format("a=%d, b=%d, c=%d", 1, 4, 3);

Hier is een korte lijst met indelingsspecificaties die kunnen worden gebruikt in de indelingsreeks:

%s

%d

%f

%b

%c

%t

%%

Deze specifiers geven het type data aan, maar er zijn ook specifiers die de volgorde van de data aangeven. Om een ​​argument op nummer te krijgen (de nummering begint bij één), moet u " " schrijven in plaats van " ". Voorbeeld:%1$d%d

String s = String.format("a=%3$d, b=%2$d, c=%d", 11, 12, 13);

%3$dkrijgt het 3e argument, %2$dkrijgt het tweede argument en %dkrijgt het allereerste argument. De %sen %dformaatspecificaties verwijzen naar argumenten, ongeacht de specificatie zoals %3$dof%2$s

3. Stringpool

Elke tekenreeks die in code is gespecificeerd als een letterlijke tekenreeks, wordt opgeslagen in een geheugengebied dat de wordt genoemd StringPoolterwijl het programma wordt uitgevoerd. StringPoolis een speciale array voor het opslaan van strings. Het doel is om stringopslag te optimaliseren:

Ten eerste moeten de strings die in de code zijn gespecificeerd ergens worden opgeslagen, toch? Code bestaat uit opdrachten, maar gegevens (vooral grote strings) moeten apart van de code in het geheugen worden opgeslagen. Alleen verwijzingen naar tekenreeksobjecten verschijnen in code.

Ten tweede moeten alle identieke letterlijke tekenreeksen slechts één keer in het geheugen worden opgeslagen. En dat is precies hoe het werkt. Wanneer uw klassecode wordt geladen door de Java-machine, worden alle letterlijke tekenreeksen toegevoegd aan de StringPoolals ze er nog niet zijn. Als ze er al zijn, gebruiken we gewoon een tekenreeksreferentie uit de StringPool.

Dienovereenkomstig, als u dezelfde letterlijke waarde toewijst aan verschillende Stringvariabelen in uw code, dan zullen deze variabelen dezelfde referentie bevatten. Er wordt een letterlijke waarde toegevoegd aan de StringPoolenige keer. In alle andere gevallen krijgt de code een verwijzing naar de string die al in het StringPool.

Hier is ongeveer hoe het werkt:

String a = "Hello";
String b = "Hello";
String c = "Bye";

String[] pool = {"Hello", "Bye"};
a = pool[0];
b = pool[0];
c = pool[1];

Daarom zullen de variabelen aen bdezelfde referenties opslaan.

intern()methode

En het beste is dat je programmatisch elke string aan het StringPool. Om dit te doen, hoef je alleen maar de methode Stringvan de variabele aan te roepen intern().

De intern()methode voegt de string toe aan de StringPoolals deze er nog niet is, en retourneert een verwijzing naar de string in de StringPool.

Als twee identieke strings worden toegevoegd aan de StringPoolmet behulp van de intern()methode, retourneert de methode dezelfde referentie. Dit kan worden gebruikt om tekenreeksen op basis van referentie te vergelijken. Voorbeeld:

String a = new String("Hello");
String b = new String("Hello");
System.out.println(a == b);

false

String a = new String("Hello");
String b = new String("Hello");

String t1 = a.intern();
String t2 = b.intern();
System.out.println(a == b);
System.out.println(t1 == t2);

false
true

Het is onwaarschijnlijk dat je deze methode vaak gebruikt, maar mensen vragen er graag naar in interviews . Het is dus beter om er iets van te weten dan om het niet te weten.