全面的44个Java 性能调优细节

• 减小代码的体积

• 提高代码运行的效率

代码优化细节

for (int i = ; i < list.size(); i++)
{...}

for (int i = , length = list.size(); i < length; i++)
{...}

String str = "aaa";
if (i == 1)
{
　　list.add(str);
}

if (i == 1)
{
　　String str = "aaa";
　　list.add(str);
}

StringBuilder()　　　　　　// 默认分配16个字符的空间
StringBuilder(int size)　　// 默认分配size个字符的空间
StringBuilder(String str)　// 默认分配16个字符+str.length()个字符空间

• 在4096 的基础上，再申请8194个大小的字符数组，加起来相当于一次申请了12290个大小的字符数组，如果一开始能指定5000个大小的字符数组，就节省了一倍以上的空间

• 把原来的4096个字符拷贝到新的的字符数组中去

for (val = ; val < 100000; val += 5)
{
　　a = val * 8;
　　b = val / 2;
}

for (val = ; val < 100000; val += 5)
{
　　a = val << 3;
　　b = val >> 1;
}

for (int i = 1; i <= count; i++)
{
    Object obj = new Object();    
}

Object obj = null;
for (int i = ; i <= count; i++)
{
    obj = new Object();
}

• 控制资源的使用，通过线程同步来控制资源的并发访问

• 控制实例的产生，以达到节约资源的目的

• 控制数据的共享，在不建立直接关联的条件下，让多个不相关的进程或线程之间实现通信

public class A
{
    private static B b = new B();  
}

if (list instanceof RandomAccess)
{
    for (int i = ; i < list.size(); i++){}
}
else
{
    Iterator<?> iterator = list.iterable();
    while (iterator.hasNext()){iterator.next()}
}

cnblogs.com/xrq730/p/4868465.html

cnblogs.com/xrq730/p/4851530.html

cnblogs.com/xrq730/p/4862111.html

• 违反了面向对象的编程思想，Java讲求一切都是对象，太多的形参，和面向对象的编程思想并不契合

• 参数太多势必导致方法调用的出错概率增加

String str = "123";
if (str.equals("123"))
{
    ...
}

String str = "123";
if ("123".equals(str))
{
    ...
}

int i = 2;
if (i == 1)
{
    ...
}
else
{
    ...
}

int i = 2;
if (i = 1)
{
    ...
}
else
{
    ...
}

int i = 2;
if (1 == i)
{
    ...
}
else
{
    ...
}

public static void main(String[] args)
{
    int[] is = new int[]{1, 2, 3};
    System.out.println(is.toString());
}

[I@18a992f

public static void main(String[] args)
{
    long l = 12345678901234L;
    int i = (int)l;
    System.out.println(i);
}

1942892530

0000 0000 0000 0000 0000 1011 0011 1010 0111 0011 1100 1110 0010 1111 1111 0010

0111 0011 1100 1110 0010 1111 1111 0010

• 整型默认的数据类型是int，long l = 12345678901234L，这个数字已经超出了int的范围了，所以后有一个L，表示这是一个long型数。顺便，浮点型的默认类型是double，所以定义float的时候要写成float f = 3.5f

• 接下来再写一句int ii = l + i;会报错，因为long + int是一个long，不能赋值给int

public static void main(String[] args)
{
    int loopTime = 50000;
    Integer i = ;
    long startTime = System.currentTimeMillis();
    for (int j = ; j < loopTime; j++)
    {
        String str = String.valueOf(i);
    }    
    System.out.println("String.valueOf()：" + (System.currentTimeMillis() - startTime) + "ms");
    startTime = System.currentTimeMillis();
    for (int j = ; j < loopTime; j++)
    {
        String str = i.toString();
    }    
    System.out.println("Integer.toString()：" + (System.currentTimeMillis() - startTime) + "ms");
    startTime = System.currentTimeMillis();
    for (int j = ; j < loopTime; j++)
    {
        String str = i + "";
    }    
    System.out.println("i + \"\"：" + (System.currentTimeMillis() - startTime) + "ms");
}

String.valueOf()：11ms
Integer.toString()：5ms
i + ""：25ms

• String.valueOf()方法底层调用了Integer.toString()方法，但是会在调用前做空判断

• Integer.toString()方法就不说了，直接调用了

• i + ""底层使用了StringBuilder实现，先用append方法拼接，再用toString()方法获取字符串

public static void main(String[] args)
{
    HashMap<String, String> hm = new HashMap<String, String>();
    hm.put("111", "222");

    Set<Map.Entry<String, String>> entrySet = hm.entrySet();
    Iterator<Map.Entry<String, String>> iter = entrySet.iterator();
    while (iter.hasNext())
    {
        Map.Entry<String, String> entry = iter.next();
        System.out.println(entry.getKey() + "\t" + entry.getValue());
    }
}

try
{
    XXX.close();
    YYY.close();
}
catch (Exception e)
{
    ...
}

try
{
    XXX.close();
}
catch (Exception e)
{
    ...
}
try
{
    YYY.close();
}
catch (Exception e)
{
    ...
}

/* ThreadLocal values pertaining to this thread. This map is maintained
 * by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;

• 清楚地可以知道这个方法由父类继承而来

• getObject()和get0bject()方法，前者第四个字母是"O"，后者第四个子母是"0"，加了@Override注解可以马上判断是否重写成功

• 在抽象类中对方法签名进行修改，实现类会马上报出编译错误

public String appendStr(String oriStr, String... appendStrs) {
    if (appendStrs == null || appendStrs.length == ) {
        return oriStr;
    }

    for (String appendStr : appendStrs) {
        oriStr += appendStr;
    }

    return oriStr;
}

• ArithmeticException可以通过判断除数是否为空来规避

• NullPointerException可以通过判断对象是否为空来规避

• IndexOutOfBoundsException可以通过判断数组/字符串长度来规避

• ClassCastException可以通过instanceof关键字来规避

• ConcurrentModificationException可以使用迭代器来规避

public int nextInt() {
    return next(32);
}

protected int next(int bits) {
    long oldseed, nextseed;
    AtomicLong seed = this.seed;
    do {
        oldseed = seed.get();
        nextseed = (oldseed * multiplier + addend) & mask;
    } while (!seed.compareAndSet(oldseed, nextseed));
    return (int)(nextseed >>> (48 - bits));
}

/**
 * The internal state associated with this pseudorandom number generator.
 * (The specs for the methods in this class describe the ongoing
 * computation of this value.)
 */
private final AtomicLong seed;

扫码加技术交流微信群，技术探讨 信息分享 学习互助，还有直播等福利活动等着你~