如何拆分字符串，包括标点符号？

Question

我需要与标点符号被存储在相同的阵列词语的分割的字符串（在Java中）：

String sentence = "In the preceding examples, classes derived from..."; 
String[] split = sentence.split(" "); 

我需要分裂阵列为：

split[0] - "In" 
split[1] - "the" 
split[2] - "preceding" 
split[3] - "examples" 
split[4] - "," 
split[5] - "classes" 
split[6] - "derived" 
split[7] - "from" 
split[8] - "..." 

是否有任何优雅的解决方案？

Answer 1

对于所有您要区分的标点符号，您可以使用“，”等字符来替换字符串，例如“，”。

在特定情况下 “......” 你可以这样做：

// there can be series of dots 
sentence.replace(".", " .").replace(". .", "..") 

然后拆分。

编辑：用双引号替换单引号。

Answer 2

你需要看看变通：

String[] split = sentence.split(" ?(?<!\\G)((?<=[^\\p{Punct}])(?=\\p{Punct})|\\b) ?"); 

看变通断言，但（重要的位置）不消耗输入匹配时。

---

一些测试代码：

String sentence = "Foo bar, baz! Who? Me..."; 
String[] split = sentence.split(" ?(?<!\\G)((?<=[^\\p{Punct}])(?=\\p{Punct})|\\b) ?"); 
Arrays.stream(split).forEach(System.out::println); 

输出;

Foo 
bar 
, 
baz 
! 
Who 
? 
Me 
... 

Answer 3

为您的特定情况下，两个主要挑战是排序（例如第一标点，然后单词或周围的其他方法）和...标点符号。

您可以轻松地使用

\p{Punct} 

这样实现它的其余部分：

Pattern.compile("\p{Punct}"); 

关于上面提到的两个挑战：

1.Ordering： 你可以尝试以下方法：

private static final Pattern punctuation = Pattern.compile("\\p{Punct}"); 
private static final Pattern word = Pattern.compile("\\w"); 

public static void main(String[] args) { 
    String sentence = "In the preceding examples, classes derived from..."; 
    String[] split = sentence.split(" "); 
    List<String> result = new LinkedList<>(); 

    for (String s : split) { 
     List<String> withMarks = splitWithPunctuationMarks(s); 
     result.addAll(withMarks); 
    } 
} 

private static void List<String> splitWithPunctuationMarks(String s) { 
    Map<Integer, String> positionToString = new TreeMap<>(); 
    Matcher punctMatcher = punctuation.matcher(s); 
    while (punctMatcher.find()) { 
     positionToString.put(punctMatcher.start(), punctMatcher.group()) 
    } 
    Matcher wordMatcher = // ... same as before 
    // Then positionToString.values() will contain the 
    // ordered words and punctuation characters. 
} 

1. ...每次找到它时，都可以尝试查看以前出现的.字符（currentIndex - 1）。

Answer 4

你可以试试用省略号代替第一三重点：

String sentence = "In the preceding examples, classes derived from..."; 
    String[] split = sentence.replace("...", "…").split(" +|(?=,|\\p{Punct}|…)"); 

然后你可以离开它，因为它是或将其转换回由整个阵列上运行replace("…", "...")。

Answer 5

我相信这个方法将做你想做

public static List<String> split(String str) { 
    Pattern pattern = Pattern.compile("(\\w+)|(\\.{3})|[^\\s]"); 
    Matcher matcher = pattern.matcher(str); 
    List<String> list = new ArrayList<String>(); 
    while (matcher.find()) { 
     list.add(matcher.group()); 
    } 
    return list; 
} 

它将一个字符串分割成

1. 连续单词字符
2. 省略号...
3. 任何一个空格
别的分开什么

在这个例子中

"In the preceding examples, classes.. derived from... Hello, World! foo!bar" 

名单将于

[0] In 
[1] the 
[2] preceding 
[3] examples 
[4] , 
[5] classes 
[6] . 
[7] . 
[8] derived 
[9] from 
[10] ... 
[11] Hello 
[12] , 
[13] World 
[14] ! 
[15] foo 
[16] ! 
[17] bar 

Answer 6

