String-Klasse

• Methoden
• Generieren einer zufälligen Zeichenfolge
• String-Vergleich: equals()oder ==?

Die Klasse wird Stringsehr häufig von Programmierern verwendet und sollte daher sehr gut erlernt werden. Denken Sie daran, dass Klassenobjekte Stringunveränderlich sind. Wenn Sie also denken, dass Sie eine Zeichenfolge ändern, erstellen Sie tatsächlich eine neue Zeichenfolge. Java verfügt über spezielle Klassen StringBuffer, StringBuilderdie Änderungen an einer Zeichenfolge ermöglichen. Die Klassen String, StringBuffer, StringBuildersind im Paket java.lang definiert und stehen automatisch ohne Importdeklaration zur Verfügung. Alle drei Klassen implementieren die Schnittstelle CharSequence. Das Erstellen einer Zeichenfolge ist sehr einfach. Sie können beispielsweise Folgendes tun:

String aboutCat = "Кот - это звучит гордо, а если наступить на хвост, то громко";

Sie können ein Array von Zeichenfolgen erstellen:

String[] cats = {"Васька", „Barsik“, „Mürzik“};

Sie können ein leeres Klassenobjekt erstellen String:

String str = new String();

Sie können eine Zeichenfolge über ein Zeichenarray erstellen:

char[] chars = { 'c', 'a', 't' };
String str = new String(chars);

Es gibt auch einen Konstruktor, mit dem Sie den Bereich eines Zeichenarrays festlegen können. Sie müssen den Anfang des Bereichs und die Anzahl der zu verwendenden Zeichen angeben:

char[] chars = {'c', 'a', 't', 'a', 'm', 'a', 'r', 'a', 'n' };
String str = new String(chars, 0, 3);

Mit den folgenden Konstruktoren können Sie Stringaus einem Klassenobjekt ein Klassenobjekt erstellen:StringBufferStringBuilder

String(StringBuffer ein Objekt_StrBuf)
String(StringBuilder ein Objekt_StrBuild)

Operatoren +und += fürString

In Java bedeutet das Pluszeichen ( +) String-Verkettung, also das Kombinieren von Strings.

String cat = "Кот";
String name = "Васька";
//складываем две строки и пробел между ними, чтобы слова не слиплись
String fullname = cat + " " + name; // получится Кот Васька

Wenn einer der Operanden in einem Ausdruck eine Zeichenfolge enthält, müssen die anderen Operanden ebenfalls Zeichenfolgen sein. Daher kann Java selbst Variablen in eine String-Darstellung umwandeln, auch wenn es sich nicht um Strings handelt.

int digit = 4;
String paws = " лапы";
String aboutcat = digit + paws; // хотя мы складываем число и строку, но все равно получим строку
За кулисами Java за нас преобразовало число 4 в строку "4"

Zeichenfolgen formatieren

Nehmen wir an, wir haben eine String-Ressource:

<string name="aboutcat">У кота по имени Барсик четыре лапы, один хвост. Ему 5 лет</string>

Um diese Zeichenfolge programmgesteuert im Element anzuzeigen TextView, können Sie den Code verwenden:

TextView tvCatsInfo = (TextView)findViewById(R.id.textView1);
tvCatsInfo.setText(R.string.aboutcat);

Stellen Sie sich vor, Sie hätten mehrere Katzen. Selbstverständlich können Sie für jede Katze eine eigene Linie haben. Aber die Linien sind sehr ähnlich, nur die Namen und das Alter ändern sich. Sie können auch die Anzahl der Pfoten und Schwänze ändern (was rauchen Sie?). In solchen Fällen können Sie eine Zeichenfolgenformatierung anwenden. Wir müssen die Wörter bestimmen, die wir ändern, und sie durch einen speziellen Satz von Zeichen ersetzen, die mit einem Prozentzeichen beginnen, dann mit einer um eins aufsteigenden Zahl, dann $sfür Zeichenfolgen oder $dfür Zahlen. Ändern wir also unsere String-Ressource wie folgt:

<string name="aboutcat">У кота по имени %1$s %2$s лапы, %3$s хвост. Ему %4$d лет</string>

Nehmen wir Änderungen am Code vor:

