Java编程思想学习笔记——字符串

前言

字符串操作是计算机程序设计中最常见的行为。

不可变String

String对象是不可变的

重载"+"与StringBuilder

String对象是不可变的，可以给String对象加任意多得别名。

String对象具有只读特性，所以指向它的任何引用都不可能改变它的值。

String a = "a";
String b = a;
System.out.println("first: a=" + a + " b=" + b);
b = "b";
System.out.println("second: a=" + a + " b=" + b);

运行结果：

first: a=a b=a
second: a=a b=b

String对象的不可变性会带来一定的效率问题。

比如为String对象重载的"+"操作符。

重载：一个操作符在应用于特定类时，被赋予特殊的意义。Java中，用于String的"+"与"+="是仅有的两个重载过的操作符。Java不允许程序员重载任何操作符。

public class Connection {
    public static void main(String[] args) {
        String str = "hello";
        String anotherStr = "abc" + str + "def" + 123;
        System.out.println(anotherStr);
    }
}

Compiled from "Connection.java"
public class Connection {
  public Connection();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: ldc           #2                  // String hello
       2: astore_1
       3: new           #3                  // class java/lang/StringBuilder
       6: dup
       7: invokespecial #4                  // Method java/lang/StringBuilder."<init>":()V
      10: ldc           #5                  // String abc
      12: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      15: aload_1
      16: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      19: ldc           #7                  // String def
      21: invokevirtual #6                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
      24: bipush        123
      26: invokevirtual #8                  // Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;
      29: invokevirtual #9                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      32: astore_2
      33: getstatic     #10                 // Field java/lang/System.out:Ljava/io/PrintStream;
      36: aload_2
      37: invokevirtual #11                 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      40: return
}

无意识的递归

Java中的每个类从根本上都是继承自Object。

public class Object {
  ...
  //Object类的toString方法
  public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
   ...
}

标准容器类同样是继承自Object类，因此容器类都有toString()方法，并且覆写了这个方法来表达容器本身和它所包含的对象。

比如ArrayList.toString()方法,查看源代码可知，ArrayList类继承自AbstractList类，而AbstractList类覆写了toString()方法。

它会遍历AbstractList中所包含的所有对象，并调用每个元素上的toString方法。

public abstract class AbstractCollection<E> implements Collection<E> {
  ...
 public String toString() {
        Iterator<E> it = iterator();
        if (! it.hasNext())
            return "[]";

        StringBuilder sb = new StringBuilder();
        sb.append('[');
        for (;;) {
            E e = it.next();
            sb.append(e == this ? "(this Collection)" : e);
            if (! it.hasNext())
                return sb.append(']').toString();
            sb.append(',').append(' ');
        }
    }
...
}

想打印对象的内存地址，应该调用super.toString()方法，也就是基类Object的toString()方法。

class A{
   public static void main(String [] args){
    System.out.println(new A());
  }
  @Override
  public void toString(){
     // return "A:"+this;//会造成递归调用，导致栈溢出。
      return "A:"+super.toString();
  }
}

正则表达式

解决各种字符串处理相关的问题：匹配，选择，编辑以及验证。

基础

以某种方式来描述字符串

Java中，\表示：插入一个正则表达式的反斜线，它后面的字符具有特殊的意义。

数字：\\d
反斜线:\\\\

String类中的，正则匹配方法：

1.匹配matches()方法。查看源代码，可以知道该方法实际上是调用了Pattern类的matches()方法来实现正则表达式的匹配功能的。

2.分隔split()方法，这个方法能将字符串从正则表达式匹配的地方切开。

3.替代replaceAll(),replaceFirst()方法

 ...
 public boolean matches(String regex) {
        return Pattern.matches(regex, this);
    }
 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);
    }
    public String replaceFirst(String regex, String replacement) {
        return Pattern.compile(regex).matcher(this).replaceFirst(replacement);
    }
    public String replaceAll(String regex, String replacement) {
        return Pattern.compile(regex).matcher(this).replaceAll(replacement);
    }
 ...

创建正则表达式

![http://docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html]

量词

1.贪婪型

2.占有型

3.勉强型

CharSequence

接口CharSequence从CharBuffer,String,StringBuffer,StringBuilder类之中抽象出字符序列的的一般化定义：

interface CharSequence{
   charAt(int i);
   length();
   subSequence(int start,int end);
   toString();
}

Pattern和Matcher

String类功能有限，我们可以自己构造强大的正则表达式对象。

导入java.util.regex包，使用静态方法Pattern.compile()来编译正则表达式。

  public static Pattern compile(String regex) {
        return new Pattern(regex, 0);
    }

compile()方法返回一个Pattern对象，表示编译后的正则表达式。

  public Matcher matcher(CharSequence input) {
        if (!compiled) {
            synchronized(this) {
                if (!compiled)
                    compile();
            }
        }
        Matcher m = new Matcher(this, input);
        return m;
    }

对于已编译正则表达式的Pattern对象的matcher()方法，加上要被匹配的字符串，返回一个Matcher对象。

使用Matcher对象的各种方法，我们就能判断各种不同类型的匹配是否成功。

boolean matches() //判断整个字符串是否匹配
boolean lookingAt()//判断字符串的起始部分是否能够匹配
boolean find()
boolean find(int start)