字符串类

• 方法
• 生成随机字符串
• 字符串比较：equals()或==?

该类是String程序员经常使用的，所以应该学好。 请记住，类对象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从类对象 创建类对象：StringBufferStringBuilder

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>

要以编程方式在 element 中显示此字符串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);

如果您有一只猫 Vaska 并且它已经六岁了，那么添加两个变量并格式化该行

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

这是一个简单的格式化示例。记住它并在正确的地方使用它。

字符串资源

建议将字符串存储在资源中。以编程方式访问字符串资源是这样完成的：

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

从资源中的字符串数组中提取字符串

假设您在名为 的strings.xmlcats_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)start计算位置和 之间的 Unicode 字符数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 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为 length 的位置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默认使用16位Unicode字符，而在互联网上，字符串经常使用8位Unicode、ASCII等 public void getChars(int start, int end, char[] buffer, int index) 从字符串中提取多个字符的方法。您需要指定子字符串开头的索引 ( start)、要提取的子字符串末尾后面的字符的索引 ( end )。接收所选字符的数组位于buffer参数中。数组中的索引（从其开始写入子字符串）在索引参数中传递。确保数组足够大以包含指定子字符串中的所有字符。

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() 返回一个整数，该整数是该对象的哈希码。 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（Android 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) и другие перегруженные версии 将字符串拆分为单词数组。例如，有一个字符串 Vaska Ryzhik Murzik Barsik，我们想要获取猫名字的数组：

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() и другие перегруженные версии 将字符串转换为小写。默认区域设置控制转换。字符串猫=“猫”；字符串 lower = cat.toLowerCase(); infoTextView.setText(下); 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。有一次，当树很大时，我需要比较来自不同来源的两个字符串。尽管字符串看起来完全相同，但使用运算符的比较==返回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)));