现在我会说，最简单的，可能干净的方式来实现你想要的是把重点放在寻找你的阵列想要的数据，而不是找到将文字分开的地方。

我这样说是因为split介绍了很多的例如像问题：

• split(" +|(?=\\p{Punct})");将拆分只在空间和前标点字符，这意味着像"abc" def文本将被分割分成"abc"def。所以如你所见，它不会分裂后"在"abc。

• 前面的问题可以很容易地通过添加另一个|(?<=\\p{Punct})条件像split(" +|(?=\\p{Punct})|(?<=\\p{Punct})")来解决，但是我们仍然没有解决你所有的，因为...问题。所以我们需要找出方法来防止这些点之间的分裂.|.|.。

  • 要做到这一点，我们可以尝试从\p{Punct}排除.，并试图单独处理，但这样会使我们的正则表达式相当复杂。
  • 其他方法可能会用一些唯一的字符串替换...，在我们的split逻辑中添加此字符串，并在我们的结果数组中将其替换回...。但是这种方法也需要我们知道文本中永远不可能存在的字符串，所以每次我们解析文本时都需要生成它。
• 另一个可能的问题是，pre-java-8正则表达式引擎会在结果数组开头处生成空元素，如果标点符号将是第一个字符，如"。所以在Java 7 "foo" bar字符串上拆分(?=\p{Punct)将导致[ , "foo, " bar]元素。为了避免这个问题，你需要添加像(?!^)这样的正则表达式来防止在字符串开始时分裂。

无论如何，这些解决方案看起来过于复杂。

---

所以不是split方法考虑使用find方法从Matcher类，并专注于你想在结果数组什么。

尝试使用图案像这样的：[.]{3}|\p{Punct}|[\S&&\P{Punct}]+"

• [.]{3}将匹配...

• \p{Punct}将匹配单个标点字符根据documentation这是!"#$%&'()*+,-./:;<=>?@[]^_`{|}~

  !"#$%一个'()*+,-./:;<=>?@[\]^_`{|}~

• [\S&&\P{Punct}]+将匹配的一个或多个字符，这是
  • \S不空格
  • &&和
  • \P{Punct}不标点符号字符（\P{foo}是\p{foo}否定）。

演示：

String sentence = "In (the) preceding examples, classes derived from..."; 
Pattern p = Pattern.compile("[.]{3}|\\p{Punct}|[\\S&&\\P{Punct}]+"); 
Matcher m = p.matcher(sentence); 
while(m.find()){ 
    System.out.println(m.group()); 
} 

输出：

In 
(
the 
) 
preceding 
examples 
, 
classes 
derived 
from 
... 

Answer 7

这里的另一个例子。这个解决方案可能适用于所有组合。

import java.util.ArrayList; 
import java.util.List; 
import java.util.regex.Matcher; 
import java.util.regex.Pattern; 

public class App { 

    public static void main(String[] args) {  
     String sentence = "In the preceding examples, classes derived from..."; 
     List<String> list = splitWithPunctuation(sentence); 
     System.out.println(list); 
    } 

    public static List<String> splitWithPunctuation(String sentence) { 
     Pattern p = Pattern.compile("([^a-zA-Z\\d\\s]+)"); 
     String[] split = sentence.split(" "); 
     List<String> list = new ArrayList<>(); 

     for (String s : split) { 
      Matcher matcher = p.matcher(s); 
      boolean found = false; 
      int i = 0; 
      while (matcher.find()) { 
       found = true; 
       list.add(s.substring(i, matcher.start())); 
       list.add(s.substring(matcher.start(), matcher.end())); 
       i = matcher.end(); 
      } 

      if (found) { 
       if (i < s.length()) 
        list.add(s.substring(i, s.length())); 
      } else 
       list.add(s); 
     } 

     return list; 
    } 
} 

输出：

In 
the 
preceding 
examples 
, 
classes 
derived 
from 
... 

更复杂的例子：

String sentence = "In the preced^^^in## examp!les, classes derived from..."; 
List<String> list = splitWithPunctuation(sentence); 
System.out.println(list); 

输出：

In 
the 
preced 
^^^ 
in 
## 
examp 
! 
les 
, 
classes 
derived 
from 
...