JAVA split 英文句号

我会带着你远行 2022-01-23 07:59 252阅读 0赞

简单的问题。。越是简单的问题，越能看出功底。。。。

一组字符串。。。。。aaa.bbb.ccc,对其根据英文句好进行切割。。分别拿到不同的数据。。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1lvdW5nTGVlMTY_size_16_color_FFFFFF_t_70][]

不是想要的aa 的结果。。。。而且抛了一个ArrayIndexOutOfBoundsException；

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1lvdW5nTGVlMTY_size_16_color_FFFFFF_t_70 1][]

仔细看下，经过“."切割后的也是一个String\[\]，问题出在哪里了呢。。。。。

/**
 * Splits this string around matches of the given <a
 * href="../util/regex/Pattern.html#sum">regular expression</a>.
 *
 * This method works as if by invoking the two-argument {@link
 * #split(String, int) split} method with the given expression and a limit
 * argument of zero. Trailing empty strings are therefore not included in
 * the resulting array.
 *
 * The string {@code "boo:and:foo"}, for example, yields the following
 * results with these expressions:
 *
 * <blockquote><table cellpadding=1 cellspacing=0 summary="Split examples showing regex and result">
 * <tr>
 * <th>Regex</th>
 * <th>Result</th>
 * </tr>
 * <tr><td align=center>:</td>
 * <td>{@code { "boo", "and", "foo" }}</td></tr>
 * <tr><td align=center>o</td>
 * <td>{@code { "b", "", ":and:f" }}</td></tr>
 * </table></blockquote>
 *
 *
 * @param regex
 * the delimiting regular expression
 *
 * @return the array of strings computed by splitting this string
 * around matches of the given regular expression
 *
 * @throws PatternSyntaxException
 * if the regular expression's syntax is invalid
 *
 * @see java.util.regex.Pattern
 *
 * @since 1.4
 * @spec JSR-51
 */
 public String[] split(String regex) {
 return split(regex, 0);
 }

split的是一个regex，是一个正则表达式。。。。。而”.“在正则表达式中表示所有。。。。所以。。。

