Kihagyás

Sztringek

Az előadás videója elérhető a itt.

A sztring manipulációs tevékenységek vitathatatlanul a leggyakoribb tevékenységek a számítógépes programokban, így nagyon fontos, hogy alaposabban megismerkedjünk ezzel a típussal, illetve megvalósításával.

Karakterek sorozata

A String osztály megvalósítja a CharSequence interface-t, amely karakter értékek sorozatát jelképezi. Fontos azonban, hogy minden String objektum, és nem karaktertömb. A CharSequence interface leírása alapján minden sztringre le lehet kérni annak hosszát (int length()), illetve adott indexen levő karakterének értékét (char charAt(int)), és vissza lehet adni adott indexek közötti karakterek sorozatát (CharSequence subSequence(int start, int end)).

CharSequence interface-t nemcsak a String, de a CharBuffer, Segment, StringBuffer, StringBuilder osztályok is megvalósítják, így a fenti metódusok ezeknél is értelemzettek lesznek.

Sztringek

Ha egy kicsit elmerengünk a String JDK dokumentációjában, akkor talán feltűnhet, hogy valamennyi művelete a Stringnek magát az eredeti objektumot nem bántja, minden esetben egy új String jön létre az aktuális módosítás eredményeként.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
public class StringPelda {
  public static void main(String[] args) {
    String str1 = "abc";
    // ekvivalens az alábbival:
    char data[] = {'a', 'b', 'c'};
    String str2 = new String(data);
    // további példák:
    System.out.println("abc");
    String cde = "cde";
    System.out.println("abc" + cde);
    String c = "abc".substring(2,3); // -> "c" (2)--(3-1) karakterek
    System.out.println(c);
    String d = cde.substring(1,2);   // -> "d" (1)--(2-1) karakterek
    System.out.println(d);
  }
}

Kimenet

abc

abccde

c

d

Amíg módosítani nem szeretnénk a Stringet, az teljesen úgyanúgy működik, mint egy karakter sorozat. Nagyon sok konstruktort definiáltak a String osztályhoz, de a leggyakoribban használt talán az, ami egy karakter tömb alapján hozza létre a Stringet. Mivel a String az egyik leggyakrabban használt osztály, így a nyelv az automatikus konstruktorhívás lehetőségét is felkínálja, azaz new hívás nélkül, egyszerű értékadással is inicializálható a String egy karaktersorozattal, vagy sztring konstanssal.

Azonban a Stringek annyival többek már így is a karakter sorozatoknál, hogy értelmezve van rajtuk a "+" operátor, aminek hatására két sztring összefűzhető, és eredményül keletkezik egy harmadik String. Ez a "+" operátor igen érdekes olyan értelemben, hogy a Java a String kivételével nem teszi lehetővé ennek az operátornak a felüldefiniálását.

1
2
3
4
5
6
7
public class Concatenation {
    public static void main(String[] args) {
        String def = "def";
        String s = "abc" + def + "ghi" + 47;
        System.out.println(s);
    }
}

Kimenet

abcdefghi47

A String osztály számos metódussal próbálja könnyíteni a Stringekkel kapcsolatos műveletek elvégzését. A leggyakoribb metódusok a következők:

Metódus neve Leírása
length() visszaadja az aktuális sztring hosszát
charAt() visszaadja a sztring adott pozícióján levő karaktert
getChars() az aktuális sztring adott karakterétől adott karakteréig bemásolja a cél karaktertömb adott indexű elemétől kezdve
toCharArray() karaktertömbként adja vissza az aktuális sztringe
equals(), equalsIgnoreCase() összehasonlítja az aktuális sztringet a paraméterben kapottal;
u.a. csak a kis- és nagybetűk közötti eltéréseket figyelmen kívül hagyja
compareTo(),
compareToIgnoreCase()
összehasonlítja az aktuális sztringgel a paraméterben kapott sztringet lexikografikusan;
u.a, mint az előző, csak a kis- és nagybetűk közötti eltérést nem veszi figyelembe
contains() visszatér true-val, ha a paraméterben kapott karakter sorozatot tartalmazza a sztring
regionMatches() összehasonlítja az aktuális és a paraméterben kapott sztringek adott régióit
startsWith(), endsWith() ellenőrzi, hogy az aktuális sztring a paraméterben kapott sztringgel kezdődik, vagy végződik-e
indexOf(), lastIndexOf() visszatér az adott sztringben hol található az első/utolsó előfordulása az adott karakternek
substring() visszaad egy új sztringet, ami az eredeti rész sztringje
replace() visszatér egy új sztringgel, amiben az aktuális sztringben levő adott karaktert lecserél egy másikra
toLowerCase(), toUpperCase() visszaad egy új sztringet, ami az aktuális sztring valamennyi karakterét nagybetűsíti/kisbetűsíti
trim() visszaad egy új sztringet, amiben levágja a String végi whitespace karaktereket
valueOf() az adott paramétert Stringgé konvertálja

