Question

我有android应用程序从telnet客户端获取巨大的String对象。后来我只使用大字符串的一小部分。我用

new String(Part of old string);

从旧的Strings char数组中分离新的字符串Char数组。所以旧的String应该收集垃圾，但是新的字符串出乎意料地仍然有对旧对象的引用。我可以用“Eclipse Memory Analyzer”看到它。这很快就溢出了我的16Meg应用程序内存。

如何避免这种情况？

    private WifiChannel parse1(String channLine){
    //scanning with "iwlist wlan0 scanning" the getChans1 method
    String[] input = channLine.split(System.getProperty("line.separator"));
    if (input.length < 4);
    String segment[];
    String segment2[];
    WifiChannel chan = new WifiChannel();
    try {
        if (input.length > 5){
            chan.setMacAddress(new String(input[0]));
            segment = input[1].split(":");
            chan.setChannel(Integer.parseInt(segment[1].trim()));
            segment = input[3].split(" ");
            segment2 = segment[20].split("=");
            chan.setQuality(new String(segment2[1]));
            segment2 = segment2[1].split("/");
            chan.setSignalStrength((Integer.parseInt(segment2[0].trim())*100)/Integer.parseInt(segment2[1].trim())+"%");
            segment2 = segment[23].split("=");
            try{chan.setSignalLevel(Integer.parseInt(segment2[1].trim()));}catch(Exception e){chan.setSignalLevel(0);}
            segment = input[5].split(":");
            chan.setName(new String(segment[1].replaceAll("^\"|\"$", "")));
            for (int i = 6;i<input.length;i++)
                if (input[i].contains("Mode"))
                    segment = input[i].split(":");
            chan.setChannelMode(new String(segment[1]));
            String band = "";
            if(channLine.contains("5.5 Mb/s"))band = band +"b";
            if(channLine.contains("12 Mb/s") )band = band +"g";
            chan.setBand(new String(band));
        }
    }catch (Exception e){Log.e("","",e);}
    return chan;
}

方法输入也是更大字符串的一部分。

Answer 1

每个String实例都由char数组支持：

public class String {

    private final char[] value;

    ...
}

由于效率原因，对字符串的某些操作可以创建一个与原始字符串共享char[]的新字符串实例。这是可能的，因为所有字符串都是不可变的。一个例子是substring()方法：

public String substring(int start) {
    if (start == 0) {
        return this;
    }
    if (start >= 0 && start <= count) {
        return new String(offset + start, count - start, value); // !!!
    }
    throw indexAndLength(start);
}

我添加注释的行调用的构造函数不会创建char[]的副本，而是直接引用它。你不能直接调用这个构造函数，因为它是包私有的，因此只能通过substring等方法在内部使用：

/*
 * Internal version of the String(char[], int, int) constructor.
 * Does not range check, null check, or copy the character array.
 */
String(int offset, int charCount, char[] chars) {
    this.value = chars;
    this.offset = offset;
    this.count = charCount;
}

现在，如果您从非常长的字符串创建一个短子字符串，那么短字符串仍会引用原始的大char[]。即使在原始字符串被垃圾收集之后，它的大数组仍然保留在内存中，即使新子字符串现在只能访问它的一小部分。这有效地创建了内存泄漏。

要解决此问题，通常的技巧是使用复制构造函数从子字符串创建一个新字符串，该复制构造函数仅复制原始char[]所需的范围。

String longString = "1234567890";
// backed by char[] of length 10

String substring = longString.substring(5);
// value is "67890", but still backed by the original char[] of length 10

String copy = new String(substring);
// also has value "67890", but now backed only by char[] of length 5

修改

为了完整性，这是copy-contructor的源代码。如您所见，如果原始字符串引用与字符串本身长度相同的数组，则不需要复制该数组，因为其中没有“死字符”。但是，如果数组大于字符串的长度，则执行数组“实时”范围的副本。

public String(String toCopy) { value = (toCopy.value.length == toCopy.count) ? toCopy.value : Arrays.copyOfRange(toCopy.value, toCopy.offset, toCopy.offset + toCopy.length()); offset = 0; count = value.length; }

注意：以上所有源代码均来自Android API 15

Android上的字符串复制

1 个答案: