JavaRush /בלוג Java /Random-HE /שיעור מיתר

רָמָה

28 February 2021
44 views
0 comments

שיעור מיתר

שיטות
יצירת מחרוזת אקראית
השוואת מחרוזות: equals()או ==?

הכיתה Stringמשמשת לעתים קרובות מאוד מתכנתים, ולכן יש ללמוד אותה היטב. מחרוזת כיתה - 1

זכור שאובייקטי מחלקה Stringאינם ניתנים לשינוי. אז כשאתה חושב שאתה משנה מחרוזת, אתה בעצם יוצר מחרוזת חדשה. ל-Java יש מחלקות מיוחדות StringBufferשמאפשרות StringBuilderשינויים במחרוזת. המחלקות String, StringBuffer, StringBuilderמוגדרות בחבילת java.lang וזמינות אוטומטית ללא הצהרת ייבוא. כל שלושת המחלקות מיישמות את הממשק CharSequence. יצירת מחרוזת היא פשוטה מאוד. לדוגמה, אתה יכול לעשות זאת:

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

אתה יכול ליצור מערך של מחרוזות:

String[] cats = {"Васька", "Barsik", "Murzik"};

אתה יכול ליצור אובייקט מחלקה ריק String:

String str = new String();

אתה יכול ליצור מחרוזת דרך מערך תווים:

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

יש גם בנאי שמאפשר להגדיר את הטווח של מערך תווים. עליך לציין את תחילת הטווח ואת מספר התווים לשימוש:

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

אתה יכול ליצור אובייקט מחלקה Stringמאובייקט מחלקה StringBufferבאמצעות StringBuilderהבנאים הבאים:

String(StringBuffer an object_StrBuf)
String(StringBuilder an object_StrBuild)

אופרטורים `+`ו-+= עבור`String`

ב-Java, סימן הפלוס ( +) פירושו שרשור מחרוזות, במילים אחרות, שילוב מחרוזות.

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

אם אחד מהאופרנדים בביטוי מכיל מחרוזת, אז גם האופרנדים האחרים חייבים להיות מחרוזות. לכן, Java עצמה יכולה להטיל משתנים לייצוג מחרוזת, גם אם הם לא מחרוזות.

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

עיצוב מחרוזות

נניח שיש לנו משאב מחרוזת:

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

כדי להציג מחרוזת זו באופן פרוגרמטי באלמנט TextView, אתה יכול להשתמש בקוד:

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

תאר לעצמך שיש לך כמה חתולים. אתה יכול, כמובן, לקבל קו משלך עבור כל חתול. אבל השורות מאוד דומות, רק השמות והגילאים משתנים. אתה יכול גם לשנות את מספר הכפות והזנבות (מה אתה מעשן?). במקרים כאלה, תוכל להחיל עיצוב מחרוזת. עלינו לקבוע את המילים שנשנה ולהחליף אותן בקבוצה מיוחדת של תווים שמתחילים בסמל אחוז, לאחר מכן מספר גדל באחד, לאחר מכן $sעבור מחרוזות או $dעבור מספרים. אז בואו נשנה את משאב המחרוזות שלנו כך:

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

בוא נעשה שינויים בקוד:

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

אם יש לך חתול ואסקה והוא בן שש, הוסף שני משתנים ועצב את השורה

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

הנה דוגמה לעיצוב פשוט. זכור אותו והשתמש בו במקומות הנכונים.

משאב מחרוזת

רצוי לאחסן מחרוזות במשאבים. גישה פרוגרמטית למשאב מחרוזת מתבצעת כך:

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

חלץ מחרוזות ממערכי מחרוזת במשאבים

נניח שיש לך מערך מחרוזות המוגדר בקובץ strings.xml שנקרא cats_array. לאחר מכן תוכל לגשת לשורות ממשאבים כמו זה:

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

שיטות

public char charAt (int index) מחזירה את התו בהיסט שצוין במחרוזת זו. הספירה לאחור מתחילה מ-0. אין צורך להשתמש בערכים שליליים ולא קיימים, תהיו יותר רציניים. כדי לחלץ תווים מרובים השתמש getChars().

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

public int codePointAt(int index) מחזירה את תו Unicode באינדקס הנתון

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

public int codePointBefore(int index) מחזירה את תו Unicode שלפני האינדקס הנתון

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

public int codePointCount(int start, int end) מחשב את מספר תווי Unicode בין עמדות startוend

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

public int compareTo(String string) משווה את המחרוזת שצוינה באמצעות ערכי תווים של Unicode ומחשבת איזו מחרוזת קטנה, שווה או גדולה מהמחרוזת הבאה. ניתן להשתמש למיון. המקרה נלקח בחשבון. אם המחרוזות תואמות, אזי 0 מוחזר, אם קטן מאפס, אז המחרוזת הקוראת קטנה ממחרוזת string, אם גדולה מאפס, אז המחרוזת הקוראת גדולה מהמחרוזת string. מילים רישיות ממוקמות מעל מילים קטנות.

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

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

בואו נמיין את מערך המחרוזות באמצעות מיון בועות.

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]);
}

