【Java】基础知识巩固（char和String）&&示例（一）

最近在项目上使用replaceAll（）函数去掉小数点的时候，发现并没有得到自己想要的结果。之后便记录下自己遇到的问题，今天正好有空，不用上班（开心~），顺便整理一下此处遇到的问题。博客已经一个多星期没有更新了，终于又开始了！

先放测试代码！

下面的代码主要分为三部分

（1）replace和replaceAll的区别
（2）关于char类型数据的使用
（3）关于String类的理解

代码：

package test;

public class replaceTest {
    public static void main(String[] args) {
        /*第一部分：关于replace和replaceAll的测试(涉及知识点：CharSequence，Pattern，Matcher。具体区别查看源码)*/
        String literal_s="\\ab\\.";
        System.out.println(literal_s.replace("\\.", ""));//输出为\ab,替换的是\.而不是小数点
        System.out.println(literal_s.replaceAll("\\.", ""));//输出为\ab\,替换的是.
        String s="192.168.102.1";
        System.out.println(s.replace(".", ""));//输出为1921681021
        System.out.println(s);//输出为：192.168.102.1,说明经过上面一行代码的执行之后改变的不是本身，而是副本
        System.out.println(s.replaceAll(".", ""));//输出结果为：（空），什么都没有，因为这里是正则表达式中的.，.在正则表达式中代表任何字符，因此全部被替换
        String[] split_arr=s.split(".");//replaceAll(String regex, String replacement)和split(String regex)这里的参数指的是正则表达式的字符串，对于.，是特殊字符，在正则表达式里面代表任何字符，
        System.out.println(s.replaceAll("\\.", ""));//输出结果为：1921681021
        /*第二部分：关于char类型的理解*/
        char c='\\';
//      char b='\';//此种写法错误
        char d='/';
        String zhuanyi_s="\\a";//长度为2
        System.out.println(zhuanyi_s.length());//输出为2
        char[] c_arr=zhuanyi_s.toCharArray();//数组内容为：[\,a]
        /*第三部分：关于String的理解（涉及知识点：栈，堆，常量池，引用，值）*/
        String a="a";
        String a_1="a";//
        System.out.println(a==a_1);//true，指向同一个内存地址，共享一个字符串常量池
        String b_obj=new String("test");
        String b_obj_copy=new String("test");
        System.out.println(b_obj==b_obj_copy);//false，指向不同地址
    }
}

1、replace和replaceAll函数的区别

1.1、replace函数源码：

  /**
     * Replaces each substring of this string that matches the literal target
     * sequence with the specified literal replacement sequence. The
     * replacement proceeds from the beginning of the string to the end, for
     * example, replacing "aa" with "b" in the string "aaa" will result in
     * "ba" rather than "ab".
     *
     * @param  target The sequence of char values to be replaced
     * @param  replacement The replacement sequence of char values
     * @return  The resulting string
     * @since 1.5
     */
    public String replace(CharSequence target, CharSequence replacement) {
        return Pattern.compile(target.toString(), Pattern.LITERAL).matcher(
                this).replaceAll(Matcher.quoteReplacement(replacement.toString()));
    }

从replace函数的内部来看，该处的target会被当作字面上的字符串，里面的字符不再具有正则表达式的特殊含义。Pattern.LITERAL的意思如下：

 /**
     * Enables literal parsing of the pattern.
     *
     * <p> When this flag is specified then the input string that specifies
     * the pattern is treated as a sequence of literal characters.
     * Metacharacters or escape sequences in the input sequence will be
     * given no special meaning.
     *
     * <p>The flags CASE_INSENSITIVE and UNICODE_CASE retain their impact on
     * matching when used in conjunction with this flag. The other flags
     * become superfluous.
     *
     * <p> There is no embedded flag character for enabling literal parsing.
     * @since 1.5
     */
    public static final int LITERAL = 0x10;