String strBarsik = „Barsik“;
String strPaws = "четыре";
String strTail = "eins";
int year = 5;
String strCats = getResources().getString(R.string.aboutcat);
String strFinal = String.format(strCats, strBarsik, strPaws, strTail, year);
tvCatsInfo.setText(strFinal);

Wenn Sie eine Katze Vaska haben und diese sechs Jahre alt ist, fügen Sie zwei Variablen hinzu und formatieren Sie die Zeile

String strVaska = "Васька";
year = 6;
String strFinal = String.format(strCats, strVaska, strPaws, strTail, year);
tvCatsInfo.setText(strFinal);

Hier ist ein einfaches Formatierungsbeispiel. Denken Sie daran und verwenden Sie es an den richtigen Stellen.

String-Ressource

Es empfiehlt sich, Strings in Ressourcen zu speichern. Der programmgesteuerte Zugriff auf eine String-Ressource erfolgt folgendermaßen:

String catName = getResources().getString(R.string.barsik);

Extrahieren Sie Zeichenfolgen aus Zeichenfolgenarrays in Ressourcen

Nehmen wir an, Sie haben ein String-Array in einer strings.xml- Datei mit dem Namen definiert cats_array. Dann können Sie über Ressourcen wie diese auf Zeilen zugreifen:

Resources res = getResources();
String[] cats = res.getStringArray(R.array.cats_array);

Methoden

public char charAt (int index) Gibt das Zeichen am angegebenen Offset in dieser Zeichenfolge zurück. Der Countdown beginnt bei 0. Es besteht keine Notwendigkeit, negative und nicht vorhandene Werte zu verwenden, seien Sie ernster. Um mehrere Zeichen zu extrahieren, verwenden Sie getChars().

String testString = "Котёнок";
char myChar = testString.charAt(2);
tv.setText(Character.toString(myChar)); // выводит третий символ - т

public int codePointAt(int index) Gibt das Unicode-Zeichen am angegebenen Index zurück

String testString = "Котёнок";
int myChar = testString.codePointAt(3);
tv.setText(String.valueOf(myChar)); // возвращает 1105

public int codePointBefore(int index) Gibt das Unicode-Zeichen zurück, das vor dem angegebenen Index steht

String testString = "Котёнок";
int myChar = testString.codePointBefore(4);
tv.setText(String.valueOf(myChar)); // возвращает 1105

public int codePointCount(int start, int end) Berechnet die Anzahl der Unicode-Zeichen zwischen den Positionen startundend

String testString = "Котёнок";
int myChar = testString.codePointCount(0, 3);
tv.setText(String.valueOf(myChar)); // возвращает 3

public int compareTo(String string) Vergleicht die angegebene Zeichenfolge mithilfe von Unicode-Zeichenwerten und berechnet, welche Zeichenfolge kleiner, gleich oder größer als die nächste ist. Kann zum Sortieren verwendet werden. Der Fall wird berücksichtigt. Wenn die Zeichenfolgen übereinstimmen, wird 0 zurückgegeben. Wenn sie kleiner als Null sind, ist die aufrufende Zeichenfolge kleiner als string string. Wenn sie größer als Null sind, ist die aufrufende Zeichenfolge größer als string string. Großgeschriebene Wörter werden über kleingeschriebenen Wörtern platziert.

String testString = "Котёнок";

if (testString.compareTo("котёнок") == 0) {
    tvInfo.setText("Строки равны");
} else {
    tvInfo.setText("Строки не равны. Возвращено"
            + testString.compareTo("котёнок")); // возвращает -32
}

Sortieren wir das String-Array mithilfe der Blasensortierung.

String[] poem = { "Мы", "везём", "с", "собой", "кота" };

for (int j = 0; j < poem.length; j++) {
	for (int i = j + 1; i < poem.length; i++) {
		if (poem[i].compareTo(poem[j]) < 0) {
			String temp = poem[j];
			poem[j] = poem[i];
			poem[i] = temp;
		}
	}
	System.out.println(poem[j]);
}

Als Ergebnis erhalten wir:

Мы
везём
кота
с
собой

Wie Sie sehen, ändert sich durch das Ändern der Stellen der Begriffe nicht die Sortiersumme der Katzen. public int compareToIgnoreCase (String string) Vergleicht die angegebene Zeichenfolge mit Unicode-Zeichenwerten, ohne Berücksichtigung der Groß- und Kleinschreibung.

