Vấn đề về Integer và String

1. em có thể check source Java hàm Integer.valueOf() để hiểu rõ hơn vì:

   Integer a = 127; //=Integer.valueOf(127);
   Integer b = 127; //=Integer.valueOf(127);

và hàm ValueOf nó thể này:

public static Integer valueOf(int i) {
    if(i >= -128 && i <= IntegerCache.high)
        return IntegerCache.cache[i + 128];
    else
        return new Integer(i);
}

-> giá trị từ -127 đến 128 được cache lại, mục đích vì những số trong khoảng này dùng tần suất cực nhiều -> nên cache lại đỡ tốn bộ nhớ.

2. check hàm subString():

   String a = “ABC”; // String from pool
   String c = “ABCDEF”; // String from pool
   String b = c.subString(0,3);// new String
   String d = c.subString(0,3): // new String

hàm subString:

public String substring(int beginIndex, int endIndex) {
    if (beginIndex < 0) {
        throw new StringIndexOutOfBoundsException(beginIndex);
    }
    if (endIndex > count) {
        throw new StringIndexOutOfBoundsException(endIndex);
    }
    if (beginIndex > endIndex) {
        throw new StringIndexOutOfBoundsException(endIndex - beginIndex);
    }
    return ((beginIndex == 0) && (endIndex == count)) ? this :
        new String(offset + beginIndex, endIndex - beginIndex, value);
}

-> new String() luôn tạo ra 1 object mới nên reference luôn khác với những cái khác;

(offset + beginIndex, endIndex - beginIndex, value);

Chỗ này em chưa hiểu lắm, anh Cương có thể giải thích lại đoạn này đc không ạ?

đó là source của Java, mục đích là để lấy subString, a nghĩ hiểu thế là đủu
rồi

là do phiên bản cũ Java 6 thì phải, String có thêm offset để substring ko cần tạo chuỗi mới mà xài ké nội dung của chuỗi cũ luôn

new String(offset + beginIndex, endIndex - beginIndex, value); sẽ xài private constructor này:

  644       // Package private constructor which shares value array for speed.
  645       String(int offset, int count, char value[]) {
  646           this.value = value;
  647           this.offset = offset;
  648           this.count = count;
  649       }

//s gồm
//  value -> [a,b,c,d,e,f]
//  offset = 0
//  count = 6
//  hash = 0  (khi gọi hashCode() thì mới tính 1 lần hash code của "abcdef")
String s = "abcdef";

//a gồm
//  value -> [a,b,c,d,e,f]   (mảng mà s.value trỏ tới)
//  offset = 2
//  count = 2
//  hash = 0 (khi gọi hashCode() thì mới tính 1 lần hash code  của "cd")
String a = s.substring(2, 4); //"cd"

do có offset mà ko cần tạo mảng value mới, xài ké value của s, tiết kiệm bộ nhớ 1 tí. Nhưng sang Java 7u6 ko xài nữa:

    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);
    }

Chuỗi bây giờ chỉ còn có mảng value và int hash thôi, offset và count ko cần nữa

Cảm ơn a Em hiểu r.

check source Java

Dạ em cám ơn.
cái IntegerCache cái lớp đó lạ quá em chưa từng gặp…
Mà anh ơi mình cần tìm xem các phương thức có sẵn của java được viết như thế nào( hay source Java) thì tìm ở đâu ạ.

Em có thể xem ở đây:
http://grepcode.com/

dạ vâng em cám ơn anh