本文发表于KuTear's Blog,转载请注明

最简单的例子说起

数组

粗糙数组

数组中构成矩阵的每个向量都可以具有任意的长度

 int[][] array = new int[][]{
        new int[]{1, 2, 3},
        new int[]{1, 2}
 };
 System.out.println(Arrays.deepToString(array));//输出 [[1, 2, 3], [1, 2]]
 System.out.println(array[1][2]);// java.lang.ArrayIndexOutOfBoundsException: 2

基础

• 新生成一个数组，其中所有引用被自动初始化为null，基本类型被初始化为0（boolean是false）

Arrays

数组与泛型

通常，数组与泛型不能很好结合，你不能实例化具有参数化类型的数组。Peel<Banana>[] peels = new Peel<>[10]不合法，擦除会移除参数类型信息，而数组必须知道它们所持有的确切类型，以强制保证类型安全。

类型擦除

Class c1 = new ArrayList<Integer>().getClass();
Class c2 = new ArrayList<String>().getClass();
System.out.println(c1 == c2); //Output: true

参数化方法

private <T> Class get(T data){
        return data.getClass();
}

参数化类

public class Container<K, V> {
    private K key;
    private V value;

    public Container(K k, V v) {
        key = k;
        value = v;
    }
}

泛型自动打包拆包

HashMap<String,Integer> map = new HashMap<>();
map.put("one",1);  //  int ---> Integer
int value = map.get("one"); // Integer ---> int

通过反编译查看实现

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

  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class java/util/HashMap
       3: dup
       4: invokespecial #3                  // Method java/util/HashMap."<init>":()V
       7: astore_1
       8: aload_1
       9: ldc           #4                  // String one
      11: iconst_1
      12: invokestatic  #5                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;[打包]
      15: invokevirtual #6                  // Method java/util/HashMap.put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/
lang/Object;
      18: pop
      19: aload_1
      20: ldc           #4                  // String one
      22: invokevirtual #7                  // Method java/util/HashMap.get:(Ljava/lang/Object;)Ljava/lang/Object;
      25: checkcast     #8                  // class java/lang/Integer
      28: invokevirtual #9                  // Method java/lang/Integer.intValue:()I [拆包]
      31: istore_2
      32: return
}

字符串

String对象不可变

任意的包含改变String的方法其实都是重新生成对象

//String.java
public String substring(int beginIndex, int endIndex) {
        if (beginIndex < 0) {
            throw new StringIndexOutOfBoundsException(beginIndex);
        }
        if (endIndex > value.length) {
            throw new StringIndexOutOfBoundsException(endIndex);
        }
        int subLen = endIndex - beginIndex;
        if (subLen < 0) {
            throw new StringIndexOutOfBoundsException(subLen);
        }
        return ((beginIndex == 0) && (endIndex == value.length)) ? this
                : new String(value, beginIndex, subLen);
}

"+"重载原理

String result1 = "AAA" + "BBB";
String result2 = "AAABBB";

上面的result1==result2.
通过反编译可得

public static void main(java.lang.String[]);
  Code:
     0: ldc           #2                  // String AAABBB
     2: astore_1
     3: ldc           #2                  // String AAABBB
     5: astore_2
     6: return

java编译器对它进行了优化.

public static void main(String[] args) {
       String result1 = new String("AAA");
       String result2 = result1+"BBB";
}

  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class java/lang/String
       3: dup
       4: ldc           #3                  // String AAA
       6: invokespecial #4                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
       9: astore_1
      10: new           #5                  // class java/lang/StringBuilder
      13: dup
      14: invokespecial #6                  // Method java/lang/StringBuilder."<init>":()V
      17: aload_1
      18: invokevirtual #7                  // Method java/lang/StringBuilder.append(Ljava/lang/String;)Ljava/lang/StringBuilder;
      21: ldc           #8                  // String BBB
      23: invokevirtual #7                  // Method java/lang/StringBuilder.append(Ljava/lang/String;)Ljava/lang/StringBuilder;
      26: invokevirtual #9                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
      29: astore_2
      30: return
}

由上可以看出"+"的实现是利用StringBuilder的append()实现

for(int i = 0; i < fields.length; i++) {
            result += fields[i];
}

根据上面的原理知道这里的+=会生成临时StringBuilderN多个,会造成不必要的消耗,这时应主动用StringBuilder

StringBuilder result = new StringBuilder();
for(int i = 0; i < fields.length; i++) {
    result.append(fields[i]);
}
return result.toString();

StringBuilder & StringBuffer

StringBuffer是线程安全的，速度慢些；StringBuilder是线程不安全的，但是速度快些；

性能: StringBuilder > StringBuffer > String

字符格式化

• System.out.println("%d %f", x, y);
• System.out.printf("%d %f", x, y);
• java.util.Formatter
• String.format("%d %f", x, y);

正则表达式

补充

Java中的String内存分析

栈(Stack) ：存放基本类型的变量数据和对象的引用，但对象本身不存放在栈中，而是存放在堆（new 出来的对象）或者常量池中（字符串常量对象存放在常量池中）
堆(heap)：存放所有new出来的对象和数组。
常量池(constant pool)：在堆中分配出来的一块存储区域，存放储显式的String常量和基本类型常量(float、int等)。另外，可以存储不经常改变的东西(public static final)。常量池中的数据可以共享。
静态存储：存放静态成员（static定义的）。

Java中字符串对象创建有两种形式，一种为字面量形式，如String str = "droid";，另一种就是使用new这种标准的构造对象的方法，如String str = new String("droid").
当代码中出现字面量形式创建字符串对象时，JVM首先会对这个字面量进行检查，如果字符串常量池中存在相同内容的字符串对象的引用，则将这个引用返回，否则新的字符串对象被创建，然后将这个引用放入字符串常量池，并返回该引用。
当我们使用了new来构造字符串对象的时候，不管字符串常量池中有没有相同内容的对象的引用，新的字符串对象都会创建。

String str1 = "droid";
String str2 = "droid";
String str3 = new String("droid");
System.out.println(str1 == str2); //true
System.out.println(str1 == str3);//false

使用new创建对象,会在堆中创建对象(真正的内存占用),同时会在栈中创建指向堆中该对象的首地址的一个引用(相当于指针,同样占一小部分内存),当程序运行到该变量的作用域之后,栈中的引用会被置为空,但是此时堆中的内存并没有被即可释放,会根据程序所占用的内存Java GC在合适的时候回收堆中的内存.

对于String的比较问题,我们需要记住

String a = new String("A");
String b = new String("A");

对于new出来的对象,==操作是不相等的.

String a = "A";
String b = a + "B";

String c = "A" + "B";

通过反编译,发现b这里其实利用StringBuilder,最后用StringBuilder#toString()方法生成String,是经过new出来的,而前面说过,new出来的对象是栈中的引用指向堆中的地址,而字面量形式是栈中的引用指向常量区的地址.当然是不相等的.
而c经编译器优化等同于String c = "AB".

//StringBuilder.java
@Override
public String toString() {
    // Create a copy, don't share the array
    return new String(value, 0, count);
}

参考

• Java编程思想笔记五
• Java泛型：类型擦除
• Java中的字符串常量池