String testString = "Котёнок";

if (testString.compareToIgnoreCase("котёнок") == 0) {
    tv.setText("Строки равны"); // слова одинаковы, если не учитывать регистр
} else {
    tv.setText("Строки не равны. Возвращено"
            + testString.compareTo("котёнок"));
}

public String concat (String string) Verkettet eine Zeichenfolge mit der angegebenen Zeichenfolge. Es wird eine neue Zeichenfolge zurückgegeben, die die Verkettung der beiden Zeichenfolgen enthält. Beachten Sie, dass der Methodenname selbst eine Katze enthält!

String testString = "Сук";
String newString = testString.concat("кот");
tv.setText(newString);

Die Methode führt die gleiche Funktion wie der Operator aus +und könnte geschrieben werden Сук + кот. Aber ein echter Katzenmensch wird die „Katzen“-Methode anwenden. public boolean contains (CharSequence cs) Bestimmt, ob eine Zeichenfolge eine Zeichenfolge enthältCharSequence

String testString = "котёнок";

if(testString.contains("кот")){
    infoTextView.setText("В слове котёнок содержится слово кот!");
}

public static String copyValueOf (char[] data, int start, int length) Erstellt eine neue Zeichenfolge mit den angegebenen Zeichen aus dem Array, Databeginnend an der Position start(nullbasierte Nummerierung) der Länge length . public static String copyValueOf(char[] data) Erstellt eine neue Zeichenfolge mit Zeichen aus dem angegebenen Array. Wenn Sie das Array ändern, nachdem die Zeile erstellt wurde, wird die erstellte Zeile nicht geändert. public boolean endsWith(String suffix) Prüft, ob eine Zeichenfolge mit endet suffix.

String str1 = "Суккот";

if(str1.endsWith("кот"))
    infoTextView.setText("Слово заканчивается на котике");
else
    infoTextView.setText("Плохое слово. Нет смысла его использовать");

public boolean equals (Object string) Vergleicht das angegebene Objekt und einen String und gibt true zurück , wenn die verglichenen Strings gleich sind, d. h. enthält dieselben Zeichen und in derselben Reihenfolge (Groß- und Kleinschreibung beachten).

String str1 = "Кот";
String str2 = "Кошка";

if(str1.equals(str2))
    infoTextView.setText("Строки совпадают");
else
    infoTextView.setText("Строки не совпадают");

Die Methode ist nicht mit dem Operator zu verwechseln ==, der zwei Objektreferenzen vergleicht und feststellt, ob sie auf dieselbe Instanz verweisen. Siehe String-Vergleich: equals()oder ==? public boolean equalsIgnoreCase(String string) Vergleicht die angegebene Zeichenfolge ohne Berücksichtigung der Groß- und Kleinschreibung mit der Quellzeichenfolge und gibt „ true“ zurück , wenn sie gleich sind. Der AZ-Bereich gilt als gleich dem az-Bereich.

String str1 = "Кот";
String str2 = "кот";

if(str1.equalsIgnoreCase(str2))
    infoTextView.setText("Строки совпадают");
else
    infoTextView.setText("Строки не совпадают");
public static String format(Locale locale, String format, Object... args)

Gibt eine formatierte Zeichenfolge mit dem angegebenen Format und Argumenten zurück, die auf den angegebenen Bereich lokalisiert sind. Zum Beispiel Datum oder Uhrzeit

// выводим число типа float с двумя знаками после запятой
String.format("%.2f", floatValue);

Wir kleben zwei Wörter zusammen, die in einer neuen Zeile erscheinen. In diesem Fall wird das zweite Wort in Großbuchstaben angezeigt.

String str1 = "Кот";
String str2 = "васька";
String strResult = String.format("%s\n%S", str1, str2);
// выводим результат в TextView
infoTextView.setText(strResult);

Konvertieren Sie die Zahl in das Oktalsystem.

String str1 = "8";
int inInt = Integer.parseInt(str1); // конвертируем строку в число
String strResult = String.format("(Восьмеричное Bedeutung): %o\n", inInt);

infoTextView.setText(strResult);

Analog zeigen wir im Hexadezimalsystem an

String str1 = "255";
int inInt = Integer.parseInt(str1);
String strResult = String.format("(Шестнадцатеричное Bedeutung): %x\n", inInt);
// число 255 будет выведено Wie ff
infoTextView.setText(strResult);

