我有一个使用管道分隔的文件，我解析它以获取系统选项。 这个环境对堆分配非常敏感，我们正在尝试避免垃圾回收。
以下是我用于解析管道分隔字符串的代码。此函数被调用约35000次。 我想知道是否有更好的方法，可以减少内存占用。
以下是我用于解析管道分隔字符串的代码。此函数被调用约35000次。 我想知道是否有更好的方法，可以减少内存占用。
static int countFields(String s) {
int n = 1;
for (int i = 0; i < s.length(); i++)
if (s.charAt(i) == '|')
n++;
return n;
}
static String[] splitFields(String s) {
String[] l = new String[countFields(s)];
for (int pos = 0, i = 0; i < l.length; i++) {
int end = s.indexOf('|', pos);
if (end == -1)
end = s.length();
l[i] = s.substring(pos, end);
pos = end + 1;
}
return l;
}
关于Java版本的编辑1：
由于业务需要，我们被困在JDK 1.6.0_25。
关于String和String[]使用的编辑2：
String[]用于执行系统设置逻辑。基本上，如果String[0].equals("true")则启用调试。这是使用模式。
关于垃圾回收对象的编辑3：
输入的String和String[]最终会被GC回收。输入的String是系统设置文件中的单行，文件全部处理完毕后回收，而String[]则是在整行处理完毕后回收。
解决方案编辑：
这是Peter Lawrey和zapl的解决方案的组合。此类不是线程安全的。
public class DelimitedString {
private static final Field EMPTY = new Field("");
private char delimiter = '|';
private String line = null;
private Field field = new Field();
public DelimitedString() { }
public DelimitedString(char delimiter) {
this.delimiter = delimiter;
}
public void set(String line) {
this.line = line;
}
public int length() {
int numberOfFields = 0;
if (line == null)
return numberOfFields;
int idx = line.indexOf(delimiter);
while (idx >= 0) {
numberOfFields++;
idx = line.indexOf(delimiter, idx + 1);
}
return ++numberOfFields;
}
public Field get(int fieldIndex) {
if (line == null)
return EMPTY;
int currentField = 0;
int startIndex = 0;
while (currentField < fieldIndex) {
startIndex = line.indexOf(delimiter, startIndex);
// not enough fields
if (startIndex < 0)
return EMPTY;
startIndex++;
currentField++;
}
int endIndex = line.indexOf(delimiter, startIndex);
if (endIndex == -1)
endIndex = line.length();
fieldLength = endIndex - startIndex;
if (fieldLength == 0)
return EMPTY;
// Populate field
for (int i = 0; i < fieldLength; i++) {
char c = line.charAt(startIndex + i);
field.bytes[i] = (byte) c;
}
field.fieldLength = fieldLength;
return field;
}
@Override
public String toString() {
return new String(line + " current field = " + field.toString());
}
public static class Field {
// Max size of a field
private static final int DEFAULT_SIZE = 1024;
private byte[] bytes = null;
private int fieldLength = Integer.MIN_VALUE;
public Field() {
bytes = new byte[DEFAULT_SIZE];
fieldLength = Integer.MIN_VALUE;
}
public Field(byte[] bytes) {
set(bytes);
}
public Field(String str) {
set(str.getBytes());
}
public void set(byte[] str) {
int len = str.length;
bytes = new byte[len];
for (int i = 0; i < len; i++) {
byte b = str[i];
bytes[i] = b;
}
fieldLength = len;
}
public char charAt(int i) {
return (char) bytes[i];
}
public byte[] getBytes() {
return bytes;
}
public int length() {
return fieldLength;
}
public short getShort() {
return (short) readLong();
}
public int getInt() {
return (int) readLong();
}
public long getLong() {
return readLong();
}
@Override
public String toString() {
return (new String(bytes, 0, fieldLength));
}
// Code taken from Java class Long method parseLong()
public long readLong() {
int radix = 10;
long result = 0;
boolean negative = false;
int i = 0, len = fieldLength;
long limit = -Long.MAX_VALUE;
long multmin;
int digit;
if (len > 0) {
char firstChar = (char) bytes[0];
if (firstChar < '0') { // Possible leading "-"
if (firstChar == '-') {
negative = true;
limit = Long.MIN_VALUE;
} else
throw new NumberFormatException("Invalid leading character.");
if (len == 1) // Cannot have lone "-"
throw new NumberFormatException("Negative sign without trailing digits.");
i++;
}
multmin = limit / radix;
while (i < len) {
// Accumulating negatively avoids surprises near MAX_VALUE
digit = Character.digit(bytes[i++], radix);
if (digit < 0)
throw new NumberFormatException("Single digit is less than zero.");
if (result < multmin)
throw new NumberFormatException("Result is less than limit.");
result *= radix;
if (result < limit + digit)
throw new NumberFormatException("Result is less than limit plus new digit.");
result -= digit;
}
} else {
throw new NumberFormatException("Called readLong with a length <= 0. len=" + len);
}
return negative ? result : -result;
}
}
}
String[]对象在空间和对象数量上并不比long[]对象更昂贵，并且通常不值得费力去避免创建它。它基本上是一个对象段，大约长为(4 + N) * 8字节。 - Hot Licks