BeginnersBook-Java-字符串教程-一-
BeginnersBook Java 字符串教程（一）
Java String endsWith()方法
原文： https://beginnersbook.com/2013/12/java-string-endswith-method-example/
Java String endsWith(String suffix)方法检查String是否以指定的后缀结尾。此方法返回布尔值true或false。如果在字符串的末尾找到指定的后缀，则返回true，否则返回false。
endsWith()方法签名：
public boolean endsWith(String suffix)
Java String endsWith()方法示例
在下面的例子中，我们有两个字符串str1和str2，我们正在检查字符串是否以指定的后缀结尾。
public class EndsWithExample{
public static void main(String args[]){
String str1 = new String("This is a test String");
String str2 = new String("Test ABC");
boolean var1 = str1.endsWith("String");
boolean var2 = str1.endsWith("ABC");
boolean var3 = str2.endsWith("String");
boolean var4 = str2.endsWith("ABC");
System.out.println("str1 ends with String: "+ var1);
System.out.println("str1 ends with ABC: "+ var2);
System.out.println("str2 ends with String: "+ var3);
System.out.println("str2 ends with ABC: "+ var4);
}
}
输出：
str1 ends with String: true
str1 ends with ABC: false
str2 ends with String: false
str2 ends with ABC: true
String endsWith()方法，带if语句
由于方法endsWith()返回一个布尔值，因此它可以在If语句中用作条件，如下例所示。这里我们给出了一个String "Java String tutorial"，我们正在检查if语句是否以后缀"tutorial"结尾。
public class JavaExample {
public static void main(String[] args) {
String str = "Java String tutorial";
if(str.endsWith("tutorial")) {
System.out.println("The Given String ends with tutorial");
}
}
}
输出：
Java String trim()和hashCode()方法
原文： https://beginnersbook.com/2013/12/java-string-trim-and-hashcode-methods/
在本教程中，我们将在示例的帮助下讨论 Java String trim()和hashCode()方法。
Java String trim()方法签名
从输入String中删除前导和尾随空格后，它返回一个String。对于例如" Hello".trim()将返回String "Hello"。
public String trim()
Java String trim()方法示例
在下面的例子中，我们有一个带有前导和尾随空格的字符串，我们使用trim()方法去除这些前导和尾随空格，但是我们想要保留给定字符串的单词之间的空格str。trim()方法仅删除前导和尾随空格，并将空格保留在空格中。
public class JavaExample{
public static void main(String args[]){
String str = new String(" How are you?? ");
System.out.println("String before trim: "+str);
System.out.println("String after trim: "+str.trim());
}
}
输出：
Java String hashCode()方法签名
此方法返回String的哈希码。计算如下：
s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
public int hashCode()
Java hashCode()方法示例
在下面的示例中，我们有一个字符串str，其值为"Welcome !!"，我们使用hashCode()方法显示该值的哈希码。
public class JavaExample{
public static void main(String args[]){
String str = new String("Welcome!!");
System.out.println("Hash Code of the String str: "+str.hashCode());
}
}
输出：
参考：
Java String indexOf()方法
原文： https://beginnersbook.com/2013/12/java-string-indexof-method-example/
Java String indexOf()方法用于查找给定String中指定字符或子字符串的索引。String类中有 4 种变体：
indexOf()方法签名
int indexOf(int ch)：返回给定String中字符ch的第一次出现的索引。
int indexOf(int ch, int fromIndex)：返回给定字符串中指定索引fromIndex后，字符ch的第一次出现的索引。例如，如果像str.indexOf('A', 20)那样调用indexOf()方法，那么它将开始在字符串str中索引 20 之后查找字符'A'。
int indexOf(String str)：返回特定String中字符串str的索引。
int indexOf(String str, int fromIndex)：返回给定字符串中指定索引fromIndex后，字符串str的索引。
如果在特定String中找不到指定的char/substring，则上述所有函数都返回 -1 。
Java String indexOf()方法示例
public class IndexOfExample{
public static void main(String args[]) {
String str1 = new String("This is a BeginnersBook tutorial");
String str2 = new String("Beginners");
String str3 = new String("Book");
String str4 = new String("Books");
System.out.println("Index of B in str1: "+str1.indexOf('B'));
System.out.println("Index of B in str1 after 15th char:"+str1.indexOf('B', 15));
System.out.println("Index of B in str1 after 30th char:"+str1.indexOf('B', 30));
System.out.println("Index of string str2 in str1:"+str1.indexOf(str2));
System.out.println("Index of str2 after 15th char"+str1.indexOf(str2, 15));
System.out.println("Index of string str3:"+str1.indexOf(str3));
System.out.println("Index of string str4"+str1.indexOf(str4));
System.out.println("Index of hardcoded string:"+str1.indexOf("is"));
System.out.println("Index of hardcoded string after 4th char:"+str1.indexOf("is", 4));
}
}
输出：
Index of B in str1: 10
Index of B in str1 after 15th char:19
Index of B in str1 after 30th char:-1
Index of string str2 in str1:10
Index of str2 after 15th char-1
Index of string str3:19
Index of string str4-1
Index of hardcoded string:2
Index of hardcoded string after 4th char:5
indexOf()方法的另一个例子
让我们举一个简短的例子，我们使用indexOf()方法找到给定字符和子字符串的索引。
public class JavaExample {
public static void main(String[] args) {
String str = "Java String";
char ch = 'J';
char ch2 = 'S';
String subStr = "tri";
int posOfJ = str.indexOf(ch);
int posOfS = str.indexOf(ch2);
int posOfSubstr = str.indexOf(subStr);
System.out.println(posOfJ);
System.out.println(posOfS);
System.out.println(posOfSubstr);
}
}
输出：
Java String lastIndexOf()方法
原文： https://beginnersbook.com/2013/12/java-string-lastindexof-method-example/
在上一个教程中，我们讨论了indexOf()方法，该方法用于找出给定String中指定char或子字符串的出现。在本教程中，我们将讨论lastIndexOf()方法，该方法用于找出给定String中或字符子串的最后一次出现的索引。
Java String lastIndexOf()方法签名
要找出指定字符或字符串的最后一次出现，此方法从字符串末尾开始搜索并从那里向后返回。如果在方法调用期间指定了fromIndex，则向后搜索从指定的索引fromIndex开始
int lastIndexOf(int ch)：返回给定String中字符ch的最后一次出现。
int lastIndexOf(int ch, int fromIndex)：返回ch的最后一次出现，它从指定的索引fromIndex开始向后看。
int lastIndexOf(String str)：返回String中substring str的最后一次出现。
int lastIndexOf(String str, int fromIndex)：返回str的最后一次出现，开始从指定的索引fromIndex向后搜索。
Java String lastIndexOf()示例
在下面的例子中，我们在String str中搜索几个给定的字符和一个给定的子字符串。我们正在寻找它们在String str中的最后一次出现，这就是我们使用lastIndexOf()方法的原因。如果要查找字符串中char或子字符串的第一次出现，请改用indexOf()方法。
public class JavaExample {
public static void main(String[] args) {
String str = "beginnersbook is for beginners";
char ch = 'b';
char ch2 = 's';
String subStr = "beginners";
int posOfB = str.lastIndexOf(ch);
int posOfS = str.lastIndexOf(ch2);
int posOfSubstr = str.lastIndexOf(subStr);
System.out.println(posOfB);
System.out.println(posOfS);
System.out.println(posOfSubstr);
}
}
输出：
String lastIndexOf()方法的另一个例子
这里我们将演示在各种情况下使用lastIndexOf()方法。我们正在尝试使用lastIndexOf()方法的不同变体，我们提供fromIndex，然后该方法从指定的fromIndex向后搜索。
public class LastIndexOfExample{
public static void main(String args[]) {
String str1 = new String("This is a BeginnersBook tutorial");
String str2 = new String("Beginners");
String str3 = new String("Book");
String str4 = new String("Books");
System.out.println("Last 'B' in str1: "+str1.lastIndexOf('B'));
System.out.println("Last 'B' in str1 whose index<=15:"+str1.lastIndexOf('B', 15));
System.out.println("Last 'B' in str1 whose index<=30:"+str1.lastIndexOf('B', 30));
System.out.println("Last occurrence of str2 in str1:"+str1.lastIndexOf(str2));
System.out.println("Last occurrence of str2 in str1 before 15:"+str1.lastIndexOf(str2, 15));
System.out.println("Last occurrence of str3 in str1:"+str1.lastIndexOf(str3));
System.out.println("Last occurrence of str4 in str1"+str1.lastIndexOf(str4));
System.out.println("Last occurrence of 'is' in str1:"+str1.lastIndexOf("is"));
System.out.println("Last occurrence of 'is' in str1 before 4:"+str1.lastIndexOf("is", 4));
}
}
输出：
Last 'B' in str1: 19
Last 'B' in str1 whose index<=15:10
Last 'B' in str1 whose index<=30:19
Last occurrence of str2 in str1:10
Last occurrence of str2 in str1 before 15:10
Last occurrence of str3 in str1:19
Last occurrence of str4 in str1-1
Last occurrence of 'is' in str1:5
Last occurrence of 'is' in str1 before 4:2
Java - String substring()方法
原文： https://beginnersbook.com/2013/12/java-string-substring-method-example/
方法substring()返回一个新字符串，它是给定字符串的子字符串。 Java Stringsubstring()方法用于根据传递的索引获取给定字符串的子字符串。这种方法有两种变体。在本指南中，我们将看到如何在示例的帮助下使用此方法。
String substring()方法变体
我们可以通过两种方式使用substring()方法 -
1.当我们只通过起始指数时：
String substring(int beginIndex)
返回从指定索引开始的子字符串，即beginIndex，并扩展到字符串末尾的字符。例如 - "Chaitanya".substring(2)将返回"aitanya"。beginIndex是包含的，这就是索引 2 中出现的字符包含在子字符串中的原因。如果beginIndex小于零或大于String的长度（beginIndex < 0 || > String.length()）抛出IndexOutOfBoundsException。
2.当我们传递两个索引时，起始索引和结束索引：
String substring(int beginIndex, int endIndex)
返回一个新字符串，该字符串是此字符串的子字符串。子字符串从指定的beginIndex开始，并扩展到索引endIndex - 1处的字符。因此子字符串的长度是endIndex-beginIndex。 换句话说，你可以说beginIndex是包容性的，而endIndex在获取子字符串时是独占的。
例如 - "Chaitanya".substring(2,5)将返回"ait"。如果beginIndex小于零或beginIndex > endIndex或endIndex大于String的长度，它抛出IndexOutOfBoundsException。
Java String substring()示例
现在我们了解了substring()方法的基础知识，让我们来看一个示例来理解这个方法的用法。
这里我们有一个字符串str，我们使用substring()方法找出该字符串的子串。
public class SubStringExample{
public static void main(String args[]) {
String str= new String("quick brown fox jumps over the lazy dog");
System.out.println("Substring starting from index 15:");
System.out.println(str.substring(15));
System.out.println("Substring starting from index 15 and ending at 20:");
System.out.println(str.substring(15, 20));
}
}
输出：
Substring starting from index 15:
jumps over the lazy dog
Substring starting from index 15 and ending at 20:
jump
注意：很多人都很困惑，第二个方法调用中返回的子字符串应该是" jump"而不是" jumps"，这是因为返回的子字符串长度应该是endIndex-beginIndex，在我们的例子中，beginIndex是 15，endIndex是 20，因此，返回的子串的长度应该是20-15 = 5。正确的答案是" jump"，因为在它之前有一个空格，所以子串" jump"的长度是 5（包括空格）。
为了进一步避免混淆，我正在分享这个方法的另一个例子，这个例子很容易理解。
String substring()方法的另一个例子
public class JavaExample{
public static void main(String args[]) {
String mystring = new String("Lets Learn Java");
/* The index starts with 0, similar to what we see in the arrays
* The character at index 0 is s and index 1 is u, since the beginIndex
* is inclusive, the substring is starting with char 'u'
*/
System.out.println("substring(1):"+mystring.substring(1));
/* When we pass both beginIndex and endIndex, the length of returned
* substring is always endIndex - beginIndex which is 3-1 =2 in this example
* Point to note is that unlike beginIndex, the endIndex is exclusive, that is
* why char at index 1 is present in substring while the character at index 3
* is not present.
*/
System.out.println("substring(1,3):"+mystring.substring(1,3));
}
}
输出：
Java 字符串方法
Java String concat()方法
原文： https://beginnersbook.com/2013/12/java-string-concat-method-example/
Java 字符串concat()方法连接多个字符串。此方法将指定的字符串附加到给定字符串的末尾，并返回组合的字符串。我们可以使用concat()方法连接多个字符串。
concat()方法签名
public String concat(String str)
此方法将字符串 str 连接到当前字符串的末尾。例如 - s1.concat("Hello");会在String s1的末尾连接字符串"Hello"。可以在这样的单个语句中多次调用此方法
String s1="Beginners";
s1= s1.concat("Book").concat(".").concat("com");
执行上述声明后，s1的值将为BeginnersBook.com。
Java String concat方法示例
在这个例子中，我们将看到使用concat()方法进行String连接的两种方法。
public class ConcatenationExample {
public static void main(String args[]) {
//One way of doing concatenation
String str1 = "Welcome";
str1 = str1.concat(" to ");
str1 = str1.concat(" String handling ");
System.out.println(str1);
//Other way of doing concatenation in one line
String str2 = "This";
str2 = str2.concat(" is").concat(" just a").concat(" String");
System.out.println(str2);
}
}
输出：
Welcome to String handling
This is just a String
Java String concat方法的另一个例子
正如我们在上面看到的那样，concat()方法将字符串附加到当前字符串的末尾。但是我们可以做一个解决方法，在给定字符串的开头附加指定的字符串。
public class JavaExample {
public static void main(String args[]) {
String mystring = ".com";
String mystr = "BeginnersBook".concat(mystring);
System.out.println(mystr);
}
}
输出：
Java String replace()，replaceFirst()和replaceAll()方法
原文： https://beginnersbook.com/2013/12/java-string-replace-replacefirst-replaceall-method-examples/
在本教程中，我们将讨论replace()，replaceFirst()和replaceAll()方法。所有这些 Java String方法主要用于用另一个String替换String的一部分。
Java String替换方法签名
String replace(char oldChar, char newChar)：它用newChar字符替换oldChar字符的所有出现。对于例如"pog pance".replace('p', 'd')将返回dog dance。
String replaceFirst(String regex, String replacement)：它用替换字符串替换符合指定正则表达式的第一个子字符串。如果指定的正则表达式（正则表达式）无效抛出PatternSyntaxException。
String replaceAll(String regex, String replacement)：它用替换String替换所有符合给定正则表达式的子串。
Java String replace()方法示例
在下面的例子中，我们有一个字符串str，我们正在演示使用String str的replace()方法。我们用char 'p'替换了char 'o'的所有出现。在第二个print语句中，我们用char 'K'替换了char 'i'的所有出现。
这里我们使用print语句显示修改后的字符串，但我们实际上没有更改字符串str，为了实现我们需要在字符串中分配返回的replace()方法字符串，然后该字符串可以进行永久性更改。
public class JavaExample{
public static void main(String args[]){
String str = new String("Site is BeginnersBook.com");
System.out.print("String after replacing all 'o' with 'p' :" );
System.out.println(str.replace('o', 'p'));
System.out.print("String after replacing all 'i' with 'K' :" );
System.out.println(str.replace('i', 'K'));
}
}
输出：
Java String replaceFirst()方法示例
在下面的示例中，我们将演示如何使用replaceFirst()方法。此方法用新指定的字符串替换字符串的一部分。replaceFirst()和replaceAll()方法之间的区别在于replaceFirst()替换第一个匹配项，而replaceAll()替换所有匹配项。
public class JavaExample{
public static void main(String args[]){
String str = new String("Site is BeginnersBook.com");
System.out.print("String after replacing com with net :" );
System.out.println(str.replaceFirst("com", "net"));
System.out.print("String after replacing Site name:" );
System.out.println(str.replaceFirst("Beginners(.*)", "XYZ.com"));
}
}
输出：
Java String replaceAll()方法示例
在下面的示例中，我们使用replaceAll()方法用新字符串替换给定子字符串的所有出现。
replace()和replaceAll()方法之间的区别在于replace()方法用新char替换旧char的所有出现，而replaceAll()方法用新字符串替换旧字符串的所有出现。基本上，replace()适用于替换字符，而replaceAll()适用于替换部分字符串。
public class JavaExample{
public static void main(String args[]){
String str = new String("My .com site is BeginnersBook.com");
System.out.print("String after replacing all com with net: " );
System.out.println(str.replaceAll("com", "net"));
System.out.print("Replacing whole String: " );
System.out.println(str.replaceAll("(.*)Beginners(.*)", "Welcome"));
}
}
输出：
Java String contains()方法
原文： https://beginnersbook.com/2017/10/java-string-contains-method/
Java String contains()方法检查特定字符序列是否是给定字符串的一部分。如果给定字符串中存在指定的字符序列，则此方法返回true，否则返回false。
例如：
String str = "Game of Thrones";
//This will print "true" because "Game" is present in the given String
System.out.println(str.contains("Game"));
/* This will print "false" because "aGme" is not present, the characters
* must be present in the same sequence as specified in the contains method
*/
System.out.println(str.contains("aGme"));
contains()方法的语法
public boolean contains(CharSequence str)
返回类型是boolean，这意味着此方法返回true或false。当在给定字符串中找到字符序列时，此方法返回true，否则返回false。
如果CharSequence为null，则此方法抛出NullPointerException。
例如：像这样调用此方法会抛出NullPointerException。
str.contains(null);
Java String contains()方法示例
第二个print语句显示为false，因为contains()方法区分大小写。 您也可以使用contains()方法进行不区分大小写的检查，我已经在本教程末尾介绍了。
class Example{
public static void main(String args[]){
String str = "Do you like watching Game of Thrones";
System.out.println(str.contains("like"));
/* this will print false as the contains() method is
* case sensitive. Here we have mentioned letter "l"
* in upper case and in the actual string we have this
* letter in the lower case.
*/
System.out.println(str.contains("Like"));
System.out.println(str.contains("Game"));
System.out.println(str.contains("Game of"));
}
}
输出：
true
false
true
true
示例 2：在if-else语句中使用 Java String contains()方法
我们知道contains()方法返回一个布尔值，我们可以将此方法用作if-else语句中的条件。
class JavaExample{
public static void main(String args[]){
String str = "This is an example of contains()";
/* Using the contains() method in the if-else statement, since
* this method returns the boolean value, it can be used
* as a condition in if-else
*/
if(str.contains("example")){
System.out.println("The word example is found in given string");
}
else{
System.out.println("The word example is not found in the string");
}
}
}
输出：
Java String contains()方法，用于不区分大小写的检查
我们在上面已经看到contains()方法区分大小写，但是通过一个小技巧，您可以使用此方法进行不区分大小写的检查。让我们举个例子来理解这个：
这里我们使用toLowerCase()方法将两个字符串转换为小写，以便我们可以使用contains()方法执行不区分大小写的检查。我们也可以使用toUpperCase()方法实现同样的目的，如下例所示。
class Example{
public static void main(String args[]){
String str = "Just a Simple STRING";
String str2 = "string";
//Converting both the strings to lower case for case insensitive checking
System.out.println(str.toLowerCase().contains(str2.toLowerCase()));
//You can also use the upper case method for the same purpose.
System.out.println(str.toUpperCase().contains(str2.toUpperCase()));
}
}
输出：
true
true
参考：
Java - String toLowerCase()和toUpperCase()方法
原文： https://beginnersbook.com/2013/12/java-string-tolowercase-method-example/
方法toLowerCase()将String的字符转换为小写字符。它有两个变种：
String toLowerCase(Locale locale)：使用指定的Locale定义的规则将字符串转换为小写。
String toLowerCase()：相当于toLowerCase(Locale.getDefault())。Locale.getDefault()获取此 Java 虚拟机实例的默认语言环境的当前值。 Java 虚拟机根据主机环境在启动期间设置默认语言环境。如果未明确指定语言环境，则许多语言环境敏感方法使用它。可以使用setDefault()方法更改它。
示例：toLowerCase()方法
import java.util.Locale;
public class LowerCaseExample{
public static void main(String args[]){
String str = new String("ABC IS NOT EQUAL TO XYZ");
//Standard method of conversion
System.out.println(str.toLowerCase());
//By specifying Locale
System.out.println(str.toLowerCase(Locale.FRANCE));
}
}
输出：
abc is not equal to xyz
abc is not equal to xyz
方法：toUpperCase()
与toLowerCase()方法类似，toUpperCase()也有两个变体：
String toUpperCase(Locale locale)：它使用指定的Locale定义的规则将字符串转换为大写字符串。
String toUpperCase()：与toUpperCase(Locale.getDefault())相当。
示例：toUpperCase()方法
import java.util.Locale;
public class UpperCaseExample{
public static void main(String args[]){
String str = new String("this is a test string");
//Standard method of conversion
System.out.println(str.toUpperCase());
//By specifying Locale
System.out.println(str.toUpperCase(Locale.CHINA));
}
}
输出：
THIS IS A TEST STRING
THIS IS A TEST STRING
Java String intern()方法
原文： https://beginnersbook.com/2017/10/java-string-intern-method/
Java String intern()方法用于从内存中获取字符串（如果已存在）。此方法可确保所有相同的字符串共享相同的内存。例如，使用intern()方法创建一个字符串"hello" 10 次将确保内存中只有一个"Hello"实例，并且所有 10 个引用都指向同一个实例。
一个简单的 Java String intern()方法示例
此示例演示了intern()方法的用法。此方法在内存池中搜索提到的String，如果找到该字符串，则返回它的引用，否则它为该字符串分配新的内存空间并为其分配引用。
public class Example{
public static void main(String args[]){
String str1 = "beginnersbook";
/* The Java String intern() method searches the string "beginnersbook"
* in the memory pool and returns the reference of it.
*/
String str2 = new String("beginnersbook").intern();
//prints true
System.out.println("str1==str2: "+(str1==str2));
}
}
输出：
str1==str2: true
Java 字符串字面值
当我们使用字符串字面值创建字符串而不是使用new关键字创建字符串时，java 会自动实例化字符串。让我们举个例子来理解这个：
public class Example{
public static void main(String args[]){
String str1 = "Hello";
//Java automatically interns this
String str2 = "Hello";
//This is same as creating string using string literal
String str3 = "Hello".intern();
//This will create a new instance of "Hello" in memory
String str4 = new String("Hello");
if ( str1 == str2 ){
System.out.println("String str1 and str2 are same");
}
if ( str2 == str3 ){
System.out.println("String str2 and str3 are same" );
}
if ( str1 == str4 ){
//This will not be printed as the condition is not true
System.out.println("String str1 and str4 are same" );
}
if ( str3 == str5 ){
System.out.println("String str3 and str5 are same" );
}
}
}
输出：
String str1 and str2 are same
String str2 and str3 are same
String str3 and str5 are same
相关文章：
- Java
String format()方法 - Java
String matches()方法 - Java
String trim()和 hashCode()方法 - Java
String replace()，replaceFirst()和replaceAll()方法
参考：
Java String isEmpty()方法
原文： https://beginnersbook.com/2017/10/java-string-isempty-method-with-example/
Java String isEmpty()方法检查String是否为空。如果给定的字符串为空，则此方法返回true，否则返回false。换句话说，如果字符串的长度为 0，则可以说此方法返回true。
isEmpty()方法的签名：**
public boolean isEmpty()
Java String isEmpty()方法示例
public class Example{
public static void main(String args[]){
//empty string
String str1="";
//non-empty string
String str2="hello";
//prints true
System.out.println(str1.isEmpty());
//prints false
System.out.println(str2.isEmpty());
}
}
输出：
true
false
Java String isEmpty()方法检查字符串是否为空或空的示例
正如我们在上面的例子中看到的那样，isEmpty()方法只检查String是否为空。如果要检查String是否为null或为空，则可以执行此操作，如以下示例所示。
public class Example{
public static void main(String args[]){
String str1 = null;
String str2 = "beginnersbook";
if(str1 == null || str1.isEmpty()){
System.out.println("String str1 is empty or null");
}
else{
System.out.println(str1);
}
if(str2 == null || str2.isEmpty()){
System.out.println("String str2 is empty or null");
}
else{
System.out.println(str2);
}
}
}
输出：
String str1 is empty or null
beginnersbook
参考
相关文章
Java String join()方法
原文： https://beginnersbook.com/2017/10/java-string-join-method/
在 Java 8 中，我们在 Java String类中有一个新的方法join()。Java String join()方法连接给定的字符串并返回连接的字符串。为了同样的目的，Java 8 还引入了一个新的StringJoiner类。
Java String Join（）方法签名
public static String join(CharSequence delimiter,
CharSequence... elements)
返回一个新的String，该String由CharSequence元素的副本组成，这些元素与指定的分隔符的副本连接在一起。
例如，
String message = String.join("-", "This", "is", "a", "String");
// message returned is: "This-is-a-String"
此方法的第一个参数指定用于连接多个字符串的分隔符。
注意，如果元素为null，则添加"null"。
Java String join()示例
public class Example{
public static void main(String args[]){
//The first argument to this method is the delimiter
String str=String.join("^","You","are","Awesome");
System.out.println(str);
}
}
输出：
You^are^Awesome
Java String join()通过分隔符连接列表元素的示例
在这个例子中，我们使用join()方法通过分隔符连接List的元素。
import java.util.List;
import java.util.Arrays;
public class Example{
public static void main(String args[]){
//Converting an array of String to the list
List list<String> = Arrays.asList("Steve", "Rick", "Peter", "Abbey");
String names = String.join(" | ", list);
System.out.println(names);
}
}
输出：
Steve | Rick | Peter | Abbey
相关文章：
参考
Java String charAt()方法
原文： https://beginnersbook.com/2013/12/java-string-charat-method-example/
Java String charAt(int index)方法返回字符串中指定索引处的字符。我们在此方法中传递的索引值应介于 0 和（string的长度 -1）之间。例如：s.charAt(0)将返回实例s表示的字符串的第一个字符。如果在charAt()方法中传递的索引值小于 0 或大于等于字符串的长度（index < 0 || index >= length()），则 Java String charAt方法抛出IndexOutOfBoundsException。
Java String charAt()方法示例
让我们举一个例子来理解charAt()方法的使用。在这个例子中，我们有一个字符串，我们使用charAt()方法打印字符串的第 1，第 6，第 12 和第 21 个字符。
public class CharAtExample {
public static void main(String args[]) {
String str = "Welcome to string handling tutorial";
//This will return the first char of the string
char ch1 = str.charAt(0);
//This will return the 6th char of the string
char ch2 = str.charAt(5);
//This will return the 12th char of the string
char ch3 = str.charAt(11);
//This will return the 21st char of the string
char ch4 = str.charAt(20);
System.out.println("Character at 0 index is: "+ch1);
System.out.println("Character at 5th index is: "+ch2);
System.out.println("Character at 11th index is: "+ch3);
System.out.println("Character at 20th index is: "+ch4);
}
}
输出：
Character at 0 index is: W
Character at 5th index is: m
Character at 11th index is: s
Character at 20th index is: n
使用charAt()方法时的IndexOutOfBoundsException
当我们传递负索引或大于length() - 1的索引时，charAt()方法抛出IndexOutOfBoundsException。在下面的示例中，我们在charAt()方法中传递负索引，让我们看看我们在输出中得到了什么。
public class JavaExample {
public static void main(String args[]) {
String str = "BeginnersBook";
//negative index, method would throw exception
char ch = str.charAt(-1);
System.out.println(ch);
}
}
输出：
Java String charAt()示例打印字符串的所有字符
为了打印字符串的所有字符，我们运行for循环从 0 到字符串的长度 -1，并使用charAt()方法在循环的每次迭代中显示字符。
public class JavaExample {
public static void main(String args[]) {
String str = "BeginnersBook";
for(int i=0; i<=str.length()-1; i++) {
System.out.println(str.charAt(i));
}
}
}
输出：
B
e
g
i
n
n
e
r
s
B
o
o
k
Java String charAt()示例计算字符的出现次数
在此示例中，我们将使用charAt()方法计算给定字符串中特定字符的出现次数。这里我们有一个字符串，我们正在计算字符串中字符'B'的出现次数。
public class JavaExample {
public static void main(String[] args) {
String str = "BeginnersBook";
//initialized the counter to 0
int counter = 0;
for (int i=0; i<=str.length()-1; i++) {
if(str.charAt(i) == 'B') {
//increasing the counter value at each occurrence of 'B'
counter++;
}
}
System.out.println("Char 'B' occurred "+counter+" times in the string");
}
}
输出：
参考
Java String split()方法
原文： https://beginnersbook.com/2013/12/java-string-split-method-example/
Java Stringsplit方法用于根据给定的分隔符或正则表达式将String拆分为其子串。
例如：
String: [email protected]
Regular Expression: @
Output : {"chaitanya", "singh"}
Java 字符串拆分方法
我们在String类中有两种split()方法。
-
String[] split(String regex)：在根据分隔正则表达式拆分输入String后返回一个字符串数组。 -
String[] split(String regex, int limit)：当我们想要限制子串时，使用这个String split方法。此方法与上述方法的唯一区别在于它限制了拆分后返回的字符串数。对于例如split("anydelimiter", 3)将返回仅 3 个字符串的数组，即使字符串中的分隔符超过 3 次也是如此。
如果限制为负，则返回的数组将具有尽可能多的子串，但是当限制为零时，返回的数组将具有除尾随空字符串之外的所有子串。
如果指定正则表达式的语法无效，则抛出 PatternSyntaxException 。
Java String拆分示例
public class SplitExample{
public static void main(String args[]){
// This is out input String
String str = new String("28/12/2013");
System.out.println("split(String regex):");
/* Here we are using first variation of java string split method
* which splits the string into substring based on the regular
* expression, there is no limit on the substrings
*/
String array1[]= str.split("/");
for (String temp: array1){
System.out.println(temp);
}
/* Using second variation of split method here. Since the limit is passed
* as 2\. This method would only produce two substrings.
*/
System.out.println("split(String regex, int limit) with limit=2:");
String array2[]= str.split("/", 2);
for (String temp: array2){
System.out.println(temp);
}
System.out.println("split(String regex, int limit) with limit=0:");
String array3[]= str.split("/", 0);
for (String temp: array3){
System.out.println(temp);
}
/* When we pass limit as negative. The split method works same as the first variation
* because negative limit says that the method returns substrings with no limit.
*/
System.out.println("split(String regex, int limit) with limit=-5:");
String array4[]= str.split("/", -5);
for (String temp: array4){
System.out.println(temp);
}
}
}
输出：
split(String regex):
28
12
2013
split(String regex, int limit) with limit=2:
28
12/2013
split(String regex, int limit) with limit=0:
28
12
2013
split(String regex, int limit) with limit=-5:
28
12
2013
java 字符串拆分方法中零和负限制之间的差异
在上面的示例中，split("/", 0)和split("/", -5)返回相同的值，但在某些情况下，结果会有所不同。让我们通过一个例子来看看这两者之间的区别：
String s="bbaaccaa";
String arr1[]= s.split("a", -1);
String arr2[]= s.split("a", 0);
在这种情况下，arr1将具有{"bb"，""，"cc"，""，""}但是arr2将具有{"bb"，""，"cc"}，因为限制零不包括试验空字符串。
让我们看看完整的程序。
public class JavaExample{
public static void main(String args[]){
// This is out input String
String s = new String("bbaaccaa");
//Splitting with limit as 0
String arr2[]= s.split("a", 0);
System.out.println("Zero Limit split:");
for (String str2: arr2){
System.out.println(str2);
}
//Splitting with negative limit
String arr1[]= s.split("a", -1);
System.out.println("Negative Limit split:");
for (String str: arr1){
System.out.println(str);
}
System.out.println("End of program");
}
}
输出：
Java 带有多个分隔符（特殊字符）的字符串拆分
让我们看看我们如何在使用split()方法时传递多个分隔符。在这个例子中，我们基于多个特殊字符拆分输入字符串。
public class JavaExample{
public static void main(String args[]){
String s = " ,ab;gh,bc;pq#kk$bb";
String[] str = s.split("[,;#$]");
//Total how many substrings? The array length
System.out.println("Number of substrings: "+str.length);
for (int i=0; i < str.length; i++) {
System.out.println("Str["+i+"]:"+str[i]);
}
}
}
输出：
让我们再练习几个例子：
示例：Java String split方法中的正则表达式
public class SplitExample1 {
public static void main(String args[])
{
String str = "helloxyzhixyzbye";
String[] arr = str.split("xyz");
for (String s : arr)
System.out.println(s);
}
}
输出：
hello
hi
bye
示例：基于空格分割字符串
public class SplitExample2 {
public static void main(String args[])
{
String str = "My name is Chaitanya";
//regular expression is a whitespace here
String[] arr = str.split(" ");
for (String s : arr)
System.out.println(s);
}
}
输出：
My
name
is
Chaitanya
Java String format()方法
原文： https://beginnersbook.com/2017/10/java-string-format-method/
Java String format()方法用于格式化String。你可以用这个方法做很多事情，例如你可以使用这种方法连接字符串，同时你可以格式化连接字符串的输出。在本教程中，我们将看到 Java String format()方法的几个示例。
format()方法的语法
public static String format(Locale l,
String format,
Object... args)
使用指定的语言环境，格式字符串和参数返回格式化的字符串。
和
public static String format(String format,
Object... args)
使用指定的格式字符串和参数返回格式化字符串。
Java String format()方法的一个简单示例
public class Example{
public static void main(String args[]){
String str = "just a string";
//concatenating string using format
String formattedString = String.format("My String is %s", str);
/*formatting the value passed and concatenating at the same time
* %.6f is for having 6 digits in the fractional part
*/
String formattedString2 = String.format("My String is %.6f",12.121);
System.out.println(formattedString);
System.out.println(formattedString2);
}
}
输出：
My String is just a string
My String is 12.121000
Java String format()连接字符串参数的示例
我们可以使用%1$s, %2$s格式说明符指定参数位置。这里%1$表示第一个参数，%2$表示第二个参数，依此类推。
public class Example{
public static void main(String args[]){
String str1 = "cool string";
String str2 = "88";
/* Specifying argument positions. %1$ is for the first argument and
* %2$ is for the second argument
*/
String fstr = String.format("My String is: %1$s, %1$s and %2$s", str1, str2);
System.out.println(fstr);
}
}
输出：
My String is: cool string, cool string and 88
正如您可以看到我们如何使用参数位置格式说明符在format()方法中两次传递字符串"cool string"。
使用字符串format()填充字符串
在这个例子中，我们用 0 填充一个数字并将数字转换为格式化的字符串。在上面的例子中，我们已经格式化了浮点数和字符串，在这个例子中，我们正在格式化一个整数。要记住的重要一点是，这些格式说明符是不同的。
%s- 对于字符串%f- 对于浮点数%d- 对于整数
public class Example{
public static void main(String args[]){
int str = 88;
/* Left padding an integer number with 0's and converting it
* into a String using Java String format() method.
*/
String formattedString = String.format("%05d", str);
System.out.println(formattedString);
}
}
输出：
00088
使用format()方法显示String，int，hexadecimal，float，char，octal值
在以下示例中，我们使用不同的格式说明符来显示不同类型的值。这里我们展示了一些如何使用format()方法将整数值转换为八进制或十六进制值的示例。在此示例之后，我们共享了可用格式说明符的列表。
public class JavaExample {
public static void main(String[] args) {
String str1 = String.format("%d", 15); // Integer value
String str2 = String.format("%s", "BeginnersBook.com"); // String
String str3 = String.format("%f", 16.10); // Float value
String str4 = String.format("%x", 189); // Hexadecimal value
String str5 = String.format("%c", 'P'); // Char value
String str6 = String.format("%o", 189); // Octal value
System.out.println(str1);
System.out.println(str2);
System.out.println(str3);
System.out.println(str4);
System.out.println(str5);
System.out.println(str6);
}
}
输出：
Java 字符串格式说明符
%c- 字符%d- 整数%s- 字符串%o- 八进制%x- 十六进制%f- 浮点数%h- 一个哈希码值
相关文章：
参考：
Java - String toCharArray()方法
原文： https://beginnersbook.com/2013/12/java-string-tochararray-method-example/
方法toCharArray()在将String转换为字符序列后返回字符的Array。返回的数组长度等于String的长度，Array中的字符序列与String中的字符序列匹配。
public char[] toCharArray()
示例：toCharArray()方法
在这个例子中，我们使用toCharArray()方法将String转换为char数组。
public class CharArrayExample{
public static void main(String args[]){
String str = new String("Welcome to BeginnersBook.com");
char[] array= str.toCharArray();
System.out.print("Content of Array:");
for(char c: array){
System.out.print(c);
}
}
}
输出：
Content of Array:Welcome to BeginnersBook.com
Java - String copyValueOf()方法
原文： https://beginnersbook.com/2013/12/java-string-copyvalueof-method-example/
方法copyValueOf()用于将字符数组复制到String。这里需要注意的是，此方法不会将内容附加到String中，而是将现有的字符串值替换为数组的字符序列。
它有两个变种：
1）static copyValueOf(char[] data)：它将整个数组（数据）复制到字符串。
2）static String copyValueOf(char[] data, int offset, int count)：它使用指定的偏移量和计数值仅将指定的字符复制到字符串。offset是需要复制字符的初始索引，count是要复制的字符数。对于例如offset 2 和count 3 将被解释为：数组从第 2 个索引开始的仅仅 3 个字符（第 3 个位置因为索引从 0 开始）应该被复制到相关的String。
例
在这个例子中，我们有两个字符串str1和str2和一个名为data的字符数组。我们使用方法copyValueOf()的变体将数组复制到字符串。
public class CopyValueOfExample {
public static void main(String args[]) {
char[] data = {'a','b','c','d','e','f','g','h','i','j','k'};
String str1 = "Text";
String str2 = "String";
//Variation 1:String copyValueOf(char[] data)
str1 = str1.copyValueOf(data);
System.out.println("str1 after copy: " + str1);
//Variation 2:String copyValueOf(char[] data,int offset,int count)
str2 = str2.copyValueOf(data, 5, 3 );
System.out.println("str2 after copy: " + str2);
}
}
输出：
str1 after copy: abcdefghijk
str2 after copy: fgh
Java - String getChars()方法
原文： https://beginnersbook.com/2013/12/java-string-getchars-method-example/
方法getChars()用于将String字符复制到字符数组。
public void getChars(int srcBegin, int srcEnd, char[] dest, int destBegin)
参数说明：
srcBegin - 要复制的字符串中第一个字符的索引。
srcEnd - 要复制的字符串中最后一个字符后的索引。
dest - 目标字符数组，其中String中的字符被复制。
destBegin - 数组中的索引，从字符将被推入数组开始。
抛出IndexOutOfBoundsException - 如果出现以下任何一种情况：
（srcBegin < 0）srcBegin小于零。
（srcBegin > srcEnd）srcBegin大于srcEnd。
（srcEnd > string.length）srcEnd大于此字符串的长度。
（destBegin < 0）destBegin为负。
dstBegin+(srcEnd-srcBegin)大于dest.length。
示例：getChars()方法
public class GetCharsExample{
public static void main(String args[]){
String str = new String("This is a String Handling Tutorial");
char[] array = new char[6];
str.getChars(10, 16, array, 0);
System.out.println("Array Content:" );
for(char temp: array){
System.out.print(temp);
}
char[] array2 = new char[]{'a','a','a','a','a','a','a','a'};
str.getChars(10, 16, array2, 2);
System.out.println("Second Array Content:" );
for(char temp: array2){
System.out.print(temp);
}
}
}
输出：
Array Content:
StringSecond Array Content:
aaString
Java String valueOf()方法
原文： https://beginnersbook.com/2017/10/java-string-valueof-method/
Java String valueOf()方法返回boolean，char，char数组，int，long，float和double参数的String表示形式。对于每种类型的参数，我们有不同版本的此方法。
java 字符串valueOf()方法的不同变体
public static String valueOf(boolean b): Used for converting boolean value to a String
public static String valueOf(char c): char to String
public static String valueOf(int i): int to String
public static String valueOf(long l): long to String
public static String valueOf(float f): float to String
public static String valueOf(double d): double to String
Java String valueOf()简单示例
让我们举一个简单的例子来理解这种方法的用法。在这个例子中，我们将double nines连接到给定值的末尾。给定的值是一个整数，为了在整数的末尾附加 99，我们必须首先将给定的整数转换为字符串。我们使用valueOf()方法将number转换为等效字符串str，然后我们将 99 转换并连接 到字符串末尾。
public class JavaExample{
public static void main(String args[]){
int number = 23;
String str = String.valueOf(number);
System.out.println(str+99);
}
}
输出：
方法valueOf()示例 2
在此示例中，我们使用valueOf()方法将数组转换为字符串。
public class JavaExample{
public static void main(String args[]){
char vowel[] = {'A', 'E', 'I', 'O', 'U'};
String str = String.valueOf(vowel);
System.out.println(str);
}
}
输出：
Java String valueOf()示例
让我们举个例子，我们使用了valueOf()方法的所有变体。在这个例子中，我们使用valueOf()方法将int，float，long，double，char和char数组转换为String。
public class Example{
public static void main(String args[]){
int i = 10; //int value
float f = 10.10f; //float value
long l = 111L; //long value
double d = 2222.22; //double value
char ch = 'A'; //char value
char array[] = {'a', 'b', 'c'}; //char array
//converting int to String
String str1 = String.valueOf(i);
//converting float to String
String str2 = String.valueOf(f);
//converting long to String
String str3 = String.valueOf(l);
//converting double to String
String str4 = String.valueOf(d);
//converting char to String
String str5 = String.valueOf(ch);
//converting char array to String
String str6 = String.valueOf(array);
System.out.println(str1);
System.out.println(str2);
System.out.println(str3);
System.out.println(str4);
System.out.println(str5);
System.out.println(str6);
}
}
输出：
10
10.1
111
2222.22
A
abc
参考：String valueOf()方法 - JavaDoc
Java - String contentEquals()方法
原文： https://beginnersbook.com/2013/12/java-string-contentequals-method-example/
方法contentEquals()将String与String Buffer进行比较并返回一个布尔值。如果String与String缓冲区匹配，则返回true，否则返回false。
boolean contentEquals(StringBuffer sb)
例
在这个例子中，我们有两个字符串和两个字符串缓冲区。我们使用contentEquals()方法比较字符串和字符串缓冲区。这里我们通过直接调用System.out.println语句中的方法来显示结果。但是，您也可以将返回的值存储在布尔变量中，并进一步使用它：boolean var = str1.contentEquals(sb1);
public class ContentEqualsExample {
public static void main(String args[]) {
String str1 = "First String";
String str2 = "Second String";
StringBuffer str3 = new StringBuffer( "Second String");
StringBuffer str4 = new StringBuffer( "First String");
System.out.println("str1 equals to str3:"+str1.contentEquals(str3));
System.out.println("str2 equals to str3:"+str2.contentEquals(str3));
System.out.println("str1 equals to str4:"+str1.contentEquals(str4));
System.out.println("str2 equals to str4:"+str2.contentEquals(str4));
}
}
输出：
str1 equals to str3:false
str2 equals to str3:true
str1 equals to str4:true
str2 equals to str4:false
Java - String regionMatches()方法
原文： https://beginnersbook.com/2013/12/java-string-regionmatches-method-example/
方法regionMatches()测试两个字符串是否相等。使用此方法，我们可以将输入String的子字符串与指定String的子字符串进行比较。
两种变体：
public boolean regionMatches(int toffset, String other, int ooffset, int len)：区分大小写的测试。
public boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)：可以选择考虑或忽略大小写。
参数说明：
ignoreCase - 如果为true，则在比较字符时忽略大小写。
toffset - 此字符串中子区域的起始偏移量。
other - 字符串参数。
ooffset - 字符串参数中子区域的起始偏移量。
len - 要比较的字符数。
示例：regionMatches()方法
public class RegionMatchesExample{
public static void main(String args[]){
String str1 = new String("Hello, How are you");
String str2 = new String("How");
String str3 = new String("HOW");
System.out.print("Result of Test1: " );
System.out.println(str1.regionMatches(7, str2, 0, 3));
System.out.print("Result of Test2: " );
System.out.println(str1.regionMatches(7, str3, 0, 3));
System.out.print("Result of Test3: " );
System.out.println(str1.regionMatches(true, 7, str3, 0, 3));
}
}
输出：
Result of Test1: true
Result of Test2: false
Result of Test3: true
参考：
[regionMatches(int,java.lang.String,int,int)](https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#regionMatches(int, java.lang.String, int, int))
Java - String getBytes()方法
原文： https://beginnersbook.com/2013/12/java-string-getbytes-method-example/
getBytes()方法将给定的String编码为字节序列并返回字节数组。该方法可以以下两种方式使用：
public byte[] getBytes(String charsetName)：使用指定的字符集将String编码为字节序列，并返回这些字节的数组。抛出UnsupportedEncodingException - 如果不支持指定的字符集。
public byte[] getBytes()：它使用默认的charset对String进行编码。
示例：getBytes()方法
import java.io.*;
public class GetBytesExample{
public static void main(String args[]){
String str = new String("Hello");
byte[] array1 = str.getBytes();
System.out.print("Default Charset encoding:");
for(byte b: array1){
System.out.print(b);
}
System.out.print("\nUTF-16 Charset encoding:");
try{
byte [] array2 = str.getBytes("UTF-16");
for(byte b1: array2){
System.out.print(b1);
}
byte [] array3 = str.getBytes("UTF-16BE");
System.out.print("\nUTF-16BE Charset encoding:");
for(byte b2: array3){
System.out.print(b2);
}
}catch(UnsupportedEncodingException ex){
System.out.println("Unsupported character set"+ex);
}
}
}
输出：
Default Charset encoding:72101108108111
UTF-16 Charset encoding:-2-10720101010801080111
UTF-16BE Charset encoding:0720101010801080111
在上面的例子中，我们使用字符集UTF -16和UTF - 16BE进行了编码，还有许多其他标准字符集，如：
US-ASCII：七位 ASCII，又称 ISO646-US，又称 Unicode 字符集的 Basic Latin 块ISO-8859-1：ISO 拉丁字母第 1 号，又称 ISO-LATIN-1UTF-8：8 位 UCS 转换格式UTF-16BE：16 位 UCS 转换格式，大端字节顺序UTF-16LE：16 位 UCS 转换格式，小端字节顺序UTF-16：16 位 UCS 转换格式，字节顺序由可选字节顺序标记标识。
参考：
Java String length()方法
原文： https://beginnersbook.com/2013/12/java-string-length-method-example/
Java String length()方法用于查找String的长度。此方法计算String中包含空格的字符数，并返回计数。
Java String length()方法
int length()
此方法返回一个整数，表示给定字符串（包括空格）中的字符数（长度）。
字符串长度限制：字符串可以具有的最大长度为：2 ** 31 - 1。
Java String length()方法示例
在这个例子中，我们有三个不同的字符串，我们使用length()方法找出它们的长度
public class LengthExample{
public static void main(String args[]) {
String str1= new String("Test String");
String str2= new String("Chaitanya");
String str3= new String("BeginnersBook");
System.out.println("Length of str1:"+str1.length());
System.out.println("Length of str2:"+str2.length());
System.out.println("Length of str3:"+str3.length());
}
}
输出：
Length of str1:11
Length of str2:9
Length of str3:13
Java String length()方法计算没有空格的String的长度
正如我们在上面的例子中已经看到的那样，这个方法在计算给定字符串中的字符数时计算空格。如果您只想计算字符串中除空白字符之外的字符数，那么您可以使用字符串替换方法来完成此操作，如下例所示。
这里我们使用replace方法省略给定String中的空格，然后在其上使用length()方法。
在这里，我们使用replace()方法替换所有空格（删除它们），然后在更新的字符串上使用length方法。
public class JavaExample {
public static void main(String[] args) {
String str = "hi guys this is a string";
//length of the String
System.out.println("Length of the String: "+str.length());
//length of the String without white spaces
System.out.println("Length of String without spaces: "+
str.replace(" ", "").length());
}
}
输出：
Java - String matches()方法
原文： https://beginnersbook.com/2013/12/java-string-matches-method-example/
方法matches()检查String是否与指定的正则表达式匹配。如果String适合指定的正则表达式，则此方法返回true，否则返回false。以下是该方法的语法：
public boolean matches(String regex)
它会抛出PatternSyntaxException - 如果指定的正则表达式无效。
示例：matches()方法
在这个例子中，我们有一个String和三个正则表达式。我们使用matches()方法将正则表达式（regex）与输入String进行匹配。
public class MatchesExample{
public static void main(String args[]){
String str = new String("Java String Methods");
System.out.print("Regex: (.*)String(.*) matches string? " );
System.out.println(str.matches("(.*)String(.*)"));
System.out.print("Regex: (.*)Strings(.*) matches string? " );
System.out.println(str.matches("(.*)Strings(.*)"));
System.out.print("Regex: (.*)Methods matches string? " );
System.out.println(str.matches("(.*)Methods"));
}
}
输出：
Regex: (.*)String(.*) matches string? true
Regex: (.*)Strings(.*) matches string? false
Regex: (.*)Methods matches string? true
流行的 Java 字符串教程
Java Stringequals()和equalsIgnoreCase()方法
原文： https://beginnersbook.com/2013/12/java-string-equals-and-equalsignorecase-methods-example/
在本教程中，我们将讨论equals()和equalsIgnoreCase()方法。这两种方法都用于比较两个字符串。它们之间的唯一区别是equals()方法考虑了大小写，而equalsIgnoreCase()方法在比较期间忽略了大小写。对于例如如果我们比较字符串"TEXT"和"text"，equals()方法将返回false，但equalsIgnoreCase()将返回true。
boolean equals(String str)：区分大小写
boolean equalsIgnoreCase(String str)：不区分大小写
Java String equals()方法示例
在这个例子中，我们将看到equals()方法在不同场景中的工作原理。我们可以使用equals()方法比较两个String实例（str1，str2，str3），就像我们在下面的例子中所做的那样，或者我们也可以比较字符串实例和作为参数传递给equals()方法的硬编码字符串，如以下示例。
您可以在输出中观察到，当我们将String str1（值"Hello"）与字符串"hello"进行比较时，equals()方法返回false，因为此方法区分大小写并在比较字符串时考虑了大小写。另一方面，equalsIgnoreCase()方法在忽略它们的情况时比较字符串，我们将在下一节中看到。
public class JavaExample{
public static void main(String args[]){
String str1= new String("Hello");
String str2= new String("Hi");
String str3= new String("Hello");
System.out.println("str1 equals to str2:"+str1.equals(str2));
System.out.println("str1 equals to str3:"+str1.equals(str3));
System.out.println("str1 equals to Welcome:"+str1.equals("Welcome"));
System.out.println("str1 equals to Hello:"+str1.equals("Hello"));
System.out.println("str1 equals to hello:"+str1.equals("hello"));
}
}
输出：
Java String equalsIgnoreCase()方法示例
方法equalsIgnoreCase()在比较两个字符串时忽略大小写。在下面的示例中，我们将字符串"Apple"与字符串"APPLE"进行了比较，并返回true。
public class JavaExample{
public static void main(String args[]){
String str1= new String("Apple");
String str2= new String("MANGO");
String str3= new String("APPLE");
System.out.println("str1 equals to str2:"+str1.equalsIgnoreCase(str2));
System.out.println("str1 equals to str3:"+str1.equalsIgnoreCase(str3));
System.out.println("str1 equals to Welcome:"+str1.equalsIgnoreCase("Welcome"));
System.out.println("str1 equals to Apple:"+str1.equalsIgnoreCase("Apple"));
System.out.println("str2 equals to mango:"+str2.equalsIgnoreCase("mango"));
}
}
输出：
如何在 Java 中将InputStream转换为字符串
原文： https://beginnersbook.com/2013/12/how-to-convert-inputstream-to-string-in-java/
以下是如何读取InputStream并将其转换为String的完整示例。涉及的步骤是：
1）我使用getBytes()方法 将文件内容转换为字节之后，使用包含内部缓冲区的ByteArrayInputStream初始化InputStream，缓冲区包含可以从流中读取的字节。
2）使用InputStreamReader读取InputStream 。
3）使用BufferedReader读取InputStreamReader。
4）将BufferedReader读取的每一行附加到StringBuilder对象上。
5）最后使用toString()方法将StringBuilder转换为String。
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
public class Example {
public static void main(String[] args) throws IOException {
InputStreamReader isr = null;
BufferedReader br = null;
InputStream is =
new ByteArrayInputStream("This is the content of my file".getBytes());
StringBuilder sb = new StringBuilder();
String content;
try {
isr = new InputStreamReader(is);
br = new BufferedReader(isr);
while ((content = br.readLine()) != null) {
sb.append(content);
}
} catch (IOException ioe) {
System.out.println("IO Exception occurred");
ioe.printStackTrace();
} finally {
isr.close();
br.close();
}
String mystring = sb.toString();
System.out.println(mystring);
}
}
输出：
This is the content of my file
参考：
String和StringBuffer之间的区别
原文： https://beginnersbook.com/2014/08/string-vs-stringbuffer/
在上一篇文章中，我们讨论了StringBuffer和StringBuilder之间的差异。在这里，我们将讨论String和StringBuffer类之间的差异。
String vs StringBuffer
1）可变性：字符串是不可变的（一旦创建，不能修改），而StringBuffer是可变的（可以修改）。
示例 - 字符串是不可变的：
String str = "Hello World";
str = "Hi World!";
通过查看此代码，您会说str的值已经改变，那么它如何变为不可变？让我解释一下：
在第一个语句中，使用字符串文字"Hello World"创建一个对象，在第二个语句中，当我们将新字符串文字"Hi World!"分配给str时，对象本身没有改变而是使用字符串文字"Hi World!"在内存中创建一个新对象，并将其引用分配给str。因此，基本上两个对象"Hello World"和"Hi World!"存在于具有不同引用（位置）的存储器中。
StringBuffer是可变的：
让我们看看StringBuffer的可变性
StringBuffer sb = new StringBuffer("Hello");
sb.append(" World");
在第一个语句中，StringBuffer对象是使用字符串文字"Hello"创建的，而在第二个语句中，对象的值从"Hello"更改为"Hello World"。与字符串不同，对象被修改而不是创建新对象。
2）性能：在执行连接时，您应该优先选择StringBuffer而不是String，因为它更快。原因是：当您使用String连接字符串时，实际上每次都创建新对象，因为String是不可变的。
StringBuffer的 java 文档说了什么：
一个线程安全，可变的字符序列。字符串缓冲区就像一个String，但可以修改。在任何时间点它都包含一些特定的字符序列，但序列的长度和内容可以通过某些方法调用来改变。
Java String compareTo()方法
原文： https://beginnersbook.com/2013/12/java-string-compareto-method-example/
Java String compareTo()方法用于按字典顺序比较两个字符串。两个字符串的每个字符都转换为 Unicode 值以进行比较。如果两个字符串都相等，则此方法返回 0，否则返回正值或负值。如果第一个字符串按字典顺序大于第二个字符串，则结果为正，否则结果为负。
Java String compareTo()方法
我们有以下两种使用compareTo()方法的方法：
int compareTo(String str)
这里比较字符串。例如string1.compareTo(string2)，其中string1和string2是String。
int compareTo(Object obj)
这里比较是在字符串和对象之间。例如string1.compareTo("Just a String object")，其中string1是一个字符串，它的值与方法参数中指定的字符串进行比较。
Java String compareTo()方法示例
这里我们有三个字符串，我们使用compareTo()方法将它们相互比较。
public class CompareToExample {
public static void main(String args[]) {
String str1 = "String method tutorial";
String str2 = "compareTo method example";
String str3 = "String method tutorial";
int var1 = str1.compareTo( str2 );
System.out.println("str1 & str2 comparison: "+var1);
int var2 = str1.compareTo( str3 );
System.out.println("str1 & str3 comparison: "+var2);
int var3 = str2.compareTo("compareTo method example");
System.out.println("str2 & string argument comparison: "+var3);
}
}
输出：
str1 & str2 comparison: -16
str1 & str3 comparison: 0
str2 & string argument comparison: 0
如何使用String compareTo()方法查找字符串的长度
在这里，我们将看到一个有趣的示例，说明如何使用compareTo()方法来查找字符串的长度。如果我们使用compareTo()方法将字符串与空字符串进行比较，则该方法将返回非空字符串的长度。
例如：
String str1 = "Negan";
String str2 = ""; //empty string
//it would return the length of str1 in positive number
str1.compareTo(str2); // 5
//it would return the length of str1 in negative number
str2.compareTo(str1); //-5
在上面的代码片段中，第二个compareTo()语句以负数返回长度，这是因为我们将空字符串与str1进行了比较，而在第一个compareTo()语句中，我们将str1与空字符串进行了比较。
让我们看看完整的例子：
public class JavaExample {
public static void main(String args[]) {
String str1 = "Cow";
//This is an empty string
String str2 = "";
String str3 = "Goat";
System.out.println(str1.compareTo(str2));
System.out.println(str2.compareTo(str3));
}
}
输出：
Java String compareTo()方法区分大小写吗？
在这个例子中，我们将使用compareTo()方法比较两个字符串。两个字符串都相同，但其中一个字符串为大写，另一个字符串为小写。
public class JavaExample {
public static void main(String args[]) {
//uppercase
String str1 = "HELLO";
//lowercase
String str2 = "hello";;
System.out.println(str1.compareTo(str2));
}
}
输出：
如您所见，输出不为零，这意味着compareTo()方法区分大小写。但是我们在字符串类中有一个不区分大小写的比较方法，它是compareToIgnoreCase()，这个方法在比较两个字符串时忽略了大小写。
在 Java 中将String对象转换为Boolean对象
原文： https://beginnersbook.com/2014/07/convert-string-object-to-boolean-object-in-java/
描述
如何将String对象转换为Boolean对象。
例
在这个例子中，我们将看到String到Boolean对象转换的两种方法。
class StringObjToBooleanObj {
public static void main(String[] args) {
// String Objects
String str = "false";
// Case does not matter for conversion
String str2 = "TrUe";
/* Method 1: Using Constructor -
* Passing string value to the constructor
* of Boolean class.
*/
Boolean bobj = new Boolean(str);
Boolean bobj2 = new Boolean(str2);
System.out.println(bobj);
System.out.println(bobj2);
/* Method 2: Using valueOf() method of
* Boolean class
*/
Boolean bobj3 = Boolean.valueOf(str);
Boolean bobj4 = Boolean.valueOf(str2);
System.out.println(bobj3);
System.out.println(bobj4);
}
}
输出：
false
true
false
true
public static Boolean valueOf(String s)：返回一个布尔值，其值由指定的字符串表示。返回的布尔值表示如果字符串参数不为null且与字符串"true"相等（忽略大小写），则返回true值。
来源： valueOf(String s)方法 - Boolean Javadoc
如何在 Java 中仅删除字符串的尾随空格
原文： https://beginnersbook.com/2014/07/how-to-remove-only-trailing-spaces-of-a-string-in-java/
在本教程中，我们将学习如何从字符串中修剪尾随空格而不是前导空格。这是完整的代码：
class TrimBlanksExample {
public static void main(String[] args) {
System.out.println("#"+trimTrailingBlanks(" How are you?? ")+"@");
System.out.println("#"+trimTrailingBlanks(" I'm Fine. ")+"@");
}
public static String trimTrailingBlanks( String str)
{
if( str == null)
return null;
int len = str.length();
for( ; len > 0; len--)
{
if( ! Character.isWhitespace( str.charAt( len - 1)))
break;
}
return str.substring( 0, len);
}
}
输出：
# How are [email protected]
# I'm [email protected]
正如您所看到的，字符串和"@"之间没有空格，表明已从字符串中删除了尾随空格。此外，输出中的"#"和String之间有空格，表示不会从字符串中删除前导空格。
参考：
substring()方法
charAt()方法
length()方法
isWhitespace()方法
java - 使用空格和零左填充字符串
原文： https://beginnersbook.com/2014/07/java-left-padding-a-string-with-spaces-and-zeros/
在本教程中，我们将看到如何使用空格和零来填充字符串：
1）使用空格左填充
class LeftPaddingExample1 {
public static void main(String[] args) {
System.out.println("#" + padLeftSpaces("mystring", 10) + "@");
System.out.println("#" + padLeftSpaces("mystring", 15) + "@");
System.out.println("#" + padLeftSpaces("mystring", 20) + "@");
}
public static String padLeftSpaces(String str, int n) {
return String.format("%1$" + n + "s", str);
}
}
输出：
# [email protected]
# [email protected]
# [email protected]
2）使用零左填充
class LeftPaddingExample2 {
public static void main(String[] args) {
System.out.println("#" + padLeftZeros("mystring", 10) + "@");
System.out.println("#" + padLeftZeros("mystring", 15) + "@");
System.out.println("#" + padLeftZeros("mystring", 20) + "@");
}
public static String padLeftZeros(String str, int n) {
return String.format("%1$" + n + "s", str).replace(' ', '0');
}
}
输出：
#[email protected]
#[email protected]
#[email protected]
java - 使用空格和零右填充字符串
原文： https://beginnersbook.com/2014/07/java-right-padding-a-string-with-spaces-and-zeros/
在本教程中，我们将看到如何正确填充带空格和零的字符串：
1）使用空格右填充
public class PadRightExample1 {
public static void main(String[] argv) {
System.out.println("#" + rightPadding("mystring", 10) + "@");
System.out.println("#" + rightPadding("mystring", 15) + "@");
System.out.println("#" + rightPadding("mystring", 20) + "@");
}
public static String rightPadding(String str, int num) {
return String.format("%1$-" + num + "s", str);
}
}
输出：
#mystring @
#mystring @
#mystring @
2）使用零右填充
public class PadRightExample2 {
public static void main(String[] argv) {
System.out.println("#" + rightPadZeros("mystring", 10) + "@");
System.out.println("#" + rightPadZeros("mystring", 15) + "@");
System.out.println("#" + rightPadZeros("mystring", 20) + "@");
}
public static String rightPadZeros(String str, int num) {
return String.format("%1$-" + num + "s", str).replace(' ', '0');
}
}
输出：
#[email protected]
#[email protected]
#[email protected]
Java 程序：在String中查找重复的字符
原文： https://beginnersbook.com/2014/07/java-program-to-find-duplicate-characters-in-a-string/
该程序将找出String中的重复字符并显示它们的计数。
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class Details {
public void countDupChars(String str){
//Create a HashMap
Map<Character, Integer> map = new HashMap<Character, Integer>();
//Convert the String to char array
char[] chars = str.toCharArray();
/* logic: char are inserted as keys and their count
* as values. If map contains the char already then
* increase the value by 1
*/
for(Character ch:chars){
if(map.containsKey(ch)){
map.put(ch, map.get(ch)+1);
} else {
map.put(ch, 1);
}
}
//Obtaining set of keys
Set<Character> keys = map.keySet();
/* Display count of chars if it is
* greater than 1\. All duplicate chars would be
* having value greater than 1.
*/
for(Character ch:keys){
if(map.get(ch) > 1){
System.out.println("Char "+ch+" "+map.get(ch));
}
}
}
public static void main(String a[]){
Details obj = new Details();
System.out.println("String: BeginnersBook.com");
System.out.println("-------------------------");
obj.countDupChars("BeginnersBook.com");
System.out.println("\nString: ChaitanyaSingh");
System.out.println("-------------------------");
obj.countDupChars("ChaitanyaSingh");
System.out.println("\nString: #@[email protected]!#$%!!%@");
System.out.println("-------------------------");
obj.countDupChars("#@[email protected]!#$%!!%@");
}
}
输出：
String: BeginnersBook.com
-------------------------
Char e 2
Char B 2
Char n 2
Char o 3
String: ChaitanyaSingh
-------------------------
Char a 3
Char n 2
Char h 2
Char i 2
String: #@[email protected]!#$%!!%@
-------------------------
Char # 2
Char ! 3
Char @ 3
Char $ 2
Char % 2
参考：
如何在 Java 中将字符串转换为字符
原文： https://beginnersbook.com/2014/06/how-to-convert-char-to-string-and-a-string-to-char-in-java/
在本教程中，我们将看到char到String和String到char转换的程序。
将char转换为String的程序
我们有以下两种方式进行字符串转换。
方法 1：使用toString()方法
方法 2：使用valueOf()方法
class CharToStringDemo
{
public static void main(String args[])
{
// Method 1: Using toString() method
char ch = 'a';
String str = Character.toString(ch);
System.out.println("String is: "+str);
// Method 2: Using valueOf() method
String str2 = String.valueOf(ch);
System.out.println("String is: "+str2);
}
}
输出：
String is: a
String is: a
将字符串转换为字符
我们可以使用String类的charAt()方法将String转换为char。
class StringToCharDemo
{
public static void main(String args[])
{
// Using charAt() method
String str = "Hello";
for(int i=0; i<str.length();i++){
char ch = str.charAt(i);
System.out.println("Character at "+i+" Position: "+ch);
}
}
}
输出：
Character at 0 Position: H
Character at 1 Position: e
Character at 2 Position: l
Character at 3 Position: l
Character at 4 Position: o
如何在 Java 中将char数组转换为字符串？
原文： https://beginnersbook.com/2014/06/how-to-convert-a-char-array-to-a-string-in-java/
在 Java 中有两种方法将char数组（char[]）转换为String：
1）通过将数组名称传递给构造函数
来创建String对象
2）使用String 类的valueOf()方法 。
示例：
此示例演示了上述将char数组转换为String的方法。这里我们有一个char数组ch，我们使用char数组创建了两个字符串str和str1。
class CharArrayToString
{
public static void main(String args[])
{
// Method 1: Using String object
char[] ch = {'g', 'o', 'o', 'd', ' ', 'm', 'o', 'r', 'n', 'i', 'n', 'g'};
String str = new String(ch);
System.out.println(str);
// Method 2: Using valueOf method
String str2 = String.valueOf(ch);
System.out.println(str2);
}
}
输出：
good morning
good morning
在 Java 中将String转换为日期
原文： https://beginnersbook.com/2013/04/java-string-to-date-conversion/
在本教程中，我们将了解如何在 Java 中将String转换为Date。
将字符串转换为日期：函数
在本节之后，我分享了一个完整的示例，以各种日期格式演示String到Date的转换。对于那些只想要这个转换函数的人来说，这里是函数代码：
public Date convertStringToDate(String dateString)
{
Date date = null;
Date formatteddate = null;
DateFormat df = new SimpleDateFormat("dd-MMM-yyyy");
try{
date = df.parse(dateString);
formatteddate = df.format(date);
}
catch ( Exception ex ){
System.out.println(ex);
}
return formatteddate;
}
字符串到日期转换的示例程序
package beginnersbook.com;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
public class StringToDateDemo{
public static void main(String args[])
{
String testDateString = "02/04/2014";
String testDateString2 = "02-04-2014 23:37:50";
String testDateString3 = "02-Apr-2014";
String testDateString4 = "04 02, 2014";
String testDateString5 = "Thu, Apr 02 2014";
String testDateString6 = "Thu, Apr 02 2014 23:37:50";
DateFormat df = new SimpleDateFormat("dd/MM/yyyy");
DateFormat df2 = new SimpleDateFormat("dd-MM-yyyy HH:mm:ss");
DateFormat df3 = new SimpleDateFormat("dd-MMM-yyyy");
DateFormat df4 = new SimpleDateFormat("MM dd, yyyy");
DateFormat df5 = new SimpleDateFormat("E, MMM dd yyyy");
DateFormat df6 = new SimpleDateFormat("E, MMM dd yyyy HH:mm:ss");
try
{
//format() method Formats a Date into a date/time string.
Date d1 = df.parse(testDateString);
System.out.println("Date: " + d1);
System.out.println("Date in dd/MM/yyyy format is: "+df.format(d1));
Date d2 = df2.parse(testDateString2);
System.out.println("Date: " + d2);
System.out.println("Date in dd-MM-yyyy HH:mm:ss format is: "+df2.format(d2));
Date d3 = df3.parse(testDateString3);
System.out.println("Date: " + d3);
System.out.println("Date in dd-MMM-yyyy format is: "+df3.format(d3));
Date d4 = df4.parse(testDateString4);
System.out.println("Date: " + d4);
System.out.println("Date in MM dd, yyyy format is: "+df4.format(d4));
Date d5 = df5.parse(testDateString5);
System.out.println("Date: " + d5);
System.out.println("Date in E, MMM dd yyyy format is: "+df5.format(d5));
Date d6 = df6.parse(testDateString6);
System.out.println("Date: " + d6);
System.out.println("Date in E, E, MMM dd yyyy HH:mm:ss format is: "+df6.format(d6));
}
catch (Exception ex ){
System.out.println(ex);
}
}
}
输出：
Date: Wed Apr 02 00:00:00 IST 2014
Date in dd/MM/yyyy format is: 02/04/2014
Date: Wed Apr 02 23:37:50 IST 2014
Date in dd-MM-yyyy HH:mm:ss format is: 02-04-2014 23:37:50
Date: Wed Apr 02 00:00:00 IST 2014
Date in dd-MMM-yyyy format is: 02-Apr-2014
Date: Wed Apr 02 00:00:00 IST 2014
Date in MM dd, yyyy format is: 04 02, 2014
Date: Wed Apr 02 00:00:00 IST 2014
Date in E, MMM dd yyyy format is: Wed, Apr 02 2014
Date: Wed Apr 02 23:37:50 IST 2014
Date in E, E, MMM dd yyyy HH:mm:ss format is: Wed, Apr 02 2014 23:37:50
参考：
在 Java 中将Date转换为String
原文： https://beginnersbook.com/2013/05/java-date-string-conversion/
我们之前看过，如何在 Java 中将String转换为Date。这篇文章是该文章的延续，在这里我们将学习 Java 中的Date到String转换。
Java 代码：将日期转换为字符串
在本节之后，我已经共享了Date到String转换的完整代码。以下函数将Date转换为String。在下面的函数中，我使用了格式dd/MM/yyyy，但是如果你想要任何其他格式的结果，那么你可以简单地修改SimpleDateFormat中的模式。您也可以参考 Java 中关于日期格式的文章之一。
函数：
public String convertStringToDate(Date indate)
{
String dateString = null;
SimpleDateFormat sdfr = new SimpleDateFormat("dd/MMM/yyyy");
/*you can also use DateFormat reference instead of SimpleDateFormat
* like this: DateFormat df = new SimpleDateFormat("dd/MMM/yyyy");
*/
try{
dateString = sdfr.format( indate );
}catch (Exception ex ){
System.out.println(ex);
}
return dateString;
}
完成Date到String转换的示例程序
在这个例子中，我将当前日期作为输入并转换为String。为了获得各种格式的输出字符串，我在SimpleDateFormat中指定了不同的两个模式。
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateToStringDemo{
public static void main(String args[])
{
Date todaysDate = new Date();
DateFormat df = new SimpleDateFormat("dd/MM/yyyy");
DateFormat df2 = new SimpleDateFormat("dd-MM-yyyy HH:mm:ss");
DateFormat df3 = new SimpleDateFormat("dd-MMM-yyyy");
DateFormat df4 = new SimpleDateFormat("MM dd, yyyy");
DateFormat df5 = new SimpleDateFormat("E, MMM dd yyyy");
DateFormat df6 = new SimpleDateFormat("E, MMM dd yyyy HH:mm:ss");
try
{
//format() method Formats a Date into a date/time string.
String testDateString = df.format(todaysDate);
System.out.println("String in dd/MM/yyyy format is: " + testDateString);
String str2 = df2.format(todaysDate);
System.out.println("String in dd-MM-yyyy HH:mm:ss format is: " + str2);
String str3 = df3.format(todaysDate);
System.out.println("String in dd-MMM-yyyy format is: " + str3);
String str4 = df4.format(todaysDate);
System.out.println("String in MM dd, yyyy format is: " + str4);
String str5 = df5.format(todaysDate);
System.out.println("String in E, MMM dd yyyy format is: " + str5);
String str6 = df6.format(todaysDate);
System.out.println("String in E, E, MMM dd yyyy HH:mm:ss format is: " + str6);
}
catch (Exception ex ){
System.out.println(ex);
}
}
}
输出：
String in dd/MM/yyyy format is: 02/01/2014
String in dd-MM-yyyy HH:mm:ss format is: 02-01-2014 22:38:35
String in dd-MMM-yyyy format is: 02-Jan-2014
String in MM dd, yyyy format is: 01 02, 2014
String in E, MMM dd yyyy format is: Thu, Jan 02 2014
String in E, E, MMM dd yyyy HH:mm:ss format is: Thu, Jan 02 2014 22:38:35
参考：
Java - ASCII 到String的转换
原文： https://beginnersbook.com/2015/05/java-ascii-to-string-conversion/
在本教程中，我们将学习如何将 ASCII 值转换为String。
示例：将 ASCII 转换为String
这是完整的代码，其中我们有一个 ASCII 值数组，我们将它们转换为相应的char值，然后使用Character类的toString()方法将这些字符转换为字符串。
package com.beginnersbook.string;
public class ASCIIToString {
public static void main(String args[]){
int num[] = {65, 120, 98, 75, 115};
String str =null;
for(int i: num){
str = Character.toString((char)i);
System.out.println(str);
}
}
}
输出：
A
x
b
K
s
Java String compareToIgnoreCase()方法
原文： https://beginnersbook.com/2013/12/java-string-comparetoignorecase-method-example/
Java String compareToIgnoreCase()方法按字典顺序比较两个字符串，如果它们相等则返回 0。正如我们所知compareTo()方法做同样的事情，但这两种方法之间存在差异。与compareTo()方法不同，compareToIgnoreCase()方法在比较字符串时忽略大小写（大写或小写）。
Java String compareToIgnoreCase()方法
方法签名：
int compareToIgnoreCase(String str)
例如：
String s1 = "BEGINNERSBOOK"; //uppercase
String s2 = "beginnersBOOK"; //mixedcase
s1.compareTo(s2); //this would return non-zero value
s1.compareToIgnoreCase(s2); //this would return zero
与compareTo()方法类似，compareToIgnoreCase()方法根据每个字符的 Unicode 值比较字符串。当字符串相等时返回 0，否则返回正值或负值。
Java String compareToIgnoreCase()示例
在下面的示例中，我们有三个字符串，所有三个字符串都相同，但它们的字母大小写不同。string1是大写字母，string2是小写字母，string3是大写和小写字母的混合。我们使用compareToIgnoreCase()方法来比较这些字符串。
public class CompareExample {
public static void main(String args[]) {
String string1 = "HELLO";
String string2 = "hello";
String string3 = "HellO";
int var1 = string1.compareToIgnoreCase(string2);
System.out.println("string1 and string2 comparison: "+var1);
int var2 = string1.compareToIgnoreCase(string3);
System.out.println("string1 and string3 comparison: "+var2);
int var3 = string1.compareToIgnoreCase("HeLLo");
System.out.println("string1 and HeLLo comparison: "+var3);
}
}
输出：
string1 and string2 comparison: 0
string1 and string3 comparison: 0
string1 and HeLLo comparison: 0
Java String compareToIgnoreCase() vs compareTo()示例
让我们举一个例子来理解这两种方法之间的区别。这里我们比较两个字符串，它们是相同的，但它们的字母大小写不同。其中一个字符串为大写，第二个字符串为小写。
public class JavaExample {
public static void main(String args[]) {
//uppercase
String str1 = "HELLO";
//lowercase
String str2 = "hello";
System.out.println(str1.compareTo(str2));
System.out.println(str1.compareToIgnoreCase(str2));
}
}
输出：
Java - float到String的转换
我们可以使用以下两种方法中的任何一种将float转换为String：
1）方法 1：使用String.valueOf(float f)：我们将float值作为参数传递给该方法它返回它的字符串表示形式。
方法声明：
public static String valueOf(float f)
参数：
f - 表示我们要转换为String的float值
返回：
表示浮点数f的字符串
float fvar = 1.17f;
String str = String.valueOf(fvar);
2）方法 2：使用Float.toString(float f)：此方法与String.valueOf(float)方法的工作方式类似，只是它属于Float类。此方法获取浮点值并将其转换为其字符串表示形式。对于例如如果我们将浮点值1.07f传递给此方法，它将返回字符串"1.07"作为输出。
方法声明：
public static String toString（float f）
参数：
f - 浮点值
返回：
表示f的字符串。
float fvar2 = -2.22f;
String str2 = Float.toString(fvar2);
示例：将float转换为String
在这个程序中，我们有两个浮点变量，我们使用不同的两个方法将它们转换为字符串。我们使用valueOf(float)方法将第一个float变量转换为string，而我们使用toString(float)方法转换第二个float变量。该实施例说明了上述两种方法的使用。
package com.beginnersbook.string;
public class FloatToString {
public static void main(String[] args) {
/* Method 1: using valueOf() method
* of String class.
*/
float fvar = 1.17f;
String str = String.valueOf(fvar);
System.out.println("String is: "+str);
/* Method 2: using toString() method
* of Float class
*/
float fvar2 = -2.22f;
String str2 = Float.toString(fvar2);
System.out.println("String2 is: "+str2);
}
}
输出：
String is: 1.17
String2 is: -2.22
Java - StackTrace到String的转换
原文： https://beginnersbook.com/2015/05/java-stacktrace-to-string-conversion/
有时我们想将发生的异常转换为String。在下面的程序中，我们使用Throwable.printStackTrace(PrintWriter pw)将stacktrace转换为String。
示例：将Exception StackTrace转换为String
package com.beginnersbook.string;
import java.io.PrintWriter;
import java.io.StringWriter;
public class StacktraceToString {
public static void main(String args[]){
try{
int i =5/0;
System.out.println(i);
}catch(ArithmeticException e){
/* This block of code would convert the
* stacktrace to string by using
* Throwable.printStackTrace(PrintWriter pw)
* which sends the stacktrace to the writer
* that we can convert to string using tostring()
*/
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
e.printStackTrace(pw);
String stacktraceString = sw.toString();
System.out.println("String is: "+stacktraceString);
}
}
}
输出：
String is: java.lang.ArithmeticException: / by zero
at com.beginnersbook.string.StacktraceToString.main(StacktraceToString.java:8)
Java - Writer到String的转换
原文： https://beginnersbook.com/2015/05/java-writer-to-string-conversion/
package com.beginnersbook.string;
import java.io.StringWriter;
public class WriterToString {
public static void main(String args[]){
// create a new writer
StringWriter sw = new StringWriter();
// append a char
sw.append("abc");
sw.append(" xyz");
String str = sw.toString();
System.out.println(str);
}
}
输出：
abc xyz
Java - String到ArrayList转换
原文： https://beginnersbook.com/2015/05/java-string-to-arraylist-conversion/
在这个 java 教程中，我们将String转换为ArrayList。转换的步骤如下：
1）首先使用String split()方法分割字符串，并将子字符串分配给字符串数组。我们可以根据任何字符，表达式等拆分字符串。
2）创建ArrayList并使用Arrays.asList()方法将字符串数组的元素复制到新创建的ArrayList。此方法返回基于指定数组的元素创建的列表。
将String转换为ArrayList的程序
在这个 java 程序中，我们有一个字符串，其中包含一些带分隔符的数字作为逗号（,）。我们基于分隔符拆分字符串，然后将这些数字分配给字符串数组。
稍后我们使用Arrays的asList()方法将字符串数组的所有元素复制到ArrayList。
import java.util.ArrayList;
import java.util.List;
import java.util.Arrays;
public class JavaExample {
public static void main(String args[]){
String num = "22,33,44,55,66,77";
String str[] = num.split(",");
List<String> al = new ArrayList<String>();
al = Arrays.asList(str);
for(String s: al){
System.out.println(s);
}
}
}
输出：
22
33
44
55
66
77
注意：在上面的例子中，分隔符是逗号但是我们可以根据任何分隔符分割字符串。例如 - 如果字符串是"hello hi namaste bye"，那么我们可以使用空格作为分隔符来拆分字符串，如下所示 -
Here we have provided whitespace as delimiter
String str[] = num.split(" ");
Java String startsWith()方法
原文： https://beginnersbook.com/2013/12/java-string-startswith-method-example/
字符串类的startsWith()方法用于检查字符串的前缀。它根据给定的字符串是否以指定的字母或单词开头，返回布尔值true或false。
例如：
String str = "Hello";
//This will return true because string str starts with "He"
str.startsWith("He");
Java String startsWith()方法
StarsWith()方法有两种变体。
boolean startsWith(String str)：如果String str是String的前缀，则返回true。
boolean startsWith(String str, index fromIndex)：如果String以str开头，则返回true，它从指定的索引fromIndex开始查找。例如，假设String s的值是"Hi there"，我们调用这样的starsWith()方法 - s.startsWith("there", 3)然后这将返回true，因为我们已经将值 3 作为fromIndex传递，搜索关键字"there"从给定字符串s的索引 3 开始，并在字符串s的开头找到。
startsWith()方法的一个简单示例
这是一个简单的例子，我们有一个字符串s，我们正在使用startsWith()方法检查字符串s是否以特定的单词开头。
public class JavaExample{
public static void main(String args[]){
//given string
String s = "This is just a sample string";
//checking whether the given string starts with "This"
System.out.println(s.startsWith("This"));
//checking whether the given string starts with "Hi"
System.out.println(s.startsWith("Hi"));
}
}
输出：
Java String startsWith()方法示例
让我们举一个例子，我们使用startsWith()方法的两种变体。
public class StartsWithExample{
public static void main(String args[]) {
String str= new String("quick brown fox jumps over the lazy dog");
System.out.println("String str starts with quick: "+str.startsWith("quick"));
System.out.println("String str starts with brown: "+str.startsWith("brown"));
System.out.println("substring of str(starting from 6th index) has brown prefix: "
+str.startsWith("brown", 6));
System.out.println("substring of str(starting from 6th index) has quick prefix: "
+str.startsWith("quick", 6));
}
}
输出：
String str starts with quick: true
String str starts with brown: false
substring of str(starting from 6th index) has brown prefix: true
substring of str(starting from 6th index) has quick prefix: false