Bei Verwendung in Großbuchstaben lautet es %Xdann . Für das Dezimalsystem verwenden Sie . Auch das Datum kann auf unterschiedliche Weise angezeigt werden. ffFF%d

Date now = new Date();
Locale locale = Locale.getDefault();
infoTextView.setText(
		String.format(locale, "%tD\n", now) + // (MM/DD/YY)
		String.format(locale, "%tF\n", now) + // (YYYY-MM-DD)
		String.format(locale, "%tr\n", now) + // Full 12-hour time
		String.format(locale, "%tz\n", now) + // Time zone GMT offset
		String.format(locale, "%tZ\n", now)); // Localized time zone bbreviation

public byte[] getBytes(String charsetName) Gibt eine formatierte Zeichenfolge im angegebenen Format zurück. public void getBytes(int start, int end, byte[] data, int index)und andere Überladungen Die Methode speichert Zeichen in einem Byte-Array, einer Alternative zum getChars(). Wird häufig beim Exportieren von Zeichenfolgen aus verschiedenen Quellen verwendet, die andere Unicode-Zeichen verwenden. Beispielsweise arbeitet Java standardmäßig mit 16-Bit-Unicode-Zeichen, und im Internet verwenden Zeichenfolgen häufig 8-Bit-Unicode, ASCII usw. public void getChars(int start, int end, char[] buffer, int index) Methode zum Extrahieren mehrerer Zeichen aus einer Zeichenfolge. Sie müssen den Index des Anfangs der Teilzeichenfolge ( start) und den Index des Zeichens angeben, das auf das Ende der zu extrahierenden Teilzeichenfolge folgt ( end ). Das Array, das die ausgewählten Zeichen empfängt, befindet sich im Pufferparameter . Im Indexparameter wird der Index im Array übergeben, ab dem der Teilstring geschrieben wird . Stellen Sie sicher, dass das Array groß genug ist, um alle Zeichen in der angegebenen Teilzeichenfolge aufzunehmen.

String unusualCat = "Котёнок по имени Гав";
int start = 5;
int end = 12;
char[] buf = new char[end - start];
unusualCat.getChars(start, end, buf, 0);
infoTextView.setText(new String(buf));

public int hashCode() Gibt eine Ganzzahl zurück, die den Hashcode für dieses Objekt darstellt. public int indexOf(int c) Gibt die Nummer der ersten gefundenen Position mit dem angegebenen Index c zurück.

String testString = "котёнок";
// символ ё встречается в четвёртой позиции (index = 3)
infoTextView.setText(String.valueOf(testString.indexOf("ё")));

public int indexOf (int c, int start) Sucht den Index ab, beginnend bei der Positionstart

String testString = "котёнок";
// вернёт -1, так Wie после 5 символа буквы ё нет
infoTextView.setText(String.valueOf(testString.indexOf("ё", 4)));

public int indexOf (String string) Sucht nach einer ZeichenfolgesubString

String testString = "У окошка";
infoTextView.setText(String.valueOf(testString.indexOf("кошка")));

public int indexOf (String subString, int start) Sucht nach einer Zeichenfolge, subStringbeginnend bei Positionstart

String testString = "У окошка";
infoTextView.setText(String.valueOf(testString.indexOf("кошка", 2)));

public String intern () „Hasht“ einen String. public boolean isEmpty () Prüft, ob der String leer ist

if(catname.isEmpty()) {
    // здесь ваш Code
}

Diese Methode erschien in API 9 (Android 2.1). Verwenden Sie für ältere Geräte String.length() == 0 public int lastIndexOf (String string) и другие перегруженные версии die Nummer der zuletzt gefundenen Position am angegebenen Index. Sie können den Dateinamen beispielsweise ohne Erweiterung wie folgt erhalten:

filename.toString().substring(0, filename.getString().lastIndexOf("."));

In diesem Beispiel ermitteln wir die Position des letzten Punkts und die Teilzeichenfolge davor. public int length() Gibt die Länge einer Zeichenfolge zurück

String testString = "котёнок";
infoTextView.setText(String.valueOf(testString.length())); // возвращает 7 (семь символов)