כתוצאה מכך אנו מקבלים:

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

כפי שניתן לראות, שינוי מקומות המונחים אינו משנה את סכום המיון של החתולים. public int compareToIgnoreCase (String string) משווה את המחרוזת שצוינה באמצעות ערכי תווים של Unicode, ללא רגישות לרישיות.

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

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

public String concat (String string) משרשרת מחרוזת עם המחרוזת שצוינה. מוחזרת מחרוזת חדשה המכילה את השרשור של שתי המחרוזות. שימו לב ששם השיטה עצמו מכיל חתול!

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

השיטה מבצעת את אותה פונקציה כמו האופרטור +וניתן לכתוב אותה Сук + кот. אבל אדם חתול אמיתי ישתמש בשיטת ה"חתול". public boolean contains (CharSequence cs) קובע אם מחרוזת מכילה רצף של תווים בCharSequence

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

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

public static String copyValueOf (char[] data, int start, int length) יוצר מחרוזת חדשה המכילה את התווים שצוינו מהמערך Dataהמתחיל במיקום start(מספור מבוסס אפס) באורך אורך . public static String copyValueOf(char[] data) יוצר מחרוזת חדשה המכילה תווים מהמערך שצוין. שינוי המערך לאחר יצירת השורה אינו משנה את השורה שנוצרה. public boolean endsWith(String suffix) בודק אם מחרוזת מסתיימת ב- suffix.

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

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

public boolean equals (Object string) משווה בין האובייקט שצוין לבין מחרוזת ומחזירה true אם המחרוזות המושוות שוות, כלומר. מכיל את אותם תווים ובאותו סדר תלוי רישיות.

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

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

אין לבלבל את השיטה עם האופרטור ==, אשר משווה שני הפניות לאובייקט וקובע אם הם מתייחסים לאותו מופע. ראה השוואת מחרוזות: equals()או ==? public boolean equalsIgnoreCase(String string) משווה את המחרוזת שצוינה למחרוזת המקור באופן לא תלוי רישיות ומחזירה true אם הם שווים. טווח AZ נחשב שווה לטווח az.

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

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

מחזירה מחרוזת מעוצבת באמצעות הפורמט שסופק והארגומנטים הממוקמים לטווח הנתון. למשל תאריך או שעה

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

אנו מדביקים שתי מילים המופיעות בשורה חדשה. במקרה זה, המילה השנייה מוצגת באותיות רישיות.

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

המר את המספר למערכת אוקטלית.

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

infoTextView.setText(strResult);

באנלוגיה, אנו מציגים במערכת הקסדצימלית

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

לשימוש באותיות רישיות %X, אז ffזה יהיה FF. לשימוש במערכת עשרונית %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) מחזירה מחרוזת מעוצבת באמצעות הפורמט שסופק. public void getBytes(int start, int end, byte[] data, int index)ועומסים נוספים השיטה מאחסנת תווים במערך בתים, חלופה ל- getChars(). משמש לעתים קרובות בעת ייצוא מחרוזות ממקורות שונים המשתמשים בתווי Unicode אחרים. לדוגמה, Java כברירת מחדל פועלת עם תווי Unicode של 16 סיביות, ובאינטרנט, מחרוזות משתמשות לרוב ב-8 סיביות Unicode, ASCII וכו'. public void getChars(int start, int end, char[] buffer, int index) שיטה לחילוץ תווים מרובים ממחרוזת. עליך לציין את האינדקס של תחילת המחרוזת המשנה ( start), האינדקס של התו שאחרי סוף המחרוזת לחילוץ ( סוף ). המערך שמקבל את התווים שנבחרו נמצא בפרמטר המאגר . האינדקס במערך, שמתחיל ממנו תיכתב המחרוזת המשנה, מועבר בפרמטר index . ודא שהמערך גדול מספיק כדי להכיל את כל התווים במחרוזת המשנה שצוינה.

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() מחזירה מספר שלם שהוא קוד ה-hash עבור אובייקט זה. public int indexOf(int c) מחזירה את המספר של המיקום הראשון שנתקל בו עם האינדקס שצוין c.

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

public int indexOf (int c, int start) מחפש את האינדקס מ, מתחיל במיקוםstart

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

public int indexOf (String string) מחפש מחרוזת של תוויםsubString

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

public int indexOf (String subString, int start) מחפש מחרוזת תווים subStringשמתחילה במיקוםstart

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

public String intern () "מחטף" מחרוזת public boolean isEmpty () בודק אם המחרוזת ריקה

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

שיטה זו הופיעה ב-API 9 (אנדרואיד 2.1). עבור מכשירים ישנים יותר, השתמש String.length() == 0 public int lastIndexOf (String string) и другие перегруженные версии בהחזרת המספר של המיקום האחרון שנתקל בו באינדקס שצוין. לדוגמה, אתה יכול לקבל את שם הקובץ ללא סיומת כך:

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

בדוגמה זו, אנו מקבלים את המיקום של הנקודה האחרונה ומקבלים את המחרוזת המשנה לפניה. public int length() מחזירה את אורך המחרוזת

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