/**
 * Splits this string around matches of the given
 * <a href="../util/regex/Pattern.html#sum">regular expression</a>.
 *
 * The array returned by this method contains each substring of this
 * string that is terminated by another substring that matches the given
 * expression or is terminated by the end of the string. The substrings in
 * the array are in the order in which they occur in this string. If the
 * expression does not match any part of the input then the resulting array
 * has just one element, namely this string.
 *
 * When there is a positive-width match at the beginning of this
 * string then an empty leading substring is included at the beginning
 * of the resulting array. A zero-width match at the beginning however
 * never produces such empty leading substring.
 *
 * The {@code limit} parameter controls the number of times the
 * pattern is applied and therefore affects the length of the resulting
 * array. If the limit n is greater than zero then the pattern
 * will be applied at most n - 1 times, the array's
 * length will be no greater than n, and the array's last entry
 * will contain all input beyond the last matched delimiter. If n
 * is non-positive then the pattern will be applied as many times as
 * possible and the array can have any length. If n is zero then
 * the pattern will be applied as many times as possible, the array can
 * have any length, and trailing empty strings will be discarded.
 *
 * The string {@code "boo:and:foo"}, for example, yields the
 * following results with these parameters:
 *
 * <blockquote><table cellpadding=1 cellspacing=0 summary="Split example showing regex, limit, and result">
 * <tr>
 * <th>Regex</th>
 * <th>Limit</th>
 * <th>Result</th>
 * </tr>
 * <tr><td align=center>:</td>
 * <td align=center>2</td>
 * <td>{@code { "boo", "and:foo" }}</td></tr>
 * <tr><td align=center>:</td>
 * <td align=center>5</td>
 * <td>{@code { "boo", "and", "foo" }}</td></tr>
 * <tr><td align=center>:</td>
 * <td align=center>-2</td>
 * <td>{@code { "boo", "and", "foo" }}</td></tr>
 * <tr><td align=center>o</td>
 * <td align=center>5</td>
 * <td>{@code { "b", "", ":and:f", "", "" }}</td></tr>
 * <tr><td align=center>o</td>
 * <td align=center>-2</td>
 * <td>{@code { "b", "", ":and:f", "", "" }}</td></tr>
 * <tr><td align=center>o</td>
 * <td align=center>0</td>
 * <td>{@code { "b", "", ":and:f" }}</td></tr>
 * </table></blockquote>
 *
 * An invocation of this method of the form
 * str.{@code split(}regex{@code ,} n{@code )}
 * yields the same result as the expression
 *
 * <blockquote>
 * <code>
 * {@link java.util.regex.Pattern}.{@link
 * java.util.regex.Pattern#compile compile}(regex).{@link
 * java.util.regex.Pattern#split(java.lang.CharSequence,int) split}(str, n)
 * </code>
 * </blockquote>
 *
 *
 * @param regex
 * the delimiting regular expression
 *
 * @param limit
 * the result threshold, as described above
 *
 * @return the array of strings computed by splitting this string
 * around matches of the given regular expression
 *
 * @throws PatternSyntaxException
 * if the regular expression's syntax is invalid
 *
 * @see java.util.regex.Pattern
 *
 * @since 1.4
 * @spec JSR-51
 */
 public String[] split(String regex, int limit) {
 /* fastpath if the regex is a
 (1)one-char String and this character is not one of the
 RegEx's meta characters ".$|()[{^?*+\\", or
 (2)two-char String and the first char is the backslash and
 the second is not the ascii digit or ascii letter.
 */
 char ch = 0;
 if (((regex.value.length == 1 &&
 ".$|()[{^?*+\\".indexOf(ch = regex.charAt(0)) == -1) ||
 (regex.length() == 2 &&
 regex.charAt(0) == '\\' &&
 (((ch = regex.charAt(1))-'0')|('9'-ch)) < 0 &&
 ((ch-'a')|('z'-ch)) < 0 &&
 ((ch-'A')|('Z'-ch)) < 0)) &&
 (ch < Character.MIN_HIGH_SURROGATE ||
 ch > Character.MAX_LOW_SURROGATE))
 {
 int off = 0;
 int next = 0;
 boolean limited = limit > 0;
 ArrayList<String> list = new ArrayList<>();
 while ((next = indexOf(ch, off)) != -1) {
 if (!limited || list.size() < limit - 1) {
 list.add(substring(off, next));
 off = next + 1;
 } else { // last one
 //assert (list.size() == limit - 1);
 list.add(substring(off, value.length));
 off = value.length;
 break;
 }
 }
 // If no match was found, return this
 if (off == 0)
 return new String[]{this};
 
 // Add remaining segment
 if (!limited || list.size() < limit)
 list.add(substring(off, value.length));
 
 // Construct result
 int resultSize = list.size();
 if (limit == 0) {
 while (resultSize > 0 && list.get(resultSize - 1).length() == 0) {
 resultSize--;
 }
 }
 String[] result = new String[resultSize];
 return list.subList(0, resultSize).toArray(result);
 }
 return Pattern.compile(regex).split(this, limit);
 }

具体的实现为上。。。虽然有很多看不懂的，还是要逼着自己去看的。。。

既然要的是正则表达式。。。所以问题就可以了。。。

SOLUTIONS：

一般是不会用”.“进行拼接的。。。如果真是拼接了。。应该

//1，使用转义符
            String bb = "aa.bb.bb";
            String[] split1 = bb.split("\\.");
            System.out.println(split1[0]); // 预测结果 aa
    
            //2，先将“.”换成正则的非关键字。。“，”等其他字符
            String aa = "bb.aa.cc";
            String[] split = aa.replace(".", ",").split(",");
            System.out.println(split[0]);

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1lvdW5nTGVlMTY_size_16_color_FFFFFF_t_70 2][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1lvdW5nTGVlMTY_size_16_color_FFFFFF_t_70]: /images/20220123/975ee20ef44349bc8adf10e2b9a2c7c4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1lvdW5nTGVlMTY_size_16_color_FFFFFF_t_70 1]: /images/20220123/276b0d0b6f7f4e34acdb43fd03b4dcb7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1lvdW5nTGVlMTY_size_16_color_FFFFFF_t_70 2]: /images/20220123/103bd30853e74eb893caada3dce14ecb.png