C# – Szövegek kezelése


C# nyelvben a szövegek tárolására és kezelésére string (System.String) és System.Text.StringBuilder típusú objektumokat használjuk. A String típusú változókban tárolt szöveg nem változtatható meg, ellentétben a StringBuilder típusú objektumokkal, melyekben lévő szöveg módosítható. További szövegkezelő osztályokat találunk a System.Text és a System.Text.RegularExpressions névterületeken.

A String osztály

A String osztály (illetve a neki megfelelő string típus) unicode kódolású szöveg tárolására használható, azonban a tárolt szöveg nem módosítható. String típusú objektumot többféleképpen is létrehozhatunk. Nézzük meg ezt részletesebben!

  • Stringliterállal inicializálva.

string szoveg = “Digitális kultúra”;

  • Karaktertömbből a teljes tömböt felhasználva, vagy a tömb adott indexű elemétől, adott darabszámú karakterének segítségével.

char[] tomb = {‘a’,’b’,’c’,’d’,’e’};
string str1 = new string(tomb);
string str2 = new string(tomb,1,3);
Console.WriteLine(str1); //abcde
Console.Write(str2); //bcd

  • Adott karakter adott számú ismétlésével.

string str = new string(‘A’, 10);
Console.Write(str); //AAAAAAAAAA

  • Az értékadás (=) során új objektum jön létre a megadott, új tartalommal. A += művelet végrehajtását követően az új karaktersorozat objektum tartalma a régi szöveg összefűzve a jobb oldali operandussal.

string str;
tr = “Digitális “;
str += “kultúra”;
Console.Write(str); //Digitális kultúra

  • A == és a != relációs műveletek nem a referenciákat, hanem a szövegtartalmakat hasonlítják össze string típusú változók esetén (más reláció nem használható).

string str1 = “alma”;
string str2 = “körte”;
string str3 = “alma”;

bool hasonlit1 = str1 == str2;
bool hasonlit2 = str1 == str3;
bool hasonlit3 = str1 != str2;

Console.WriteLine(hasonlit1); //False
Console.WriteLine(hasonlit2); //True
Console.WriteLine(hasonlit3); //True

  • Az indexelés operátorával a sztring karaktereit egyenként is kiolvashatjuk. Az első karakter sorszáma 0, míg az utolsóé Length-1 (hossza-1).

string str = “Tengerkék”;
string uj_string = string.Empty; //üres legyen
uj_string += str[3]; //a negyedik karaktert választjuk

Console.Write(uj_string); //g

A String osztály statikus függvényei

Compare( )

Stringeket hasonlíthatunk össze ezzel a lehetőséggel. Egyezés esetén 0-át, különbözőség esetén pedig -1-et kapunk eredményül. Nézzünk egy egyszerű példát!

int hasonlit1 = string.Compare(“Alma”, “Körte”);
int hasonlit2 = string.Compare(“Alma”, “Alma”);

Console.WriteLine(hasonlit1); //-1
Console.Write(hasonlit2); //0

Concat( )

Stringeket egyetlen stringgé fűzhetjük össze. Íme!

string osszefuzott1 = string.Concat(“Indul “, “a “, “görög “, “aludni”);
Console.WriteLine(osszefuzott1); //Indul a görög aludni

string str1 = “A digitális kultúra “;
string str2 = “egy új tantárgy Magyarországon”;
string osszefuzott2 = string.Concat(str1, str2);
Console.Write(osszefuzott2); //A digitális kultúra egy új tantárgy Magyarországon

Join( )

Egy sztringtömb elemeit, az első paraméterben szereplő elválasztó szöveggel egyetlen sztringgé kapcsolja össze.

string[] tomb = {“alma”,”körte”,”szőlő”,”dió”,”szilva”};
string str = string.Join(“, “, tomb); //vesszővel és egy üres karakterrel választja el a szövegeket
Console.WriteLine(str); //alma, körte, szőlő, dió, szilva

string str1 = “Kiránduló”;
string str2 = “hajóval utazunk”;
string str_join = string.Join(” “,str1, str2); //üres karakterekkel választja el a szövegeket
Console.Write(str_join); //Ma délután kiránduló hajóval utazunk

A String osztály nem statikus függvényei

A String osztály nem statikus függvényei az objektumban tárolt szöveggel végeznek műveleteket, azonban soha sem változtatják meg azt.

CompareTo( )

Az objektumban tárolt szöveget összeveti a paraméterben megadott sztringgel. A visszatérési érték 0 (igaz) vagy 1 (hamis) értékkel jelzi a karaktersorozatok viszonyát.

string nev = “Judit”;
int hasonlit1 = nev.CompareTo(“Gábor”);
Console.WriteLine(hasonlit1); //1

int hasonlit2 = nev.CompareTo(“Judit”);
Console.Write(hasonlit2); //0

Equals ( )

Ez a függvény true értékkel jelzi, ha a két objektum ugyanazt a szöveget tárolja.

string nev = “Anna”;
bool osszevet1 = nev.Equals(“Anna”);
Console.WriteLine(osszevet1); //True

bool osszevet2 = nev.Equals(“Tamás”);
Console.Write(osszevet2); //False