public boolean matches(String regularExpression) בודק אם מחרוזת תואמת לביטויים רגולריים.

public int offsetByCodePoints (int index, int codePointOffset)

מחזירה מיקום הממוקם במרחק codePointOffsetאחרי מיקום ההתחלה שצוין על ידי הפרמטר. index public boolean regionMatches (int thisStart, String string, int start, int length) השיטה משווה את החלק שצוין של המחרוזת עם חלק אחר של המחרוזת. עליך לציין את האינדקס של תחילת טווח השורות של האובייקט הקורא של המחלקה String. המחרוזת שיש להשוות מועברת בפרמטר string. אינדקס התו שמתחיל ממנו צריך לבצע את ההשוואה מועבר בפרמטר start, ואורך המחרוזת המשנה להשוואה מועבר בפרמטר length. public boolean regionMatches (boolean ignoreCase, int thisStart, String string, int start, int length) גרסה עמוסה מדי. השיטה משווה את החלק שצוין של מחרוזת עם חלק אחר של המחרוזת, תוך התעלמות מרישיות. public String replace(CharSequence target, CharSequence replacement) и другие перегруженные версии משנה תו או רצף של תווים targetלreplacement

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

public String replaceAll (String regularExpression, String replacement) public String replaceFirst (String regularExpression, String replacement) מסיר את התווים הראשונים באמצעות ביטוי רגולרי. לדוגמה, אם אתה צריך להסיר אפסים בתחילת המספרים 001, 007, 000024, אז אתה יכול להשתמש בשיחה זו.

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

public String[] split (String regularExpression) и другие перегруженные версии מפצל מחרוזת למערך של מילים. לדוגמה, יש מחרוזת ואסקה ריז'יק מורזיק ברסיק ואנחנו רוצים לקבל מערך של שמות חתולים:

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

אנחנו מקבלים:

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

public boolean startsWith(String prefix) בודק אם מחרוזת מתחילה בתווים prefixמתחילת המחרוזת

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

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

public boolean startsWith(String prefix, int start) בודק אם המחרוזת הנתונה מתחילה בתווים prefixבמיקום שצוין.

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

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

public CharSequence subSequence (int start, int end) דומה לשיטה substring(), אך ניתן להשתמש בו עבור CharSequence. public String substring(int start)ועוד עומסים נוספים יוצר רצף/מחרוזת חדשה עם תווים מהמחרוזת הנתונה שמתחילה במיקום startועד סוף השורה/מסתיימת עם התו במיקום end. השורה החדשה מכילה תווים מקצה startלקצה - 1, אז אנחנו לוקחים עוד תו אחד.

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

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

public char[] toCharArray() מעתיק את התווים במחרוזת זו למערך תווים. את אותה תוצאה ניתן להשיג דרך ה getChars(). התיעוד אינו ממליץ להשתמש בשיטה זו, מה שמציע את ה charAt().

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

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

public String toLowerCase() и другие перегруженные версии ממיר מחרוזת לאותיות קטנות. מקום ברירת המחדל שולט בהמרה. חתול מחרוזת = "חתול"; String lower = cat.toLowerCase(); infoTextView.setText(lower); public String toString () מחזירה מחרוזת. למיתר עצמו, שבעצמו הוא כבר מיתר, אין טעם להחזיר את המיתר (אוי, איך כופפתי אותו). אבל שיטה זו למעשה שימושית מאוד עבור מחלקות אחרות. public String toUpperCase() ממירה מחרוזת לאותיות גדולות. מקום ברירת המחדל שולט בהמרה.

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

public String trim() מסיר רווחים בתחילת וסוף מחרוזת.

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

public static String valueOf(long value)ועומסים אחרים ממיר תוכן (מספרים, אובייקטים, תווים, מערכי תווים) למחרוזת.

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

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

יצירת מחרוזת אקראית

נניח שאנו זקוקים למחרוזת אקראית של תווים נתונים.

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();
}

השוואת מחרוזות: `equals()`או `==`?

בואו נסתכל על דוגמה.

String str1 = "Murzik";
String str2 = new String(str1);
boolean isCat = str1 == str2;

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

למרות ששני המשתנים מכילים את אותה מילה, אנו עוסקים בשני אובייקטים שונים והאופרטור ==יחזיר false . פעם, כשהעצים היו גדולים, הייתי צריך להשוות בין שני מיתרים ממקורות שונים. למרות שהמחרוזות נראו בדיוק אותו הדבר, ההשוואה באמצעות האופרטור ==החזירה שקר ובלבלה לי את כל הקלפים. ורק אז גיליתי שאני צריך להשתמש ב- equals(). מחרוזת ב-Java היא אובייקט נפרד שאולי אינו זהה לאובייקט אחר, למרות שהפלט של המחרוזת עשוי להיראות זהה על המסך. רק ש-Java, במקרה של האופרטור הלוגי ==(כמו גם !=), משווה הפניות לאובייקטים (אין בעיה כזו בעבודה עם פרימיטיבים):

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)));

הערות

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION