开发中一些代码优化技巧及常见的错误

常见的代码优化技巧示例

类成员与方法的可见性最小化

使用位移操作替代乘除法

a = val << 3;
b = val >> 1;

尽量减少对变量的重复计算

//反例
for (int i = 0; i < list.size(); i++) {
    System.out.println("result");
}

//正例
for (int i = 0, length = list.size(); i < length; i++) {
    System.out.println("result");
}

不要捕捉RuntimeException

public String test1(List<String> list, int index) {
    try {
        return list.get(index);
    } catch (IndexOutOfBoundsException ex) {
        return null;
    }
}

//正例
public String test2(List<String> list, int index) {
    if (index >= list.size() || index < 0) {
        return null;
    }
    return list.get(index);
}

使用局部变量可避免在堆上分配

减少变量的作用范围

public void test(String str) {
    final int s = 100;
    if (!StringUtils.isEmpty(str)) {
        int result = s * s;
    }
}

尽量采用懒加载的策略，在需要的时候才创建

String str = "月鱼";
if (name == "Hi") {
    list.add(str);
}

if (name == "Hi") {
    String str = "月鱼";
    list.add(str);
}

访问静态变量直接使用类名

// 反例
int i = objectA.staticMethod();
// 正例
int i = ClassA.staticMethod();

字符串拼接使用StringBuilder

//反例
public class StringTest {
    @Test
    public void testStringPlus() {
        String str = "111";
        str += "222";
        str += "333";
        System.out.println(str);
    }

}

//正例
public class TestMain {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("111");
        sb.append("222");
        sb.append(333);
        System.out.println(sb.toString());
    }
}

重写对象的HashCode，不要简单地返回固定值

HashMap等集合初始化的时候，指定初始值大小

循环内不要不断创建对象引用

//反例
for (int i = 1; i <= size; i++) {
    Object obj = new Object();    
}

//正例
Object obj = null;
for (int i = 0; i <= size; i++) {
    obj = new Object();
}

遍历Map 的时候，使用 EntrySet 方法

Set<Map.Entry<String, String>> entryseSet = nmap.entrySet();
for (Map.Entry<String, String> entry : entryseSet) {
    System.out.println(entry.getKey()+","+entry.getValue());
}

不要在多线程下使用同一个 Random

public static void main(String[] args) {
    ThreadLocalRandom threadLocalRandom = ThreadLocalRandom.current();
    Thread thread1 = new Thread(()->{
        for (int i=0;i<10;i++){
            System.out.println("Thread1:"+threadLocalRandom.nextInt(10));
        }
    });
    Thread thread2 = new Thread(()->{
        for (int i=0;i<10;i++){
            System.out.println("Thread2:"+threadLocalRandom.nextInt(10));
        }
    });
    thread1.start();
    thread2.start();
}

自增推荐使用LongAddr

public class Test {
    public int longAdderTest(Blackhole blackhole) throws InterruptedException {
        LongAdder longAdder = new LongAdder();
        for (int i = 0; i < 1024; i++) {
            longAdder.add(1);
        }
        return longAdder.intValue();
    }
}

程序中要少用反射

常见的错误示例

多线程相关

• 使用了 ConcurrentHashMap，不代表对它的多个操作之间的状态是一致的，如果需要确保需要手动加锁

• 诸如size()、isEmpty()和containsValue()等聚合方法，在并发情况下可能会反映 ConcurrentHashMap 的中间状态。因此在并发情况下，这些方法的返回值只能用作参考，而不能用于流程控制

• 诸如putAll()这样的聚合方法也不能确保原子性，在putAll()的过程中去获取数据可能会获取到部分数据

Spring 事务

• 除非特殊配置（比如使用 AspectJ 静态织入实现 AOP），否则只有定义在 public 方法上的@Transactional才能生效」。原因是，Spring 默认通过动态代理的方式实现 AOP，对目标方法进行增强，private 方法无法代理到，Spring 自然也无法动态增强事务处理逻辑

• 必须通过代理过的类从外部调用目标方法才能生效

• 只有异常传播出了标记了@Transactional注解的方法，事务才能回滚

• 默认情况下，出现RuntimeException或Error的时候，Spring 才会回滚事务

• 对基本类型，比如 int、long，进行判等，只能使用 ==，比较的是直接值。因为基本类型的值就是其数值

• 对引用类型，比如 Integer、Long 和 String，进行判等，需要使用equals()进行内容判等。因为引用类型的直接值是指针，使用==的话，比较的是指针，也就是两个对象在内存中的地址，即比较它们是不是同一个对象，而不是比较对象的内容

//案例一
Integer a = 127; //Integer.valueOf(127)
Integer b = 127; //Integer.valueOf(127)
System.out.println("\nInteger a = 127;\n" + "Integer b = 127;\n" + "a == b ? " + (a == b)); //true

//案例二
Integer c = 128; //Integer.valueOf(128)
Integer d = 128; //Integer.valueOf(128)
System.out.println("\nInteger c = 128;\n" + "Integer d = 128;\n" + "c == d ? " + (c == d)); //false

//案例三
Integer e = 127; //Integer.valueOf(127)
Integer f = new Integer(127); //new instance
System.out.println("\nInteger e = 127;\n" + "Integer f = new Integer(127);\n" + "e == f ? " + (e == f)); //false

//案例四
Integer g = new Integer(127); //new instance
Integer h = new Integer(127); //new instance
System.out.println("\nInteger g = new Integer(127);\n" + "Integer h = new Integer(127);\n" + "g == h ? " + (g == h)); //false

//案例五
Integer i = 128; //unbox
int j = 128;
System.out.println("\nInteger i = 128;\n" + "int j = 128;\n" + "i == j ? " + (i == j)); //true

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

private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static final Integer cache[];

    static {
        // high value may be configured by property
        int h = 127;
        String integerCacheHighPropValue =
            sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
        if (integerCacheHighPropValue != null) {
            try {
                int i = parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);
                // Maximum array size is Integer.MAX_VALUE
                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            } catch( NumberFormatException nfe) {
                // If the property cannot be parsed into an int, ignore it.
            }
        }
        high = h;

        cache = new Integer[(high - low) + 1];
        int j = low;
        for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);

        // range [-128, 127] must be interned (JLS7 5.1.7)
        assert IntegerCache.high >= 127;
    }

    private IntegerCache() {}
}

String a = "1";
String b = "1";
System.out.println("\nString a = \"1\";\n" + "String b = \"1\";\n" + "a == b ? " + (a == b)); //true

String c = new String("2");
String d = new String("2");
System.out.println("\nString c = new String(\"2\");\n" + "String d = new String(\"2\");\n" + "c == d ? " + (c == d)); //false

String e = new String("3").intern();
String f = new String("3").intern();
System.out.println("\nString e = new String(\"3\").intern();\n" + "String f = new String(\"3\").intern();\n" + "e == f ? " + (e == f)); //true

String g = new String("4");
String h = new String("4");
System.out.println("\nString g = new String(\"4\");\n" + "String h = new String(\"4\");\n" + "g == h ? " + g.equals(h)); //true

public boolean equals(Object anObject) {
    if (this == anObject) {
        return true;
    }
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        int n = value.length;
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

• 考虑到性能，可以先进行指针判等，如果对象是同一个那么直接返回true

• 需要对另一方进行判空，空对象和自身进行比较，结果一定是 fasle

• 需要判断两个对象的类型，如果类型都不同，那么直接返回 false

• 确保类型相同的情况下再进行类型强制转换，然后逐一判断所有字段

public class Point {
    private int x;
    private int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Point that = (Point) o;
        return x == that.x && y == that.y;
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }

}

@Data
public class Person {
    private String name; //姓名
    private String identity; //身份证

    public Person(String name, String identity) {
        this.name = name;
        this.identity = identity;
    }
}

Person person1 = new Person("xiaoming", "001");
Person person2 = new Person("xiaoming", "001");
System.out.println("person1.equals(person2) ? " + person1.equals(person2)); //true

@Data
public class Person {
    @EqualsAndHashCode.Exclude
    private String name; //姓名

    private String identity; //身份证

    public Person(String name, String identity) {
        this.name = name;
        this.identity = identity;
    }
}