public boolean matches(String regularExpression) Überprüft, ob eine Zeichenfolge mit regulären Ausdrücken übereinstimmt.

public int offsetByCodePoints (int index, int codePointOffset)

Gibt eine Position zurück, die sich in einem Abstand codePointOffsetnach der durch den Parameter angegebenen Startposition befindet. index public boolean regionMatches (int thisStart, String string, int start, int length) Die Methode vergleicht den angegebenen Teil der Zeichenfolge mit einem anderen Teil der Zeichenfolge. Sie müssen den Index des Anfangs des Zeilenbereichs des aufrufenden Objekts der Klasse angeben String. Im Parameter wird der zu vergleichende String übergeben string. Im Parameter wird der Index des Zeichens übergeben, ab dem der Vergleich durchgeführt werden soll start, und im Parameter wird die Länge des zu vergleichenden Teilstrings übergeben length. public boolean regionMatches (boolean ignoreCase, int thisStart, String string, int start, int length) Überladene Version. Die Methode vergleicht den angegebenen Teil einer Zeichenfolge mit einem anderen Teil der Zeichenfolge und ignoriert dabei die Groß-/Kleinschreibung. public String replace(CharSequence target, CharSequence replacement) и другие перегруженные версии Ändert ein Zeichen oder eine Zeichenfolge targetinreplacement

String testString = "Wal";
// меняем и на о
infoTextView.setText(testString.replace("Und", "о")); // возвращается кот

public String replaceAll (String regularExpression, String replacement) public String replaceFirst (String regularExpression, String replacement) Entfernt die ersten Zeichen mithilfe eines regulären Ausdrucks. Wenn Sie beispielsweise Nullen am Anfang der Zahlen 001, 007, 000024 entfernen müssen, können Sie diesen Aufruf verwenden.

String s = "001234-cat";
String s = s.replaceFirst ("^0*", ""); // останется 1234-cat

public String[] split (String regularExpression) и другие перегруженные версии Teilt eine Zeichenfolge in ein Array von Wörtern auf. Zum Beispiel gibt es eine Zeichenfolge „Vaska Ryzhik Murzik Barsik“ und wir möchten eine Reihe von Katzennamen erhalten:

String catnames = "Васька Рыжик Мурзик Барсик";
String aCats[] = catnames.split(" ");  // по пробелу

Wir bekommen:

aCats[0] = Васька
aCats[1] = Рыжик
aCats[2] = Мурзик
aCats[3] = Барсик

public boolean startsWith(String prefix) Prüft, ob eine Zeichenfolge mit Zeichen prefixvom Anfang der Zeichenfolge beginnt

String str1 = "котлета";

if(str1.startsWith("кот"))
    infoTextView.setText("Слово содержит кота");
else
    infoTextView.setText("Плохое слово. Нет смысла его использовать");

public boolean startsWith(String prefix, int start) Prüft, ob die angegebene Zeichenfolge mit Zeichen prefixan der angegebenen Position beginnt.

String str1 = "Суккот";

if(str1.startsWith("кот", 3))
    infoTextView.setText("Слово содержит кота");
else
    infoTextView.setText("Плохое слово. Нет смысла его использовать");

public CharSequence subSequence (int start, int end) Ähnlich der Methode substring(), kann aber für verwendet werden CharSequence. public String substring(int start)und andere Überladungen Erstellt eine neue Sequenz/Zeichenfolge mit Zeichen aus der angegebenen Zeichenfolge, beginnend an der Position startbis zum Ende der Zeile/endet mit dem Zeichen an der Position end. Die neue Zeile enthält Zeichen von bis startzum Ende – 1, also nehmen wir ein weiteres Zeichen.

String testString = "скотина";

infoTextView.setText(testString.substring(1, 4)); // возвращается кот

public char[] toCharArray() Kopiert die Zeichen in dieser Zeichenfolge in ein Zeichenarray. Das gleiche Ergebnis kann durch erzielt werden getChars(). Die Dokumentation empfiehlt die Verwendung dieser Methode nicht und schlägt vor charAt(), .

String unusualCat = "Котёнок по имени Гав";

char[] yomoe = unusualCat.toCharArray();
infoTextView.setText(String.valueOf(yomoe[3]));

