Skip to content

B
beginnersbook-zh

OpenDocCN / beginnersbook-zh
10 个月 前同步成功

通知 0
Star 107
Fork 30
B
beginnersbook-zh

前往新版Gitcode，体验更适合开发者的 AI 搜索 >>

提交 6f32f2cb 编写于 作者: W wizardforcel
浏览文件
操作

2019-10-13 17:02:35

上级 83bfaa4f
隐藏空白更改
内联 并排
Showing with 115 addition and 437 deletion
docs/java-string/12.md
浏览文件 @ 6f32f2cb
# Java String indexOf（）带示例的方法
# Java `String indexOf()`带示例的方法
> 原文： [https://beginnersbook.com/2013/12/java-string-indexof-method-example/](https://beginnersbook.com/2013/12/java-string-indexof-method-example/)
**Java String indexOf（）方法**用于查找给定 String 中指定字符或子字符串的索引。 [String 类](https://beginnersbook.com/2013/12/java-strings/)中有 4 种变体：
Java `String indexOf()`方法用于查找给定`String`中指定字符或子字符串的索引。[`String`类](https://beginnersbook.com/2013/12/java-strings/)中有 4 种变体：
## indexOf（）方法签名
## `indexOf()`方法签名
`int indexOf(int ch)`：返回给定 String 中第一次出现的字符 ch 的索引。
`int indexOf(int ch)`：返回给定`String`中字符`ch`的第一次出现的索引。
`int indexOf(int ch, int fromIndex)`：返回指定索引“fromIndex”后给定字符串中第一次出现字符 ch 的索引。例如，如果像这个 str.indexOf（'A'，20）那样调用 indexOf（）方法，那么它将开始在索引 20 之后的字符串`str`中查找字符'A'。
`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)`：返回特定`String`中字符串`str`的索引。
`int indexOf(String str, int fromIndex)`：返回指定索引“fromIndex”后给定字符串中字符串 str 的索引。
`int indexOf(String str, int fromIndex)`：返回给定字符串中指定索引`fromIndex`后，字符串`str`的索引。
如果在特定`String`中找不到指定的 char / substring，则上述所有变量**都返回-1** 。
如果在特定`String`中找不到指定的`char`/`substring`，则上述所有函数**都返回 -1** 。
## Java String indexOf（）方法示例
## Java `String indexOf()`方法示例
```java
public class IndexOfExample{
......@@ -52,9 +52,9 @@ Index of hardcoded string:2
Index of hardcoded string after 4th char:5
```
## indexOf（）方法的另一个例子
## `indexOf()`方法的另一个例子
让我们举一个简短的例子，我们使用 indexOf（）方法找到给定字符和[子字符串](https://beginnersbook.com/2013/12/java-string-substring-method-example/)的索引。
让我们举一个简短的例子，我们使用`indexOf()`方法找到给定字符和[子字符串](https://beginnersbook.com/2013/12/java-string-substring-method-example/)的索引。
```java
public class JavaExample {
......
docs/java-string/15.md
浏览文件 @ 6f32f2cb
......@@ -8,17 +8,17 @@
要找出指定字符或字符串的最后一次出现，此方法从字符串末尾开始搜索并从那里向后返回。如果在方法调用期间指定了`fromIndex`，则向后搜索从指定的索引`fromIndex`开始
`int lastIndexOf(int ch)`：返回给定`String`中最后一次出现的字符`ch`。
`int lastIndexOf(int ch)`：返回给定`String`中字符`ch`的最后一次出现。
`int lastIndexOf(int ch, int fromIndex)`：返回最后一次出现的 ch，它从指定的索引`fromIndex`开始向后看。
`int lastIndexOf(int ch, int fromIndex)`：返回`ch`的最后一次出现，它从指定的索引`fromIndex`开始向后看。
`int lastIndexOf(String str)`：返回`String`中最后一次出现的`substring str`。
`int lastIndexOf(String str)`：返回`String`中`substring str`的最后一次出现。
`int lastIndexOf(String str, int fromIndex)`：返回最后一次出现的`str`，开始从指定的索引`fromIndex`向后搜索。
`int lastIndexOf(String str, int fromIndex)`：返回`str`的最后一次出现，开始从指定的索引`fromIndex`向后搜索。
## Java `String lastIndexOf()`示例
在下面的例子中，我们在`String str`中搜索几个给定的字符和一个给定的子字符串。我们正在寻找它们在`String str`中的最后一次出现，这就是我们使用`lastIndexOf()`方法的原因。如果要查找字符串中第一次出现的`char`或子字符串，请改用[`indexOf()`方法](https://beginnersbook.com/2013/12/java-string-indexof-method-example/)。
在下面的例子中，我们在`String str`中搜索几个给定的字符和一个给定的子字符串。我们正在寻找它们在`String str`中的最后一次出现，这就是我们使用`lastIndexOf()`方法的原因。如果要查找字符串中`char`或子字符串的第一次出现，请改用[`indexOf()`方法](https://beginnersbook.com/2013/12/java-string-indexof-method-example/)。
```java
public class JavaExample {
......
docs/java-string/18.md
浏览文件 @ 6f32f2cb
# Java - String substring（）方法示例
# Java - `String substring()`方法示例
> 原文： [https://beginnersbook.com/2013/12/java-string-substring-method-example/](https://beginnersbook.com/2013/12/java-string-substring-method-example/)
**方法 substring（）**返回一个新字符串，它是给定字符串的子字符串。 Java [String](https://beginnersbook.com/2013/12/java-strings/) substring（）方法用于根据传递的索引获取给定字符串的子字符串。这种方法有两种变体。在本指南中，我们将看到如何在示例的帮助下使用此方法。
方法`substring()`返回一个新字符串，它是给定字符串的子字符串。 Java [`String`](https://beginnersbook.com/2013/12/java-strings/)`substring()`方法用于根据传递的索引获取给定字符串的子字符串。这种方法有两种变体。在本指南中，我们将看到如何在示例的帮助下使用此方法。
## String substring（）方法变体
## `String substring()`方法变体
我们可以通过两种方式使用 substring（）方法 -
我们可以通过两种方式使用`substring()`方法 -
**1.当我们只通过起始指数时：**
......@@ -14,7 +14,7 @@
String substring(int beginIndex)
```
返回从指定索引开始的子字符串，即 beginIndex，并扩展到字符串末尾的字符。例如 - `"Chaitanya".substring(2)`将返回`"aitanya"`。 beginIndex 是包含的，这就是索引 2 中出现的字符包含在子字符串中的原因。抛出`IndexOutOfBoundsException`如果 beginIndex 小于零或大于 String 的长度（beginIndex< 0 ||> String 的长度）。
返回从指定索引开始的子字符串，即`beginIndex`，并扩展到字符串末尾的字符。例如 - `"Chaitanya".substring(2)`将返回`"aitanya"`。`beginIndex`是包含的，这就是索引 2 中出现的字符包含在子字符串中的原因。如果`beginIndex`小于零或大于`String`的长度（`beginIndex < 0 || > String.length()`）抛出`IndexOutOfBoundsException`。
**2.当我们传递两个索引时，起始索引和结束索引：**
......@@ -22,15 +22,15 @@ String substring(int beginIndex)
String substring(int beginIndex, int endIndex)
```
返回一个新字符串，该字符串是此字符串的子字符串。子字符串从指定的 beginIndex 开始，并扩展到索引 endIndex - 1 处的字符。**因此子字符串的长度是 endIndex-beginIndex。** 换句话说，你可以说 beginIndex 是包容性的，而 endIndex 在获取子字符串时是独占的。
返回一个新字符串，该字符串是此字符串的子字符串。子字符串从指定的`beginIndex`开始，并扩展到索引`endIndex - 1`处的字符。**因此子字符串的长度是`endIndex-beginIndex`。** 换句话说，你可以说`beginIndex`是包容性的，而`endIndex`在获取子字符串时是独占的。
例如 - `"Chaitanya".substring(2,5)`将返回`"ait"`。它抛出`IndexOutOfBoundsException`如果`beginIndex`小于零 OR `beginIndex &gt; endIndex`或`endIndex`大于 String 的长度。
例如 - `"Chaitanya".substring(2,5)`将返回`"ait"`。如果`beginIndex`小于零或`beginIndex > endIndex`或`endIndex`大于`String`的长度，它抛出`IndexOutOfBoundsException`。
## Java String substring（）示例
## Java `String substring()`示例
现在我们了解了 substring（）方法的基础知识，让我们来看一个[示例](https://beginnersbook.com/2017/09/java-examples/)来理解这个方法的用法。
现在我们了解了`substring()`方法的基础知识，让我们来看一个[示例](https://beginnersbook.com/2017/09/java-examples/)来理解这个方法的用法。
这里我们有一个字符串`str`，我们使用 substring（）方法找出该字符串的子串。
这里我们有一个字符串`str`，我们使用`substring()`方法找出该字符串的子串。
```java
public class SubStringExample{
......@@ -53,10 +53,10 @@ Substring starting from index 15 and ending at 20:
jump
```
**注意：**很多人都很困惑，第二个方法调用中返回的子字符串应该是跳转而不是跳转，这是因为返回的子字符串长度应该是 endIndex-beginIndex，在我们的例子中，beginIndex 是 15，endIndex 是因此，返回的子串的长度应该是 20-15 = 5.正确的答案是“跳转”，因为在跳转之前有一个空格，所以子串“jump”的长度是 5（包括空格）。
**注意：**很多人都很困惑，第二个方法调用中返回的子字符串应该是`" jump"`而不是`" jumps"`，这是因为返回的子字符串长度应该是`endIndex-beginIndex`，在我们的例子中，`beginIndex`是 15，`endIndex`是 20，因此，返回的子串的长度应该是`20-15 = 5`。正确的答案是`" jump"`，因为在它之前有一个空格，所以子串`" jump"`的长度是 5（包括空格）。
为了进一步避免混淆，我正在分享这个方法的另一个例子，这个例子很容易理解。
## String substring（）方法的另一个例子
## `String substring()`方法的另一个例子
```java
public class JavaExample{
......@@ -82,4 +82,5 @@ public class JavaExample{
**输出：**
![Java String substring method example](img/dfbef92bd047786aa0e7634593181eac.jpg)
**参考：** [Javadoc 子串（）](https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#substring(int,%20int))
\ No newline at end of file
**参考：**[Javadoc `substring()`](https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#substring(int,%20int))
\ No newline at end of file
docs/java-string/20.md
浏览文件 @ 6f32f2cb
# Java String concat（）方法示例
# Java `String concat()`方法示例
> 原文： [https://beginnersbook.com/2013/12/java-string-concat-method-example/](https://beginnersbook.com/2013/12/java-string-concat-method-example/)
Java 字符串 concat（）方法连接多个字符串。此方法将指定的字符串附加到给定字符串的末尾，并返回组合的字符串。我们可以使用 concat（）方法连接多个字符串。
Java 字符串`concat()`方法连接多个字符串。此方法将指定的字符串附加到给定字符串的末尾，并返回组合的字符串。我们可以使用`concat()`方法连接多个字符串。
## concat（）方法签名
## `concat()`方法签名
```java
public String concat(String str)
```
此方法将字符串 str 连接到当前字符串的末尾。例如 - `s1.concat("Hello");`会在`String s1`的末尾连接字符串“Hello”。可以在这样的单个语句中多次调用此方法
此方法将字符串 str 连接到当前字符串的末尾。例如 - `s1.concat("Hello");`会在`String s1`的末尾连接字符串`"Hello"`。可以在这样的单个语句中多次调用此方法
```java
String s1="Beginners";
s1= s1.concat("Book").concat(".").concat("com");
```
执行上述声明后，s1 的值将为 BeginnersBook.com。
执行上述声明后，`s1`的值将为`BeginnersBook.com`。
## Java String concat 方法示例
## Java `String concat`方法示例
在这个例子中，我们将看到使用 concat（）方法进行 String 连接的两种方法。
在这个例子中，我们将看到使用`concat()`方法进行`String`连接的两种方法。
```java
public class ConcatenationExample {
......@@ -47,9 +47,9 @@ Welcome to String handling
This is just a String
```
## Java String concat 方法的另一个例子
## Java `String concat`方法的另一个例子
正如我们在上面看到的那样，concat（）方法将[字符串](https://beginnersbook.com/2013/12/java-strings/)附加到当前字符串的末尾。但是我们可以做一个解决方法，在给定字符串的开头附加**指定的字符串。**
正如我们在上面看到的那样，`concat()`方法将[字符串](https://beginnersbook.com/2013/12/java-strings/)附加到当前字符串的末尾。但是我们可以做一个解决方法，在给定字符串的开头附加**指定的字符串。**
```java
public class JavaExample {
......
docs/java-string/21.md
浏览文件 @ 6f32f2cb
# Java String replace（），replaceFirst（）和 replaceAll（）方法
# Java `String replace()`，`replaceFirst()`和`replaceAll()`方法
> 原文： [https://beginnersbook.com/2013/12/java-string-replace-replacefirst-replaceall-method-examples/](https://beginnersbook.com/2013/12/java-string-replace-replacefirst-replaceall-method-examples/)
在本教程中，我们将讨论`replace()`，`replaceFirst()`和`replaceAll()`方法。所有这些 [Java String](https://beginnersbook.com/2013/12/java-strings/) 方法主要用于用另一个 String 替换 String 的一部分。
在本教程中，我们将讨论`replace()`，`replaceFirst()`和`replaceAll()`方法。所有这些 [Java `String`](https://beginnersbook.com/2013/12/java-strings/)方法主要用于用另一个`String`替换`String`的一部分。
## Java String 替换方法签名
## Java `String`替换方法签名
`String replace(char oldChar, char newChar)`：它用 newChar 字符替换所有出现的 oldChar 字符。对于例如`"pog pance".replace('p', 'd')`将返回`dog dance`。
`String replace(char oldChar, char newChar)`：它用`newChar`字符替换`oldChar`字符的所有出现。对于例如`"pog pance".replace('p', 'd')`将返回`dog dance`。
`String replaceFirst(String regex, String replacement)`：它用替换字符串替换符合指定[正则表达式](https://docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html#sum)的第一个子字符串。 [`PatternSyntaxException`](https://docs.oracle.com/javase/7/docs/api/java/util/regex/PatternSyntaxException.html "class in java.util.regex") 如果指定的正则表达式（正则表达式）无效。
`String replaceFirst(String regex, String replacement)`：它用替换字符串替换符合指定[正则表达式](https://docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html#sum)的第一个子字符串。如果指定的正则表达式（正则表达式）无效抛出[`PatternSyntaxException`](https://docs.oracle.com/javase/7/docs/api/java/util/regex/PatternSyntaxException.html)。
`String replaceAll(String regex, String replacement)`：它用替换 String 替换所有符合给定正则表达式的子串。
`String replaceAll(String regex, String replacement)`：它用替换`String`替换所有符合给定正则表达式的子串。
## Java String replace（）方法示例
## Java `String replace()`方法示例
在下面的例子中，我们有一个字符串`str`，我们正在演示使用 String str 的 replace（）方法。我们用 char'p'替换了所有出现的 char'o'。在第二个 print 语句中，我们用 char'K'替换了所有出现的 char'i'。
在下面的例子中，我们有一个字符串`str`，我们正在演示使用`String str`的`replace()`方法。我们用`char 'p'`替换了`char 'o'`的所有出现。在第二个`print`语句中，我们用`char 'K'`替换了`char 'i'`的所有出现。
这里我们使用 print 语句显示修改后的字符串，但我们实际上没有更改字符串`str`，为了实现我们需要在字符串中分配返回的 replace（）方法字符串，然后该字符串可以进行永久性更改。
这里我们使用`print`语句显示修改后的字符串，但我们实际上没有更改字符串`str`，为了实现我们需要在字符串中分配返回的`replace()`方法字符串，然后该字符串可以进行永久性更改。
```java
public class JavaExample{
......@@ -37,9 +37,9 @@ public class JavaExample{
![Java String replace method example](img/fe2a83df51773711e30dd96d1c7b1be8.jpg)
## Java String replaceFirst（）方法示例
## Java `String replaceFirst()`方法示例
在下面的示例中，我们将演示如何使用 replaceFirst（）方法。此方法用新指定的字符串替换字符串的一部分。 replaceFirst（）和 replaceAll（）方法之间的**区别在于 replaceFirst（）替换第一个匹配项，而 replaceAll（）替换所有匹配项。**
在下面的示例中，我们将演示如何使用`replaceFirst()`方法。此方法用新指定的字符串替换字符串的一部分。`replaceFirst()`和`replaceAll()`方法之间的区别在于`replaceFirst()`替换第一个匹配项，而`replaceAll()`替换所有匹配项。
```java
public class JavaExample{
......@@ -60,11 +60,11 @@ public class JavaExample{
![Java String replaceFirst() method example](img/b5c7b51be893ba56680628861996349c.jpg)
## Java String replaceAll（）方法示例
## Java `String replaceAll()`方法示例
在下面的示例中，我们使用`replaceAll()`方法用新字符串替换给定子字符串的所有出现。
replace（）和 replaceAll（）方法之间的**区别在于`replace()`方法用新 char 替换所有出现的旧 char，而`replaceAll()`方法用新字符串替换所有出现的旧字符串。基本上，replace（）适用于替换字符，而 replaceAll（）适用于替换部分字符串。**
`replace()`和`replaceAll()`方法之间的区别在于`replace()`方法用新`char`替换旧`char`的所有出现，而`replaceAll()`方法用新字符串替换旧字符串的所有出现。基本上，`replace()`适用于替换字符，而`replaceAll()`适用于替换部分字符串。
```java
public class JavaExample{
......
docs/java-string/22.md
浏览文件 @ 6f32f2cb
# Java String contains（）方法用示例解释
# Java `String contains()`方法
> 原文： [https://beginnersbook.com/2017/10/java-string-contains-method/](https://beginnersbook.com/2017/10/java-string-contains-method/)
**Java String contains（）**方法检查特定字符序列是否是给定字符串的一部分。如果给定字符串中存在指定的字符序列，则此方法返回 true，否则返回 false。
Java `String contains()`方法检查特定字符序列是否是给定字符串的一部分。如果给定字符串中存在指定的字符序列，则此方法返回`true`，否则返回`false`。
**例如：**
......@@ -19,24 +19,24 @@ System.out.println(str.contains("aGme"));
```
## contains（）方法的语法
## `contains()`方法的语法
```java
public boolean contains(CharSequence str)
```
返回类型是 boolean，这意味着此方法返回 true 或 false。当在给定字符串中找到字符序列时，此方法返回 true，否则返回 false。
返回类型是`boolean`，这意味着此方法返回`true`或`false`。当在给定字符串中找到字符序列时，此方法返回`true`，否则返回`false`。
如果 CharSequence 为 null，则此方法抛出 NullPointerException。
例如：像这样调用此方法会抛出 NullPointerException。
如果`CharSequence`为`null`，则此方法抛出`NullPointerException`。
例如：像这样调用此方法会抛出`NullPointerException`。
```java
str.contains(null);
```
## Java String 包含（）方法示例
## Java `String contains()`方法示例
第二个 print 语句显示为 false，因为 contains（）方法区分大小写。 **您也可以使用 contains（）方法进行不区分大小写的检查**，我已经在本教程末尾介绍了**。**
第二个`print`语句显示为`false`，因为`contains()`方法区分大小写。 **您也可以使用`contains()`方法进行不区分大小写的检查**，我已经在本教程末尾介绍了。
```java
class Example{
......@@ -65,9 +65,9 @@ true
true
```
## 示例 2：在 if-else 语句中使用 Java String contains（）方法
## 示例 2：在`if-else`语句中使用 Java `String contains()`方法
我们知道 contains（）方法返回一个布尔值，我们可以将此方法用作 [if-else 语句](https://beginnersbook.com/2017/08/if-else-statement-in-java/)中的条件。
我们知道`contains()`方法返回一个布尔值，我们可以将此方法用作[`if-else`语句](https://beginnersbook.com/2017/08/if-else-statement-in-java/)中的条件。
```java
class JavaExample{
......@@ -92,11 +92,11 @@ class JavaExample{
![Java String contains method example](img/0a5ad03487f119bc2ffe82e4c2f7c22e.jpg)
## Java String 包含（）方法，用于不区分大小写的检查
## Java `String contains()`方法，用于不区分大小写的检查
我们在上面已经看到 contains（）方法区分大小写，但是通过一个小技巧，您可以使用此方法进行不区分大小写的检查。让我们举个例子来理解这个：
我们在上面已经看到`contains()`方法区分大小写，但是通过一个小技巧，您可以使用此方法进行不区分大小写的检查。让我们举个例子来理解这个：
这里我们使用 [toLowerCase（）方法](https://beginnersbook.com/2013/12/java-string-tolowercase-method-example/)将两个字符串转换为小写，以便我们可以使用 contains（）方法执行不区分大小写的检查。我们也可以使用 toUpperCase（）方法实现同样的目的，如下例所示。
这里我们使用[`toLowerCase()`方法](https://beginnersbook.com/2013/12/java-string-tolowercase-method-example/)将两个字符串转换为小写，以便我们可以使用`contains()`方法执行不区分大小写的检查。我们也可以使用`toUpperCase()`方法实现同样的目的，如下例所示。
```java
class Example{
......@@ -121,4 +121,4 @@ true
#### 参考：
[String Contains（）方法 JavaDoc](https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#contains(java.lang.CharSequence))
\ No newline at end of file
[`String Contains()`方法 JavaDoc](https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#contains(java.lang.CharSequence))
\ No newline at end of file
docs/java-string/23.md
浏览文件 @ 6f32f2cb
# Java - String toLowerCase（）和 toUpperCase（）方法
# Java - `String toLowerCase()`和`toUpperCase()`方法
> 原文： [https://beginnersbook.com/2013/12/java-string-tolowercase-method-example/](https://beginnersbook.com/2013/12/java-string-tolowercase-method-example/)
方法`toLowerCase()`将`String`的字符转换为小写字符。它有两个变种：
`String toLowerCase(Locale locale)`：使用指定的 [Locale](https://docs.oracle.com/javase/7/docs/api/java/util/Locale.html) 定义的规则将字符串转换为小写。
`String toLowerCase(Locale locale)`：使用指定的[`Locale`](https://docs.oracle.com/javase/7/docs/api/java/util/Locale.html)定义的规则将字符串转换为小写。
`String toLowerCase()`：相当于`toLowerCase(Locale.getDefault())`。 `Locale.getDefault()`获取此 Java 虚拟机实例的默认语言环境的当前值。 Java 虚拟机根据主机环境在启动期间设置默认语言环境。如果未明确指定语言环境，则许多语言环境敏感方法使用它。可以使用`setDefault()`方法更改它。
`String toLowerCase()`：相当于`toLowerCase(Locale.getDefault())`。`Locale.getDefault()`获取此 Java 虚拟机实例的默认语言环境的当前值。 Java 虚拟机根据主机环境在启动期间设置默认语言环境。如果未明确指定语言环境，则许多语言环境敏感方法使用它。可以使用`setDefault()`方法更改它。
### 示例：toLowerCase（）方法
### 示例：`toLowerCase()`方法
```java
import java.util.Locale;
......@@ -31,13 +31,13 @@ abc is not equal to xyz
abc is not equal to xyz
```
## 方法：toUpperCase（）
## 方法：`toUpperCase()`
与`toLowerCase()`方法类似，`toUpperCase()`也有两个变体：
`String toUpperCase(Locale locale)`：它使用指定的 Locale 定义的规则将字符串转换为 UpperCase 字符串。
`String toUpperCase(Locale locale)`：它使用指定的`Locale`定义的规则将字符串转换为大写字符串。
`String toUpperCase()`：与`toUpperCase(Locale.getDefault())`相当。
### 示例：toUpperCase（）方法
### 示例：`toUpperCase()`方法
```java
import java.util.Locale;
......@@ -53,7 +53,7 @@ public class UpperCaseExample{
}
```
Output:
输出：
```java
THIS IS A TEST STRING
......
docs/java-string/25.md
浏览文件 @ 6f32f2cb
# Java String intern（）方法用示例解释
# Java `String intern()`方法
> 原文： [https://beginnersbook.com/2017/10/java-string-intern-method/](https://beginnersbook.com/2017/10/java-string-intern-method/)
**Java String intern（）**方法用于从内存中获取字符串（如果已存在）。此方法可确保所有**相同的字符串**共享相同的内存。例如，使用 intern（）方法创建一个字符串“hello”10 次将确保内存中只有一个“Hello”实例，并且所有 10 个引用都指向同一个实例。
Java `String intern()`方法用于从内存中获取字符串（如果已存在）。此方法可确保所有**相同的字符串**共享相同的内存。例如，使用`intern()`方法创建一个字符串`"hello"` 10 次将确保内存中只有一个`"Hello"`实例，并且所有 10 个引用都指向同一个实例。
## 一个简单的 Java String intern（）方法示例
## 一个简单的 Java `String intern()`方法示例
此示例演示了 intern（）方法的用法。此方法在内存池中搜索提到的 String，如果找到该字符串，则返回它的引用，否则它为该字符串分配新的内存空间并为其分配引用。
此示例演示了`intern()`方法的用法。此方法在内存池中搜索提到的`String`，如果找到该字符串，则返回它的引用，否则它为该字符串分配新的内存空间并为其分配引用。
```java
public class Example{
......@@ -29,9 +29,9 @@ public class Example{
str1==str2: true
```
## Java 自动实习字符串文字
## Java 字符串字面值
当我们使用字符串文字创建字符串而不是使用 new 关键字创建字符串时，java 会自动实例化字符串。让我们举个例子来理解这个：
当我们使用字符串字面值创建字符串而不是使用`new`关键字创建字符串时，java 会自动实例化字符串。让我们举个例子来理解这个：
```java
public class Example{
......@@ -67,7 +67,7 @@ public class Example{
}
```
Output:
输出：
```java
String str1 and str2 are same
......@@ -77,13 +77,13 @@ String str3 and str5 are same
#### 相关文章：
1. [Java String format（）方法](https://beginnersbook.com/2017/10/java-string-format-method/)
2. [Java String matches（）方法](https://beginnersbook.com/2013/12/java-string-matches-method-example/)
3. [Java String trim（）和 hashCode（）方法](https://beginnersbook.com/2013/12/java-string-trim-and-hashcode-methods/)
4. [Java String replace（），replaceFirst（）和 replaceAll（）方法](https://beginnersbook.com/2013/12/java-string-replace-replacefirst-replaceall-method-examples/)
1. [Java `String format()`方法](https://beginnersbook.com/2017/10/java-string-format-method/)
2. [Java `String matches()`方法](https://beginnersbook.com/2013/12/java-string-matches-method-example/)
3. [Java `String trim()`和 hashCode()方法](https://beginnersbook.com/2013/12/java-string-trim-and-hashcode-methods/)
4. [Java `String replace()`，`replaceFirst()`和`replaceAll()`方法](https://beginnersbook.com/2013/12/java-string-replace-replacefirst-replaceall-method-examples/)
#### 参考文献：
* [intern（）方法 - JavaDoc](https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#intern())
* [什么是 String interning？](https://stackoverflow.com/questions/10578984/what-is-string-interning)
* [Java 中的 intern（）方法的目的](https://stackoverflow.com/questions/22473154/what-is-the-purpose-of-javas-string-intern)
\ No newline at end of file
* [`intern()`方法 - JavaDoc](https://docs.oracle.com/javase/7/docs/api/java/lang/String.html#intern())
* [什么是`String` interning？](https://stackoverflow.com/questions/10578984/what-is-string-interning)
* [Java 中的`intern()`方法的目的](https://stackoverflow.com/questions/22473154/what-is-the-purpose-of-javas-string-intern)
\ No newline at end of file
docs/java-string/26.md
浏览文件 @ 6f32f2cb
......@@ -60,7 +60,7 @@ public class Example{
}
```
Output:
输出：
```java
String str1 is empty or null
......
docs/java-string/27.md
浏览文件 @ 6f32f2cb
......@@ -57,7 +57,7 @@ public class Example{
}
```
Output:
输出：
```java
Steve | Rick | Peter | Abbey
......
docs/java-string/30.md 已删除 100644 → 0
浏览文件 @ 83bfaa4f
# Java 正则表达式（java 正则表达式）教程与示例
> 原文： [https://beginnersbook.com/2014/08/java-regex-tutorial/](https://beginnersbook.com/2014/08/java-regex-tutorial/)
**正则表达式**用于定义可用于搜索，操作和编辑文本的字符串模式。这些表达式也称为 **Regex** （正则表达式的简写形式）。
#### 让我们举个例子来更好地理解它：
在下面的示例中，正则表达式`.*book.*`用于搜索文本中字符串“book”的出现。
```java
import java.util.regex.*;
class RegexExample1{
public static void main(String args[]){
String content = "This is Chaitanya " +
"from Beginnersbook.com.";
String pattern = ".*book.*";
boolean isMatch = Pattern.matches(pattern, content);
System.out.println("The text contains 'book'? " + isMatch);
}
}
```
输出：
```java
The text contains 'book'? true
```
在本教程中，我们将学习如何定义模式以及如何使用它们。 java.util.regex API（我们在处理 Regex 时需要导入的包）有两个主要类：
1）java.util.regex.Pattern - 用于定义模式
2）java.util.regex.Matcher - 用于使用模式对文本执行匹配操作
## java.util.regex.Pattern 类：
#### 1）Pattern.matches（）
我们已经在上面的例子中看到过这种方法的用法，我们在给定的文本中搜索了字符串“book”。这是使用 Regex 在文本中搜索 String 的最简单和最简单的方法之一。
```java
String content = "This is a tutorial Website!";
String patternString = ".*tutorial.*";
boolean isMatch = Pattern.matches(patternString, content);
System.out.println("The text contains 'tutorial'? " + isMatch);
```
如您所见，我们使用 Pattern 类的 matches（）方法来搜索给定文本中的模式。模式`.*tutorial.*`在字符串“tutorial”的开头和结尾允许零个或多个字符（表达式`.*`用于零个或多个字符）。
**限制**：通过这种方式，我们可以搜索文本中单个出现的模式。要匹配多次出现，您应该使用 Pattern.compile（）方法（在下一节中讨论）。
#### 2）Pattern.compile（）
在上面的例子中，我们在文本中搜索了一个字符串“tutorial”，这是一个区分大小写的搜索，但是如果你想进行 CASE INSENSITIVE 搜索或者想要多次搜索，那么你可能需要先使用 Pattern 编译模式.compile（）在用文本搜索之前。这就是这种方法可以用于这种情况的方法。
```java
String content = "This is a tutorial Website!";
String patternString = ".*tuToRiAl.";
Pattern pattern = Pattern.compile(patternString, Pattern.CASE_INSENSITIVE);
```
这里我们使用了一个标志 Pattern.CASE_INSENSITIVE 来进行不区分大小写的搜索，还有其他几个标志可以用于不同的目的。要阅读有关此类标志的更多信息[，请参阅此文档](https://docs.oracle.com/javase/tutorial/essential/regex/pattern.html)。
**现在**：我们已经获得了一个 Pattern 实例，但是如何匹配呢？为此，我们需要一个 Matcher 实例，我们可以使用 Pattern.matcher（）方法。让我们讨论一下。
#### 3）Pattern.matcher（）方法
在上一节中，我们学习了如何使用 compile（）方法获取 Pattern 实例。在这里，我们将学习如何使用 matcher（）方法从 Pattern 实例获取 Matcher 实例。
```java
String content = "This is a tutorial Website!";
String patternString = ".*tuToRiAl.*";
Pattern pattern = Pattern.compile(patternString, Pattern.CASE_INSENSITIVE);
Matcher matcher = pattern.matcher(content);
boolean isMatched = matcher.matches();
System.out.println("Is it a Match?" + isMatched);
```
Output:
```java
Is it a Match?true
```
#### 4）Pattern.split（）
要根据分隔符将文本拆分为多个字符串（这里使用**正则表达式**指定分隔符），我们可以使用 Pattern.split（）方法。这是如何做到的。
```java
import java.util.regex.*;
class RegexExample2{
public static void main(String args[]){
String text = "ThisIsChaitanya.ItISMyWebsite";
// Pattern for delimiter
String patternString = "is";
Pattern pattern = Pattern.compile(patternString, Pattern.CASE_INSENSITIVE);
String[] myStrings = pattern.split(text);
for(String temp: myStrings){
System.out.println(temp);
}
System.out.println("Number of split strings: "+myStrings.length);
}}
```
Output:
```java
Th
Chaitanya.It
MyWebsite
Number of split strings: 4
```
第二个拆分 String 在输出中为 null。
## java.util.regex.Matcher 类
我们已经讨论过上面的 Matcher 类了。让我们回忆一下：
#### 创建 Matcher 实例
```java
String content = "Some text";
String patternString = ".*somestring.*";
Pattern pattern = Pattern.compile(patternString);
Matcher matcher = pattern.matcher(content);
```
#### 主要方法
**matches（）**：它在创建 Matcher 实例时将正则表达式与传递给 Pattern.matcher（）方法的整个文本进行匹配。
```java
...
Matcher matcher = pattern.matcher(content);
boolean isMatch = matcher.matches();
```
**lookingAt（）**：类似于 matches（）方法，只是它匹配正则表达式只对着文本的开头，而 matches（）搜索整个文本。
**find（）**：搜索文本中正则表达式的出现次数。主要用于搜索多次出现的情况。
**start（）和 end（）**：这两种方法通常与 find（）方法一起使用。它们用于获取使用 find（）方法找到的匹配项的开始和结束索引。
#### 让我们举个例子来找出使用 Matcher 方法的多次出现：
```java
package beginnersbook.com;
import java.util.regex.*;
class RegexExampleMatcher{
public static void main(String args[]){
String content = "ZZZ AA PP AA QQQ AAA ZZ";
String string = "AA";
Pattern pattern = Pattern.compile(string);
Matcher matcher = pattern.matcher(content);
while(matcher.find()) {
System.out.println("Found at: "+ matcher.start()
+
" - " + matcher.end());
}
}
}
```
Output:
```java
Found at: 4 - 6
Found at: 10 - 12
Found at: 17 - 19
```
现在我们熟悉 Pattern 和 Matcher 类以及将正则表达式与文本匹配的过程。让我们看一下我们定义正则表达式的各种选项：
#### 1）字符串文字
假设您只想在文本中搜索特定字符串，例如“abc”然后我们可以简单地编写这样的代码：这里的文本和正则表达式都是相同的。
`Pattern.matches("abc", "abc")`
#### 2）角色类
字符类将输入文本中的单个字符与字符类中的多个允许字符进行匹配。例如[Cc] haitanya 将匹配所有出现的字符串“chaitanya”与小写或大写 C“。更多的例子：
`Pattern.matches("[pqr]", "abcd");`它会给出错误，因为文中没有 p，q 或 r
`Pattern.matches("[pqr]", "r");`当找到 r 时返回 true
`Pattern.matches("[pqr]", "pq");`返回 false，因为其中任何一个都可以在文本中不是两个。
以下是各种字符类构造的完整列表：
`[abc]`：如果文本中包含其中一个（a，b 或 c）且只有一次，它将与文本匹配。
`[^abc]`：除 a，b 或 c 以外的任何单个字符（^表示否定）
`[a-zA-Z]`：a 到 z，或 A 到 Z，包括（范围）
`[a-d[m-p]]`：a 通过 d，或 m 到 p：[a-dm-p]（联合）
`[a-z&&[def]]`：它们中的任何一个（d，e 或 f）
`[a-z&&[^bc]]`：a 到 z，除了 b 和 c：[ad-z]（减法）
`[a-z&&[^m-p]]`：a 到 z，而不是 m 到 p：[a-lq-z]（减法）
#### 预定义字符类 - 元字符
这些就像在编写正则表达式时可以使用的短代码。
```java
Construct Description
. -> Any character (may or may not match line terminators)
\d -> A digit: [0-9]
\D -> A non-digit: [^0-9]
\s -> A whitespace character: [ \t\n\x0B\f\r]
\S -> A non-whitespace character: [^\s]
\w -> A word character: [a-zA-Z_0-9]
\W -> A non-word character: [^\w]
```
对于例如
`Pattern.matches("\\d", "1");`将返回 true
`Pattern.matches("\\D", "z");`返回 true
`Pattern.matches(".p", "qp");`返回 true，点（。）代表任何字符
#### 边界匹配器
```java
^ Matches the beginning of a line.
$ Matches then end of a line.
\b Matches a word boundary.
\B Matches a non-word boundary.
\A Matches the beginning of the input text.
\G Matches the end of the previous match
\Z Matches the end of the input text except the final terminator if any.
\z Matches the end of the input text.
```
对于例如
`Pattern.matches("^Hello$", "Hello")`：返回 true，开始并以 Hello 结尾
`Pattern.matches("^Hello$", "Namaste! Hello")`：返回 false，不以 Hello 开头
`Pattern.matches("^Hello$", "Hello Namaste!")`：返回 false，不以 Hello 结束
#### 量词
```java
Greedy Reluctant Possessive Matches
X? X?? X?+ Matches X once, or not at all (0 or 1 time).
X* X*? X*+ Matches X zero or more times.
X+ X+? X++ Matches X one or more times.
X{n} X{n}? X{n}+ Matches X exactly n times.
X{n,} X{n,}? X{n,}+ Matches X at least n times.
X{n, m) X{n, m)? X{n, m)+ Matches X at least n time, but at most m times.
```
#### 几个例子
```java
import java.util.regex.*;
class RegexExample{
public static void main(String args[]){
// It would return true if string matches exactly "tom"
System.out.println(
Pattern.matches("tom", "Tom")); //False
/* returns true if the string matches exactly
* "tom" or "Tom"
*/
System.out.println(
Pattern.matches("[Tt]om", "Tom")); //True
System.out.println(
Pattern.matches("[Tt]om", "Tom")); //True
/* Returns true if the string matches exactly "tim"
* or "Tim" or "jin" or "Jin"
*/
System.out.println(
Pattern.matches("[tT]im|[jJ]in", "Tim"));//True
System.out.println(
Pattern.matches("[tT]im|[jJ]in", "jin"));//True
/* returns true if the string contains "abc" at
* any place
*/
System.out.println(
Pattern.matches(".*abc.*", "deabcpq"));//True
/* returns true if the string does not have a
* number at the beginning
*/
System.out.println(
Pattern.matches("^[^\\d].*", "123abc")); //False
System.out.println(
Pattern.matches("^[^\\d].*", "abc123")); //True
// returns true if the string contains of three letters
System.out.println(
Pattern.matches("[a-zA-Z][a-zA-Z][a-zA-Z]", "aPz"));//True
System.out.println(
Pattern.matches("[a-zA-Z][a-zA-Z][a-zA-Z]", "aAA"));//True
System.out.println(
Pattern.matches("[a-zA-Z][a-zA-Z][a-zA-Z]", "apZx"));//False
// returns true if the string contains 0 or more non-digits
System.out.println(
Pattern.matches("\\D*", "abcde")); //True
System.out.println(
Pattern.matches("\\D*", "abcde123")); //False
/* Boundary Matchers example
* ^ denotes start of the line
* $ denotes end of the line
*/
System.out.println(
Pattern.matches("^This$", "This is Chaitanya")); //False
System.out.println(
Pattern.matches("^This$", "This")); //True
System.out.println(
Pattern.matches("^This$", "Is This Chaitanya")); //False
}
}
```
#### 参考
[正则表达式 - Javadoc](https://docs.oracle.com/javase/tutorial/essential/regex/)
\ No newline at end of file
docs/java-string/31.md
浏览文件 @ 6f32f2cb
# Java String split（）方法和示例
# Java `String split()`方法
> 原文： [https://beginnersbook.com/2013/12/java-string-split-method-example/](https://beginnersbook.com/2013/12/java-string-split-method-example/)
Java [String](https://beginnersbook.com/2013/12/java-strings/) split 方法用于根据给定的分隔符或[正则表达式](https://beginnersbook.com/2014/08/java-regex-tutorial/)将 String 拆分为其子串。
Java [`String`](https://beginnersbook.com/2013/12/java-strings/)`split`方法用于根据给定的分隔符或[正则表达式](https://beginnersbook.com/2014/08/java-regex-tutorial/)将`String`拆分为其子串。
例如：
......@@ -14,17 +14,17 @@ Output : {"chaitanya", "singh"}
## Java 字符串拆分方法
我们在 String 类中有两种 split（）方法。
我们在`String`类中有两种`split()`方法。
1. `String[] split(String regex)`：在根据分隔正则表达式拆分输入 String 后返回一个字符串数组。
1. `String[] split(String regex)`：在根据分隔正则表达式拆分输入`String`后返回一个字符串数组。
2. `String[] split(String regex, int limit)`：当我们想要限制子串时，使用这个 Java String split 方法。此方法与上述方法的唯一区别在于它限制了拆分后返回的字符串数。对于例如`split("anydelimiter", 3)`将返回仅 3 个字符串的数组，即使字符串中的分隔符超过 3 次也是如此。
2. `String[] split(String regex, int limit)`：当我们想要限制子串时，使用这个`String split`方法。此方法与上述方法的唯一区别在于它限制了拆分后返回的字符串数。对于例如`split("anydelimiter", 3)`将返回仅 3 个字符串的数组，即使字符串中的分隔符超过 3 次也是如此。
如果**限制为负**，则返回的数组将具有尽可能多的子串，但是当**限制为零**时，返回的数组将具有除尾随空字符串之外的所有子串。
如果指定正则表达式的语法无效，则抛出 [`PatternSyntaxException`](https://docs.oracle.com/javase/7/docs/api/java/util/regex/PatternSyntaxException.html) 。
## Java String 拆分示例
## Java `String`拆分示例
```java
public class SplitExample{
......@@ -93,7 +93,7 @@ split(String regex, int limit) with limit=-5:
## java 字符串拆分方法中零和负限制之间的差异
在上面的示例中，split（“/”，0）和 split（“/”， - 5）返回相同的值，但在某些情况下，结果会有所不同。让我们通过一个例子来看看这两者之间的区别：
在上面的示例中，`split("/", 0)`和`split("/", -5)`返回相同的值，但在某些情况下，结果会有所不同。让我们通过一个例子来看看这两者之间的区别：
```java
String s="bbaaccaa";
......@@ -101,7 +101,7 @@ String arr1[]= s.split("a", -1);
String arr2[]= s.split("a", 0);
```
在这种情况下，arr1 将具有{“bb”，“”，“cc”，“”，“”}但是 arr2 将具有{“bb”，“”，“cc”}，因为极限零不包括试验空字符串。
在这种情况下，`arr1`将具有`{"bb"，""，"cc"，""，""}`但是`arr2`将具有`{"bb"，""，"cc"}`，因为限制零不包括试验空字符串。
让我们看看完整的程序。
......@@ -134,9 +134,9 @@ public class JavaExample{
![Java String split](img/5468a57317627fadd25e2194a847fb2f.jpg)
## Java 字符串拆分有多个分隔符（特殊字符）
## Java 带有多个分隔符（特殊字符）的字符串拆分
让我们看看我们如何在使用 split（）方法时传递多个分隔符。在这个例子中，我们基于多个特殊字符拆分输入字符串。
让我们看看我们如何在使用`split()`方法时传递多个分隔符。在这个例子中，我们基于多个特殊字符拆分输入字符串。
```java
public class JavaExample{
......@@ -160,7 +160,7 @@ public class JavaExample{
让我们再练习几个例子：
**示例：word 作为 Java String split 方法中的正则表达式**
**示例：Java `String split`方法中的正则表达式**
```java
public class SplitExample1 {
......@@ -175,7 +175,7 @@ public class SplitExample1 {
}
```
**Output:**
**输出：**
```java
hello
......@@ -200,7 +200,7 @@ public class SplitExample2 {
}
```
**Output:**
**输出：**
```java
My
......
docs/java-string/34.md
浏览文件 @ 6f32f2cb
......@@ -70,7 +70,7 @@ public class Example{
}
```
Output:
输出：
```java
My String is: cool string, cool string and 88
......@@ -98,7 +98,7 @@ public class Example{
}
```
Output:
输出：
```java
00088
......
docs/java-string/51.md
浏览文件 @ 6f32f2cb
......@@ -128,7 +128,7 @@ public class JavaExample{
}
```
**Output:**
**输出：**
```java
hello99
......
docs/java-string/54.md
浏览文件 @ 6f32f2cb
......@@ -79,7 +79,7 @@ public class Example {
```
Output:
输出：
```java
222220000
......
docs/java-string/62.md
浏览文件 @ 6f32f2cb
......@@ -45,7 +45,7 @@ class LeftPaddingExample2 {
}
```
**Output:**
**输出：**
```java
#[email protected]
......
docs/java-string/63.md
浏览文件 @ 6f32f2cb
......@@ -44,7 +44,7 @@ public class PadRightExample2 {
}
```
**Output:**
**输出：**
```java
#[email protected]
......
docs/java-string/65.md
浏览文件 @ 6f32f2cb
......@@ -53,7 +53,7 @@ class StringToCharDemo
}
```
**Output:**
**输出：**
```java
Character at 0 Position: H
......
docs/java-string/74.md
浏览文件 @ 6f32f2cb
......@@ -56,7 +56,7 @@ public class Example {
}
```
Output:
输出：
```java
(Negan,Rick,Maggie,Daryl)
......@@ -103,7 +103,7 @@ public class Example {
}
```
Output:
输出：
```java
First String: (Negan,Rick,Maggie,Daryl)
......@@ -158,7 +158,7 @@ public class Example {
}
```
Output:
输出：
```java
Default String: This is a default String
......
docs/java-string/76.md
浏览文件 @ 6f32f2cb
......@@ -63,7 +63,7 @@ public class JavaExample {
}
```
**Output:**
**输出：**
```java
Enter your username:
......
docs/java-string/SUMMARY.md
浏览文件 @ 6f32f2cb
......@@ -16,7 +16,7 @@
+ [Java String intern（）方法用示例解释](25.md)
+ [Java String isEmpty（）方法，带有示例](26.md)
+ [Java String join（）方法用示例解释](27.md)
+ [Java 正则表达式（java 正则表达式）教程与示例](30.md)
+ [Java 正则表达式教程](../java/49.md)
+ [Java String split（）方法和示例](31.md)
+ [Java String format（）方法用例子解释](34.md)
+ [Java - String toCharArray（）方法示例](37.md)
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或