Person person1 = new Person("xiaoming", "001");
Person person2 = new Person("xiaohong", "001");
System.out.println("person1.equals(person2) ? " + person1.equals(person2)); //true

@Data
public class Employee extends Person {
    private String company;

    public Employee(String name, String identity, String company) {
        super(name, identity);
        this.company = company;
    }
}

Employee employee1 = new Employee("zhuye", "001", "bkjk.com");
Employee employee2 = new Employee("Joseph", "002", "bkjk.com");
System.out.println("employee1.equals(employee2) ? " + employee1.equals(employee2)); //true

@Data
@EqualsAndHashCode(callSuper = true)
public class Employee extends Person {}

数值计算

• 使用 BigDecimal 表示和计算浮点数，且务必使用字符串的构造方法来初始化 BigDecimal

• 如果一定要用 Double 来初始化 BigDecimal 的话，可以使用BigDecimal.valueOf()方法

double a = 0.3;
double b = 0.1;
System.out.println(a - b); //0.19999999999999998
BigDecimal bigDecimal = new BigDecimal(0.3);
System.out.println(bigDecimal); 
//0.299999999999999988897769753748434595763683319091796875

将0.3转成二进制的过程：
0.3 * 2 = 0.6 => .0 (.6)取0剩0.6
0.6 * 2 = 1.2 => .01 (.2)取1剩0.2
0.2 * 2 = 0.4 => .010 (.4)取0剩0.4
0.4 * 2 = 0.8 => .0100 (.8) 取0剩0.8
0.8 * 2 = 1.6 => .01001 (.6)取1剩0.6
.............

System.out.println(new BigDecimal("1.0").equals(new BigDecimal("1"))); //false

System.out.println(new BigDecimal("1.0").compareTo(new BigDecimal("1")) == 0); //true

Set<BigDecimal> hashSet1 = new HashSet<>();
hashSet1.add(new BigDecimal("1.0"));
System.out.println(hashSet1.contains(new BigDecimal("1"))); //false

1. 使用 TreeSet 替换 HashSet。TreeSet 不使用hashCode()方法，也不使用equals()比较元素，而是使用compareTo()方法，所以不会有问题

Set<BigDecimal> treeSet = new TreeSet<>();
treeSet.add(new BigDecimal("1.0"));
System.out.println(treeSet.contains(new BigDecimal("1"))); //true

2. 把 BigDecimal 存入 HashSet 或 HashMap 前，先使用stripTrailingZeros()方法去掉尾部的零，比较的时候也去掉尾部的 0，确保 value 相同的 BigDecimal，scale 也是一致的

Set<BigDecimal> hashSet2 = new HashSet<>();
hashSet2.add(new BigDecimal("1.0").stripTrailingZeros());
System.out.println(hashSet2.contains(new BigDecimal("1.000").stripTrailingZeros())); //true

Arrays.asList 把数据转换为 List

int[] arr = {1, 2, 3};
List<int[]> list = Arrays.asList(arr);
System.out.println(list.size()); //1

public static <T> List<T> asList(T... a) {
    return new ArrayList<>(a);
}

private static class ArrayList<E> extends AbstractList<E>
    implements RandomAccess, java.io.Serializable
{
    private static final long serialVersionUID = -2764017481108945198L;
    private final E[] a;

    ArrayList(E[] array) {
        a = Objects.requireNonNull(array);
    }

    @Override
    public E get(int index) {
        return a[index];
    }

    @Override
    public E set(int index, E element) {
        E oldValue = a[index];
        a[index] = element;
        return oldValue;
    }

    //...
}

String[] arr = {"1", "2", "3"};
List list = new ArrayList(Arrays.asList(arr));
arr[1] = "4";
list.add("5");

Map 是否支持空值

日期类

Date date = new Date(2024 - 1900, 8, 17, 10, 28, 30);
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//2024-09-17 10:28:30
System.out.println(formatter.format(date));

SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Calendar calendar = Calendar.getInstance();
calendar.set(2024, 8, 17, 10, 28, 30);
//2024-09-17 10:28:30(当前时区)
System.out.println(formatter.format(calendar.getTime()));
Calendar calendar2 = Calendar.getInstance(TimeZone.getTimeZone("America/New_York"));
calendar2.set(2024, Calendar.SEPTEMBER, 17, 10, 28, 30);
//2024-09-17 23:28:30(纽约时区)
System.out.println(formatter.format(calendar2.getTime()));