这里该变量的含义就是，对于输入的target字符串当作字面上的字符串来理解，对于正则表达式中的某些字符串可能会有特殊含义，比如.在正则表达式中表示小数点（\.在java定义字符串的时候是”\\.”），但是如果用\.作为replace(CharSequence target, CharSequence replacement)中的target变量传入的时候，这个时候，该变量会被当做\.（两个字符）的意思，而不再是小数点的意思。因此从上面的测试代码中可以看到literal_s被replace之后，输出值为\ab,而不是\ab\，而被replaceAll的时候，结果为\ab\。
注：
上面提到的元字符就是正则表达式中的元字符，元字符的知识参考：
（1）正则表达式 - 元字符：http://www.runoob.com/regexp/regexp-metachar.html
（2）String，StringBuilder等类是实现CharSequence类，其中，CharSequence类的知识移步。
String之String和CharSequence、StringBuilder和StringBuffer的区别：http://www.fengfly.com/plus/view-214077-1.html

1.2、replaceAll函数源码

此处是String类的replaceAll函数，避免和Matcher类的replaceAll函数混淆

/**
     * Replaces each substring of this string that matches the given <a
     * href="../util/regex/Pattern.html#sum">regular expression</a> with the
     * given replacement.
     *
     * <p> An invocation of this method of the form
     * <i>str</i>{@code .replaceAll(}<i>regex</i>{@code ,} <i>repl</i>{@code )}
     * yields exactly the same result as the expression
     *
     * <blockquote>
     * <code>
     * {@link java.util.regex.Pattern}.{@link
     * java.util.regex.Pattern#compile compile}(<i>regex</i>).{@link
     * java.util.regex.Pattern#matcher(java.lang.CharSequence) matcher}(<i>str</i>).{@link
     * java.util.regex.Matcher#replaceAll replaceAll}(<i>repl</i>)
     * </code>
     * </blockquote>
     *
     *<p>
     * Note that backslashes ({@code \}) and dollar signs ({@code $}) in the
     * replacement string may cause the results to be different than if it were
     * being treated as a literal replacement string; see
     * {@link java.util.regex.Matcher#replaceAll Matcher.replaceAll}.
     * Use {@link java.util.regex.Matcher#quoteReplacement} to suppress the special
     * meaning of these characters, if desired.
     *
     * @param   regex
     *          the regular expression to which this string is to be matched
     * @param   replacement
     *          the string to be substituted for each match
     *
     * @return  The resulting {@code String}
     *
     * @throws  PatternSyntaxException
     *          if the regular expression's syntax is invalid
     *
     * @see java.util.regex.Pattern
     *
     * @since 1.4
     * @spec JSR-51
     */
    public String replaceAll(String regex, String replacement) {
        return Pattern.compile(regex).matcher(this).replaceAll(replacement);
    }

从上面的源码可以看到，此处的replaceAll的参数regex是正则表达式的字符串的意思，也就是说，此处的参数会被当作正则表达式来处理（而String类的replace函数则是直接当作字面意思来看待）对比上面的测试代码可以看出差别！

总结：
从上面的两个函数可以看出来，两个函数的内部都使用了Matcher类的replaceAll函数，只不过在String类的replace函数在调用Matcher类的replaceAll之前对replacement参数进行了处理，处理过程是用Matcher.quoteReplacement(replacement.toString())，也就是调用了Matcher类的quoteReplacement函数，该函数的源码，见下：

/**
     * Returns a literal replacement <code>String</code> for the specified
     * <code>String</code>.
     *
     * This method produces a <code>String</code> that will work
     * as a literal replacement <code>s</code> in the
     * <code>appendReplacement</code> method of the {@link Matcher} class.
     * The <code>String</code> produced will match the sequence of characters
     * in <code>s</code> treated as a literal sequence. Slashes ('\') and
     * dollar signs ('$') will be given no special meaning.
     *
     * @param  s The string to be literalized
     * @return  A literal string replacement
     * @since 1.5
     */
    public static String quoteReplacement(String s) {
        if ((s.indexOf('\\') == -1) && (s.indexOf('$') == -1))
            return s;
        StringBuilder sb = new StringBuilder();
        for (int i=0; i<s.length(); i++) {
            char c = s.charAt(i);
            if (c == '\\' || c == '$') {
                sb.append('\\');
            }
            sb.append(c);
        }
        return sb.toString();
    }

从上面的源码可以看出来，如果replacement包含了\和$字符串，则需要在前面添加\进行转义。
Matcher类的replaceAll函数源码如下：