StartsWith( ), EndsWith( )

Megvizsgálhatjuk, hogy a tárolt szöveg a megadott szöveggel kezdődik-, illetve végződik-e.

string str = “Digitális kultúra”;
bool kezd = str.StartsWith(“Di”);
bool veg = str.StartsWith(“a”);

Console.WriteLine(kezd); //True
Console.Write(veg); //False

Insert( )

Az objektumban tárolt szövegbe adott pozíciótól beszúrja a megadott szöveget, és az eredményt egy új string objektumban adja vissza. Az alábbi példában az első szöveg 14. pozíciójába beszúrtuk a második szöveget (a számolás továbbra is 0-val kezdődik).

string str1 = “Egyszer volt, nem volt”;
string str2 = “hol “;
string uj_string = str1.Insert(14,str2);

Console.Write(uj_string); //Egyszer volt, hol nem volt
Console.ReadKey();

Remove( )

Az objektumban tárolt szöveg karaktereit törli az adott pozíciótól a szöveg végéig, illetve az adott pozíciótól adott hosszon.

string str = “A digitális kultúra tantárgy egy új tantárgy.”;
string uj_string1 = str.Remove(19); //A 19. pozíciótól az összes karaktert törli
string uj_string2 = str.Remove(11,8); //11. pozíciótól 8 karaktert töröl

Console.WriteLine(uj_string1); //A digitális kultúra
Console.Write(uj_string2); //A digitális tantárgy egy új tantárgy

Replace( )

A tárolt szöveg minden “régi” karakterét, illetve “régi” szövegét a megadott karakterre, illetve sztringre cseréli.

string str1 = “Reméljük, holnap jó idő lesz!”;
string uj_string1 = str1.Replace(“jó”,”szép”);
Console.WriteLine(uj_string1); //Reméljük, holnap szép idő lesz!

string str2 = “gödör”;
string uj_string2 = str2.Replace(‘g’, ‘v’);
Console.Write(uj_string2); //vödör

Substring( )

A tárolt szöveg adott pozíción kezdődő részével tér vissza. Alaphelyzetben a szöveg végéig, a length paraméter megadása esetén pedig a megadott hosszig hozza létre az új sztringet.

string str = “Gyorsforgalmi út”;
string uj_string1 = str.Substring(14); //A 14. pozíciótól végig
string uj_string2 = str.Substring(5,8); //Az 5. pozíciótól 8 karaktert

Console.WriteLine(uj_string1); //út
Console.Write(uj_string2); //forgalmi

ToLower( ), ToUpper( )

A tárolt szöveget kis-, illetve nagybetűssé alakítva hozzák létre az új sztringet.

string str1 = “kerékpár”;
string str2 = “ASZTAL”;
string uj_string1 = str1.ToUpper();
string uj_string2 = str2.ToLower();

Console.WriteLine(uj_string1); //KERÉKPÁR
Console.Write(uj_string2); //sztal

Split( )

Az objektumban tárolt szöveget a megadott tagoló (karakterek vagy sztringek) mentén szétdarabolja, és a részsztringeket tömbben adja vissza.

string str = “országos kerékpár túra”;
string[] tomb = str.Split(‘ ‘);

foreach (var tombelem in tomb)
     {
          Console.WriteLine(tombelem); //országos
                                                                 //kerékpár
                                                                 //túra
     }

Length

Egy string (karakterlánc) hosszát adja meg. A szöveg hosszát elhelyezzük egy egész típusú változóba, és ezt íratjuk ki. Figyelem, a Lenght után nem kell zárójelet írni!

string str = “Folyóvíz”;
int hossz = str.Length;

Console.Write(hossz); //8

A StringBuilder osztály

A System.String osztály objektumaiban tárolt szöveg nem változtatható meg, ezért minden módosítás során új objektum jön létre a memóriában. Ezzel szemben a System.Text.StringBuilder osztály objektumainak szövege módosítható: kitörölhetünk belőle, beszúrhatunk szövegrészletet, és a szöveg hossza is változhat. Most nézzünk meg ebből az osztályból is két függvényt.

Append( )

Az átdefiniált változatokkal bármilyen előre definiált típusú adatot (a karaktertömböt is beleértve) szövegként a sztringhez fűzhetünk. Az alábbi példában felépítünk egy karakterláncot sb néven, majd ebbe egymás után összefűzzük a megadott karakterláncokat (stringeket). Végül kiíratjuk az sb tartalmát.

StringBuilder sb = new StringBuilder();
sb.Append(“Az információ”).Append(” alapegysége”).Append(” az 1 bit.”);

Console.Write(sb); //Az információ alapegysége az 1 bit.

Egy másik példa:

string str1 = “Az óra “;
string str2 = “körbe jár!”;

StringBuilder sb = new StringBuilder();
sb.Append(str1).Append(str2);

Console.Write(sb); //Az óra körbe jár!

AppendLine( )

A megadott szöveg után sorvége jelet is fűz az objektumhoz.

string str1 = “Első sor”;
string str2 = “Második sor”;

StringBuilder sb = new StringBuilder();
sb.AppendLine(str1).AppendLine(str2);

Console.Write(sb); //Első sor
//Második sor