System.out.println(new Date(0));
System.out.println(TimeZone.getDefault().getID());

Thu Jan 01 08:00:00 CST 1970
Asia/Shanghai

String dateStr = "2024-01-02 22:00:00";
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//默认时区解析时间表示
Date date1 = formatter.parse(dateStr);
System.out.println(date1);
//纽约时区解析时间表示
formatter.setTimeZone(TimeZone.getTimeZone("America/New_York"));
Date date2 = formatter.parse(dateStr);
System.out.println(date2);

Thu Jan 02 22:00:00 CST 2024
Fri Jan 03 11:00:00 CST 2024

String stringDate = "2024-01-02 22:00:00";
SimpleDateFormat inputFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//同一Date
Date date = inputFormat.parse(stringDate);
//默认时区格式化输出
System.out.println(new SimpleDateFormat("[yyyy-MM-dd HH:mm:ss Z]").format(date));
//纽约时区格式化输出
TimeZone.setDefault(TimeZone.getTimeZone("America/New_York"));
System.out.println(new SimpleDateFormat("[yyyy-MM-dd HH:mm:ss Z]").format(date));

[2024-01-02 22:00:00 +0800]
[2024-01-02 09:00:00 -0500]

反射、注解和泛型

public class ReflectionIssueApplication {
    public void age(int age) {
        System.out.println("int age = " + age);
    }

    public void age(Integer age) {
        System.out.println("Integer age = " + age);
    }
}

Class<ReflectionIssueApplication> clazz = ReflectionIssueApplication.class;
clazz.getDeclaredMethod("age", Integer.TYPE).invoke(clazz.newInstance(), Integer.valueOf("36"));

int age = 36

public class Parent<T> {
    //用于记录value更新的次数，模拟日志记录的逻辑
    AtomicInteger updateCount = new AtomicInteger();
    private T value;

    //重写toString，输出值和值更新次数
    @Override
    public String toString() {
        return String.format("value: %s updateCount: %d", value, updateCount.get());
    }

    //设置值
    public void setValue(T value) {
        System.out.println("Parent.setValue called");
        this.value = value;
        updateCount.incrementAndGet();
    }
}

public class Child1 extends Parent {
    public void setValue(String value) {
        System.out.println("Child1.setValue called");
        super.setValue(value);
    }
}

Child1 child1 = new Child1();
Arrays.stream(child1.getClass().getMethods())
        .filter(method -> method.getName().equals("setValue"))
        .forEach(method -> {
            try {
                method.invoke(child1, "test");
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
System.out.println(child1.toString());

Child1.setValue called
Parent.setValue called
Parent.setValue called
value: test updateCount: 2

• 子类没有指定 String 泛型参数，父类的泛型方法setValue(T value)在泛型擦除后是setValue(Object value)，子类中入参是 String 的setValue()方法被当作了新方法

• 子类的setValue()方法没有增加 @Override 注解，因此编译器没能检测到重写失败的问题。这就说明，重写子类方法时，标记 @Override 是一个好习惯

public class Child2 extends Parent<String> {
    @Override
    public void setValue(String value) {
        System.out.println("Child2.setValue called");
        super.setValue(value);
    }
    
    //public void setValue(Object value) {
    //    System.out.println("Child2.setValue called");
    //    super.setValue(value);
    //}
}

Child2.setValue called
Parent.setValue called
Child2.setValue called
Parent.setValue called
value: test updateCount: 2

Child2 child2 = new Child2();
Arrays.stream(child2.getClass().getMethods())
    .filter(method -> method.getName().equals("setValue") && !method.isBridge())
    .forEach(method -> {
        try {
            method.invoke(child2, "test");
        } catch (Exception e) {
            e.printStackTrace();
        }
    });
System.out.println(child2.toString());

注解可以继承吗？

参考

Java业务开发常见错误100例 · 语雀

Java多线程相关ThreadLocalThreadL...

https://www.yuque.com/fcant/java/ywzq9w