/**
     * Replaces every subsequence of the input sequence that matches the
     * pattern with the given replacement string.
     *
     * <p> This method first resets this matcher.  It then scans the input
     * sequence looking for matches of the pattern.  Characters that are not
     * part of any match are appended directly to the result string; each match
     * is replaced in the result by the replacement string.  The replacement
     * string may contain references to captured subsequences as in the {@link
     * #appendReplacement appendReplacement} method.
     *
     * <p> Note that backslashes (<tt>\</tt>) and dollar signs (<tt>$</tt>) in
     * the replacement string may cause the results to be different than if it
     * were being treated as a literal replacement string. Dollar signs may be
     * treated as references to captured subsequences as described above, and
     * backslashes are used to escape literal characters in the replacement
     * string.
     *
     * <p> Given the regular expression <tt>a*b</tt>, the input
     * <tt>"aabfooaabfooabfoob"</tt>, and the replacement string
     * <tt>"-"</tt>, an invocation of this method on a matcher for that
     * expression would yield the string <tt>"-foo-foo-foo-"</tt>.
     *
     * <p> Invoking this method changes this matcher's state.  If the matcher
     * is to be used in further matching operations then it should first be
     * reset.  </p>
     *
     * @param  replacement
     *         The replacement string
     *
     * @return  The string constructed by replacing each matching subsequence
     *          by the replacement string, substituting captured subsequences
     *          as needed
     */
    public String replaceAll(String replacement) {
        reset();
        boolean result = find();
        if (result) {
            StringBuffer sb = new StringBuffer();
            do {
                appendReplacement(sb, replacement);
                result = find();
            } while (result);
            appendTail(sb);
            return sb.toString();
        }
        return text.toString();
    }

下面通过示例对Matcher类的replaceAll函数方法理解

代码示例：

/*Matcher中的replaceAll的理解*/
Pattern p1 = Pattern.compile("cat");
Matcher m1 = p1.matcher("one cat two cats in the yard");
StringBuffer sb = new StringBuffer();
System.out.println(m1.replaceAll("\\$2"));//输出one $2 two $2s in the yard
System.out.println(m1.replaceAll("$2"));//运行错误，错误代码：java.lang.IndexOutOfBoundsException: No group 2，此处报错可以根据replaceAll函数里调用的appendReplacement函数查看其源代码，该异常即是该函数抛出

2、char的理解

char c='\\';//定义反斜杠字符（正确写法）
//      char b='\';//此种写法错误
char d='/';
String zhuanyi_s="\\a";//长度为2
char[] c_arr=zhuanyi_s.toCharArray();//数组内容为：[\,a]

从上面可以看出来，
（1）\表示的字符为反斜杠，长度为1。
（2）String类内部实现其实是一个char[]数组
根据源码，可以看到String类含有一个名为value的char[]私有成员，其中1个常用构造函数如下：

   /**
     * Initializes a newly created {@code String} object so that it represents
     * the same sequence of characters as the argument; in other words, the
     * newly created string is a copy of the argument string. Unless an
     * explicit copy of {@code original} is needed, use of this constructor is
     * unnecessary since Strings are immutable.
     *
     * @param  original
     *         A {@code String}
     */
    public String(String original) {
        this.value = original.value;
        this.hash = original.hash;
    }

3、String类的理解

测试代码如下：

String a="a";
String a_new=new String("a");
System.out.println(a==a_new);//false
String a_1="a";//
System.out.println(a==a_1);//true，指向同一个内存地址，共享一个字符串常量池
String b_obj=new String("test");
String b_obj_copy=new String("test");
System.out.println(b_obj==b_obj_copy);//false，指向不同地址

对比上面的a_1和a两个引用，可以知道，这两个引用指向同一个地址，共享一个字符串常量
而通过b_obj和b_obj_copy知道，每次new一个对象时，两个引用指向不同地址（这里有个疑问，那么这两个引用是否是共用一个字符串呢？以后如果理解了，再来解释，先留个坑）。
结论：
（1）若两个变量直接赋值相同的字符串，则是同一个地址
（2）若两个变量都是利用构造函数生成，即使内容相同，也指向不同内存地址
一个疑问：
String类中的value成员是如何初始化的，怎么得到这个char数组的？

---

欢迎技术交流
wkang1993@outlook.com