public String toLowerCase() и другие перегруженные версии Konvertiert eine Zeichenfolge in Kleinbuchstaben. Das Standardgebietsschema steuert die Konvertierung. String cat = „Katze“; String Lower = cat.toLowerCase(); infoTextView.setText(lower); public String toString () Gibt eine Zeichenfolge zurück. Für die Saite selbst, die selbst bereits eine Saite ist, ist die Rückgabe der Saite sinnlos (oh, wie ich sie gebogen habe). Aber diese Methode ist tatsächlich für andere Klassen sehr nützlich. public String toUpperCase() Konvertiert eine Zeichenfolge in Großbuchstaben. Das Standardgebietsschema steuert die Konvertierung.

String cat = "Кот";
String upper = cat.toUpperCase();
infoTextView.setText(upper);

public String trim() Entfernt Leerzeichen am Anfang und Ende einer Zeichenfolge.

String str = "   Hello Kitty  ".trim();
infoTextView.setText(str);

public static String valueOf(long value)und andere Überladungen Konvertiert Inhalte (Zahlen, Objekte, Zeichen, Zeichenarrays) in eine Zeichenfolge.

int catAge = 7; // это число

infoTextView.setText(String.valueOf(catAge)); // преобразовано в строку

Generieren einer zufälligen Zeichenfolge

Nehmen wir an, wir benötigen eine zufällige Folge vorgegebener Zeichen.

private static final String mCHAR = "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
private static final int STR_LENGTH = 9; // длина генерируемой строки
Random random = new Random();

public void onClick(View view) {
    TextView infoTextView = (TextView) findViewById(R.id.textViewInfo);
    infoTextView.setText(createRandomString());
}

public String createRandomString() {
    StringBuilder builder = new StringBuilder();
    for (int i = 0; i < STR_LENGTH; i++) {
        int number = random.nextInt(mCHAR.length());
        char ch = mCHAR.charAt(number);
        builder.append(ch);
    }
    return builder.toString();
}

String-Vergleich: equals()oder ==?

Schauen wir uns ein Beispiel an.

String str1 = „Mürzik“;
String str2 = new String(str1);
boolean isCat = str1 == str2;

infoTextView.setText(str1 + " == " + str2 + " -> " + isCat);

Obwohl die beiden Variablen dasselbe Wort enthalten, haben wir es mit zwei verschiedenen Objekten zu tun und der Operator ==gibt false zurück . Als die Bäume einmal groß waren, musste ich zwei Saiten aus verschiedenen Quellen vergleichen. Obwohl die Zeichenfolgen genau gleich aussahen, ==ergab der Vergleich mit dem Operator „false“ und verwirrte für mich alle Karten. Und erst dann habe ich herausgefunden, dass ich das verwenden muss equals(). Eine Zeichenfolge in Java ist ein separates Objekt, das möglicherweise nicht mit einem anderen Objekt identisch ist, obwohl die Ausgabe der Zeichenfolge auf dem Bildschirm möglicherweise gleich aussieht. Es ist nur so, dass Java im Fall des logischen Operators ==(wie auch von !=) Verweise auf Objekte vergleicht (bei der Arbeit mit Grundelementen gibt es kein solches Problem):

String s1 = "hello";
String s2 = "hello";
String s3 = s1;
String s4 = "h" + "e" + "l" + "l" + "o";
String s5 = new String("hello");
String s6 = new String(new char[]{'h', 'e', 'l', 'l', 'o'});

infoTextView.setText(s1 + " == " + s2 + ": " + (s1 == s2));
// попробуйте и другие варианты
// infoTextView.setText(s1 + " equals " + s2 + ": " + (s1.equals(s2)));
// infoTextView.setText(s1 + " == " + s3 + ": " + (s1 == s3));
// infoTextView.setText(s1 + " equals " + s3 + ": " + (s1.equals(s3)));
// infoTextView.setText(s1 + " == " + s4 + ": " + (s1 == s4));
// infoTextView.setText(s1 + " equals " + s4 + ": " + (s1.equals(s4)));
// infoTextView.setText(s1 + " == " + s5 + ": " + (s1 == s5)); // false
// infoTextView.setText(s1 + " equals " + s5 + ": " + (s1.equals(s5)));
// infoTextView.setText(s1 + " == " + s6 + ": " + (s1 == s6)); // false
// infoTextView.setText(s1 + " equals " + s6 + ": " + (s1.equals(s6)));