Praktiske klasser for arbeid med strenger i Java

1. StringTokenizerklasse

Og nå noen flere vanlige scenarier som involverer arbeid med strenger. Hvordan deler du en streng i flere deler? Det er flere måter å gjøre dette på.

split()metode

Den første måten å dele en streng i flere deler er å bruke split()metoden. Et regulært uttrykk som definerer en spesiell avgrensende streng må sendes som et argument. Du vil lære hva et regulært uttrykk er i Java Multithreading- oppdraget.

Eksempel:

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

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

Enkelt, men noen ganger er denne tilnærmingen overdreven. Hvis det er mange skilletegn (for eksempel mellomrom, nylinjetegn, tabulatorer, punktum), må du konstruere et ganske komplekst regulært uttrykk. Det er vanskelig å lese og derfor vanskelig å endre.

StringTokenizerklasse

Java har en spesialklasse hvis hele jobben er å dele en streng i understrenger.

Denne klassen bruker ikke regulære uttrykk: i stedet sender du bare inn en streng som består av skilletegn. Fordelen med denne tilnærmingen er at den ikke bryter hele strengen i stykker på en gang, men i stedet beveger seg fra begynnelse til slutt ett trinn om gangen.

Klassen har en konstruktør og to viktige metoder. Vi sender konstruktøren en streng som vi deler i deler, og en streng som består av et sett med avgrensende tegn.

String nextToken()

boolean hasMoreTokens()

Denne klassen minner på en måte om Scanner-klassen, som også har nextLine()og hasNextLine()metoder.

Du kan lage et StringTokenizerobjekt med denne kommandoen:

StringTokenizer name = new StringTokenizer(string, delimiters);

Hvor stringskal strengen deles i deler. Og delimiterser en streng, og hvert tegn i den behandles som et skilletegn. Eksempel:

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 at hvert tegn i strengen som sendes som den andre strengen til konstruktøren StringTokenizerregnes som en skilletegn.

2. String.format()metode og StringFormatterklasse

En annen interessant metode for String-klassen er format().

La oss si at du har forskjellige variabler som lagrer data. Hvordan viser du dem på skjermen på én linje? For eksempel har vi noen data (venstre kolonne) og ønsket utgang (høyre kolonne):

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

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

Koden din vil sannsynligvis se omtrent slik ut:

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.}");

Slik kode er lite lesbar. Og hvis variabelnavnene var lengre, ville koden blitt enda vanskeligere:

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.}");

Ikke veldig lesbart, er det?

Men dette er en vanlig situasjon i programmer i den virkelige verden, så jeg vil fortelle deg om en måte å skrive denne koden enklere og mer konsist på.

String.format

String-klassen har en statisk format()metode: den lar deg spesifisere et mønster for å sette sammen en streng med data. Det generelle utseendet til kommandoen er som følger:

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

Eksempel:

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

Metodens format()første parameter er en formatstreng som inneholder all ønsket tekst sammen med spesialtegn som kalles formatspesifisatorer (som %dog %s) på de stedene du skal sette inn data.

Metoden format()erstatter disse %sog %dformatspesifikasjonene med parameterne som følger formatstrengen i parameterlisten. Hvis vi vil sette inn en streng, så skriver vi %s. Hvis vi vil sette inn et tall, er formatspesifikasjonen %d. Eksempel:

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

Her er en kort liste over formatspesifikasjoner som kan brukes i formatstrengen:

%s

%d

%f

%b

%c

%t

%%

Disse spesifikasjonene angir typen data, men det finnes også spesifikasjoner som indikerer rekkefølgen på dataene. For å få et argument etter nummeret (nummereringen starter fra én), må du skrive " " i stedet for " ". Eksempel:%1$d%d

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

%3$dvil få det 3. argumentet, %2$dvil få det andre argumentet, og %dvil få det aller første argumentet. Formatspesifikasjonene %sog %drefererer til argumenter uavhengig av spesifikasjoner som %3$deller%2$s

3. Strengebasseng

Hver streng spesifisert i kode som en streng-literal er lagret i et minneområde som kalles mens StringPoolprogrammet kjører. StringPooler en spesiell matrise for lagring av strenger. Formålet er å optimalisere strenglagring:

Først må strengene som er spesifisert i koden lagres et sted, ikke sant? Kode består av kommandoer, men data (spesielt store strenger) må lagres i minnet separat fra koden. Bare referanser til strengobjekter vises i kode.

For det andre må alle identiske strengliteraler bare lagres i minnet én gang. Og det er bare slik det fungerer. Når klassekoden din lastes inn av Java-maskinen, legges alle strenge bokstaver til StringPoolhvis de ikke allerede er der. Hvis de allerede er der, bruker vi ganske enkelt en strengreferanse fra StringPool.

Følgelig, hvis du tilordner samme bokstavelige til flere Stringvariabler i koden din, vil disse variablene inneholde den samme referansen. En bokstavelig vil bli lagt til den StringPooleneste ene. I alle andre tilfeller vil koden få en referanse til strengen som allerede er lastet inn i StringPool.

Slik fungerer det omtrent:

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

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

Det er derfor variablene aog bvil lagre de samme referansene.

intern()metode

Og det beste er at du kan legge til en hvilken som helst streng i StringPool. For å gjøre dette trenger du bare å kalle Stringvariabelens intern()metode.

Metoden intern()vil legge til strengen til StringPoolhvis den ikke allerede er der, og vil returnere en referanse til strengen i StringPool.

Hvis to identiske strenger legges til ved å StringPoolbruke intern()metoden, returnerer metoden den samme referansen. Dette kan brukes til å sammenligne strenger ved referanse. Eksempel:

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

Det er usannsynlig at du bruker denne metoden ofte, men folk elsker å spørre om det i intervjuer . Så det er bedre å vite om det enn å ikke vite.