Sztring formázás

A C nyelvben megismert sztring formázás kényelmes lehet sokszor. Ez megvalósítható JAVA-ban a String osztály format metódusával, vagy azzal, hogy a PrintStream objektum printf vagy format metódusát hívjuk a kiíráskor.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
public class SimpleFormat {
    public static void main(String[] args) {
        int x = 5;
        double y = 5.332542;
        // The old way:     
        System.out.println("Sor 1: [" + x + " " + y + "]");
        // The new way:     
        System.out.format("Sor 1: [%d %f]\n", x, y);
        // or
        System.out.printf("Row 1: [%d %f]\n", x, y);
    }
}

Kimenet

Sor 1: [5 5.332542]

Sor 1: [5 5.332542]

Sor 1: [5 5.332542]

StringBuilder és StringBuffer

Ahogy láttuk, a String osztály objektumait nem tudjuk megváltoztatni, minden esetben új sztring jön létre, ha valamilyen műveletet végzünk egy konkrét sztringen. Néha azonban előfordul, hogy ez a tulajdonság nem annyira praktikus, és valóban módosítani akarjuk az adott karaktersorozatot. A StringBuilder és StringBuffer osztályok ezt a funkcionalitást biztosítják többek között az append és insert metódusok által. Annyi különbség van köztük, hogy a StringBuilder gyorsabb, de nem szál biztos, ellentétben a StringBufferrel.

Sztringek darabolása

Sztringek feldolgozásakor gyakori az a feladat, hogy egy adott sztringet rész sztringekre bonstunk valamilyen szeparáló karakter mentén. (Például egy csv fájl feldolgozásakor minden sor egy-egy összetett sztring, amiben az egyes elemeket ",", vagy ";" választ el egymástól.)

A Tokenizer osztály segíthet nekünk ebben a darabolásban. A Tokenizer objektum inicializálásakor meg kell adjuk, hogy mely sztringet szeretnénk darabolni, illetve meg kell adjuk a szeparáló karaktert. Ezután a countTokens, hasMoreTokens, valamint nextToken metódusokkal el tudjuk érni a feldarabolt sztring részsztringjeit. (Hasonló megoldást kínál a String osztály split metódusa is egyébként.)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
import java.util.*; 
public class Tokenizer { 
    public static void main(String args[]) { 
        String mydelim = " : "; 
        String mystr = "JAVA : Code : String : Tokenizer : Geeks"; 

        StringTokenizer geeks3 = new StringTokenizer(mystr, mydelim); 
        int count = geeks3.countTokens(); 
        System.out.println("Number of tokens : " + count); 
        for (int i = 0; i <count; i++) 
            System.out.println("token at [" + i + "] : " + geeks3.nextToken()); 
        while (geeks3.hasMoreTokens()) 
            System.out.println(geeks3.nextToken()); 
    } 
}

Kimenet

Number of tokens : 5

token at [0] : JAVA

token at [1] : Code

token at [2] : String

token at [3] : Tokenizer

token at [4] : Geeks

A fenti példa egy kicsit csalfa, valójában a while itt már nem csinál semmit, mivel a nextToken() legfeljebb annyiszor hívható, amennyi darabra vágható a sztring. Ha kikommenteznénk a for ciklust, akkor viszont a while ciklus járná végig a felsorolt elemeket, és while ciklus kiírása érvényesülne.

Sztringek összefűzése

Ha szét tudunk darabolni egy sztringet, akkor persze hasonló módon össze is rakhatunk sztringeket, valamilyen szeparátorral elválasztva a rész sztringeket. Ezt teszi meg nekünk a StringJoiner osztály, ami ezen felül egy elő-, és utótagot is képes az összetett sztringhez illeszteni.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
import java.util.StringJoiner;

class StringJoin {
  public static void main(String[] args) {
    StringJoiner sj = new StringJoiner(";", "prefix-", "-suffix");
    sj.add("Java");
    sj.add("Code"); 
    sj.add("String");
    sj.add("Joiner");
    System.out.println(sj);
  }

Kimenet

prefix-Java;Code;String;Joiner-suffix


Utolsó frissítés: 2021-05-04 07:53:32