Java High‑Performance Coding Tips: 50 Efficient Code Examples

Introduction: There are only two kinds of matter in the world—high efficiency and low efficiency; likewise, there are only two kinds of people—those who write high‑efficiency code and those who write low‑efficiency code. How to write efficient code is a major issue for every development team.

The author, based on practical experience and extensive research, summarizes "50 Java Efficient Code Examples" to help every Java programmer write "high‑efficiency code".

1. Constants & Variables

1.1 Directly assign constant values, avoid creating new objects

Assigning a constant value creates only an object reference pointing to the constant.

Bad example:

Long i = new Long(1L);</code><code>String s = new String("abc");

Good example:

Long i = 1L;</code><code>String s = "abc";

1.2 When a member variable does not need to change, define it as a static constant

Each instance has its own copy of a member variable, while a static constant has only one copy.

Bad example:

public class HttpConnection {</code><code>    private final long timeout = 5L;</code><code>    ...</code><code>}

Good example:

public class HttpConnection {</code><code>    private static final long TIMEOUT = 5L;</code><code>    ...</code><code>}

1.3 Prefer primitive types, avoid autoboxing and unboxing

Autoboxing/unboxing consumes CPU and memory resources.

Bad example:

Integer sum = 0;</code><code>int[] values = ...;</code><code>for (int value : values) {</code><code>    sum += value; // equivalent to sum = Integer.valueOf(sum.intValue() + value);</code><code>}

Good example:

int sum = 0;</code><code>int[] values = ...;</code><code>for (int value : values) {</code><code>    sum += value;</code><code>}

1.4 If a variable's initial value will be overwritten, do not assign an initial value

Bad example:

List<UserDO> userList = new ArrayList<>();</code><code>if (isAll) {</code><code>    userList = userDAO.queryAll();</code><code>} else {</code><code>    userList = userDAO.queryActive();</code><code>}

Good example:

List<UserDO> userList;</code><code>if (isAll) {</code><code>    userList = userDAO.queryAll();</code><code>} else {</code><code>    userList = userDAO.queryActive();</code><code>}

1.5 Use temporary primitive variables inside functions

Primitive parameters and temporary variables are stored on the stack, which is faster than heap‑stored object references.

Bad example:

public final class Accumulator {</code><code>    private double result = 0.0D;</code><code>    public void addAll(@NonNull double[] values) {</code><code>        for(double value : values) {</code><code>            result += value;</code><code>        }</code><code>    }</code><code>    ...</code><code>}

Good example:

public final class Accumulator {</code><code>    private double result = 0.0D;</code><code>    public void addAll(@NonNull double[] values) {</code><code>        double sum = 0.0D;</code><code>        for(double value : values) {</code><code>            sum += value;</code><code>        }</code><code>        result += sum;</code><code>    }</code><code>    ...</code><code>}

1.6 Avoid defining variables outside the loop body

In newer JDKs, defining variables inside or outside the loop has negligible performance difference, but defining them inside improves readability.

Bad example:

UserVO userVO;</code><code>List<UserDO> userDOList = ...;</code><code>List<UserVO> userVOList = new ArrayList<>(userDOList.size());</code><code>for (UserDO userDO : userDOList) {</code><code>    userVO = new UserVO();</code><code>    userVO.setId(userDO.getId());</code><code>    ...</code><code>    userVOList.add(userVO);</code><code>}

Good example:

List<UserDO> userDOList = ...;</code><code>List<UserVO> userVOList = new ArrayList<>(userDOList.size());</code><code>for (UserDO userDO : userDOList) {</code><code>    UserVO userVO = new UserVO();</code><code>    userVO.setId(userDO.getId());</code><code>    ...</code><code>    userVOList.add(userVO);</code><code>}

1.7 For immutable static constants, prefer non‑thread‑safe classes

Even immutable static constants that need to be accessed by multiple threads can use non‑thread‑safe collections.

Bad example:

public static final Map<String, Class> CLASS_MAP;</code><code>static {</code><code>    Map<String, Class> classMap = new ConcurrentHashMap<>(16);</code><code>    classMap.put("VARCHAR", java.lang.String.class);</code><code>    ...</code><code>    CLASS_MAP = Collections.unmodifiableMap(classMap);</code><code>}

Good example:

public static final Map<String, Class> CLASS_MAP;</code><code>static {</code><code>    Map<String, Class> classMap = new HashMap<>(16);</code><code>    classMap.put("VARCHAR", java.lang.String.class);</code><code>    ...</code><code>    CLASS_MAP = Collections.unmodifiableMap(classMap);</code><code>}

1.8 For immutable member variables, also prefer non‑thread‑safe classes

Bad example:

@Service</code><code>public class StrategyFactory implements InitializingBean {</code><code>    @Autowired</code><code>    private List<Strategy> strategyList;</code><code>    private Map<String, Strategy> strategyMap;</code><code>    @Override</code><code>    public void afterPropertiesSet() {</code><code>        if (CollectionUtils.isNotEmpty(strategyList)) {</code><code>            int size = (int) Math.ceil(strategyList.size() * 4.0 / 3);</code><code>            Map<String, Strategy> map = new ConcurrentHashMap<>(size);</code><code>            for (Strategy strategy : strategyList) {</code><code>                map.put(strategy.getType(), strategy);</code><code>            }</code><code>            strategyMap = Collections.unmodifiableMap(map);</code><code>        }</code><code>    }</code><code>    ...</code><code>}

Good example:

@Service</code><code>public class StrategyFactory implements InitializingBean {</code><code>    @Autowired</code><code>    private List<Strategy> strategyList;</code><code>    private Map<String, Strategy> strategyMap;</code><code>    @Override</code><code>    public void afterPropertiesSet() {</code><code>        if (CollectionUtils.isNotEmpty(strategyList)) {</code><code>            int size = (int) Math.ceil(strategyList.size() * 4.0 / 3);</code><code>            Map<String, Strategy> map = new HashMap<>(size);</code><code>            for (Strategy strategy : strategyList) {</code><code>                map.put(strategy.getType(), strategy);</code><code>            }</code><code>            strategyMap = Collections.unmodifiableMap(map);</code><code>        }</code><code>    }</code><code>    ...</code><code>}

2. Objects & Classes

2.1 Avoid using JSON for object conversion

Using JSON for object conversion works functionally but hurts performance.

Bad example:

List<UserDO> userDOList = ...;</code><code>List<UserVO> userVOList = JSON.parseArray(JSON.toJSONString(userDOList), UserVO.class);

Good example:

List<UserDO> userDOList = ...;</code><code>List<UserVO> userVOList = new ArrayList<>(userDOList.size());</code><code>for (UserDO userDO : userDOList) {</code><code>    UserVO userVO = new UserVO();</code><code>    userVO.setId(userDO.getId());</code><code>    ...</code><code>    userVOList.add(userVO);</code><code>}

2.2 Avoid using reflection for object assignment

Reflection saves code but degrades performance.

Bad example:

List<UserDO> userDOList = ...;</code><code>List<UserVO> userVOList = new ArrayList<>(userDOList.size());</code><code>for (UserDO userDO : userDOList) {</code><code>    UserVO userVO = new UserVO();</code><code>    BeanUtils.copyProperties(userDO, userVO);</code><code>    userVOList.add(userVO);</code><code>}

Good example:

List<UserDO> userDOList = ...;</code><code>List<UserVO> userVOList = new ArrayList<>(userDOList.size());</code><code>for (UserDO userDO : userDOList) {</code><code>    UserVO userVO = new UserVO();</code><code>    userVO.setId(userDO.getId());</code><code>    ...</code><code>    userVOList.add(userVO);</code><code>}

2.3 Replace inner anonymous classes with lambda expressions

Lambda expressions are implemented with invokeDynamic and are generally more efficient than anonymous inner classes.

Bad example:

List<User> userList = ...;</code><code>Collections.sort(userList, new Comparator<User>() {</code><code>    @Override</code><code>    public int compare(User user1, User user2) {</code><code>        Long userId1 = user1.getId();</code><code>        Long userId2 = user2.getId();</code><code>        ...</code><code>        return userId1.compareTo(userId2);</code><code>    }</code><code>});

Good example:

List<User> userList = ...;</code><code>Collections.sort(userList, (user1, user2) -> {</code><code>    Long userId1 = user1.getId();</code><code>    Long userId2 = user2.getId();</code><code>    ...</code><code>    return userId1.compareTo(userId2);</code><code>});

2.4 Avoid defining unnecessary subclasses

Each class adds a class‑loading overhead.

Bad example:

public static final Map<String, Class> CLASS_MAP =</code><code>    Collections.unmodifiableMap(new HashMap<String, Class>(16) {</code><code>    private static final long serialVersionUID = 1L;</code><code>    {</code><code>        put("VARCHAR", java.lang.String.class);</code><code>    }</code><code>});

Good example:

public static final Map<String, Class> CLASS_MAP;</code><code>static {</code><code>    Map<String, Class> classMap = new HashMap<>(16);</code><code>    classMap.put("VARCHAR", java.lang.String.class);</code><code>    ...</code><code>    CLASS_MAP = Collections.unmodifiableMap(classMap);</code><code>}

2.5 Prefer adding final modifier to classes

Final classes cannot be subclassed; the compiler can inline final methods, improving performance by up to 50%.

Bad example:

public class DateHelper {</code><code>    ...</code><code>}

Good example:

public final class DateHelper {</code><code>    ...</code><code>}

Note: When using Spring AOP, final classes cannot be proxied.

3. Methods

3.1 Declare methods unrelated to class fields as static

Static methods can be called without creating an instance, saving object creation overhead.

Bad example:

public int getMonth(Date date) {</code><code>  Calendar calendar = Calendar.getInstance();</code><code>  calendar.setTime(date);</code><code>  return calendar.get(Calendar.MONTH) + 1;</code><code>}

Good example:

public static int getMonth(Date date) {</code><code>  Calendar calendar = Calendar.getInstance();</code><code>  calendar.setTime(date);</code><code>  return calendar.get(Calendar.MONTH) + 1;</code><code>}

3.2 Use primitive types for method parameters to avoid boxing/unboxing

Bad example:

public static double sum(Double value1, Double value2) {</code><code>    double double1 = Objects.isNull(value1) ? 0.0D : value1;</code><code>    double double2 = Objects.isNull(value2) ? 0.0D : value2;</code><code>    return double1 + double2;</code><code>}</code><code>double result = sum(1.0D, 2.0D);

Good example:

public static double sum(double value1, double value2) {</code><code>    return value1 + value2;</code><code>}</code><code>double result = sum(1.0D, 2.0D);

3.3 Use primitive return types to avoid boxing/unboxing

Bad example:

public static Boolean isValid(UserDO user) {</code><code>    if (Objects.isNull(user)) {</code><code>        return false;</code><code>    }</code><code>    return Boolean.TRUE.equals(user.getIsValid());</code><code>}</code><code>// call</code><code>UserDO user = ...;</code><code>Boolean isValid = isValid(user);</code><code>if (Objects.nonNull(isValid) && isValid.booleanValue()) {</code><code>    ...</code><code>}

Good example:

public static boolean isValid(UserDO user) {</code><code>    if (Objects.isNull(user)) {</code><code>        return false;</code><code>    }</code><code>    return Boolean.TRUE.equals(user.getIsValid());</code><code>}</code><code>// call</code><code>UserDO user = ...;</code><code>if (isValid(user)) {</code><code>    ...</code><code>}

3.4 Use @NonNull/@Nullable annotations for protocol methods to avoid null checks

Bad example:

public static boolean isValid(UserDO user) {</code><code>    if (Objects.isNull(user)) {</code><code>        return false;</code><code>    }</code><code>    return Boolean.TRUE.equals(user.getIsValid());</code><code>}

Good example:

public static boolean isValid(@NonNull UserDO user) {</code><code>    return Boolean.TRUE.equals(user.getIsValid());</code><code>}

3.5 Use @NonNull on return values of protocol methods

Bad example:

// interface</code><code>public interface OrderService {</code><code>    public List<OrderVO> queryUserOrder(Long userId);</code><code>}</code><code>// call</code><code>List<OrderVO> orderList = orderService.queryUserOrder(userId);</code><code>if (CollectionUtils.isNotEmpty(orderList)) {</code><code>    for (OrderVO order : orderList) {</code><code>        ...</code><code>    }</code><code>}

Good example:

// interface</code><code>public interface OrderService {</code><code>    @NonNull</code><code>    public List<OrderVO> queryUserOrder(Long userId);</code><code>}</code><code>// call</code><code>List<OrderVO> orderList = orderService.queryUserOrder(userId);</code><code>for (OrderVO order : orderList) {</code><code>    ...</code><code>}

3.6 If a called method already handles null checks, callers need not repeat them

Bad example:

UserDO user = null;</code><code>if (StringUtils.isNotBlank(value)) {</code><code>    user = JSON.parseObject(value, UserDO.class);</code><code>}

Good example:

UserDO user = JSON.parseObject(value, UserDO.class);

3.7 Avoid unnecessary function wrappers

Bad example:

// wrapper</code><code>public static boolean isVip(Boolean isVip) {</code><code>    return Boolean.TRUE.equals(isVip);</code><code>}</code><code>// usage</code><code>boolean isVip = isVip(user.getVip());

Good example:

boolean isVip = Boolean.TRUE.equals(user.getVip());

3.8 Prefer final modifier on methods

Final methods can be inlined by the JVM, improving performance.

Bad example:

public class Rectangle {</code><code>    ...</code><code>    public double area() {</code><code>        ...</code><code>    }</code><code>}

Good example:

public class Rectangle {</code><code>    ...</code><code>    public final double area() {</code><code>        ...</code><code>    }</code><code>}

Note: Spring AOP cannot proxy final methods.

4. Expressions

4.1 Reduce repeated method calls

Bad example:

List<UserDO> userList = ...;</code><code>for (int i = 0; i < userList.size(); i++) {</code><code>    ...</code><code>}

Good example:

List<UserDO> userList = ...;</code><code>int userLength = userList.size();</code><code>for (int i = 0; i < userLength; i++) {</code><code>    ...</code><code>}

4.2 Avoid unnecessary method calls

Bad example:

List<UserDO> userList = userDAO.queryActive();</code><code>if (isAll) {</code><code>    userList = userDAO.queryAll();</code><code>}

Good example:

List<UserDO> userList;</code><code>if (isAll) {</code><code>    userList = userDAO.queryAll();</code><code>} else {</code><code>    userList = userDAO.queryActive();</code><code>}

4.3 Use bit‑shift instead of multiplication/division by powers of two

Bad example: int num1 = a * 4;</code><code>int num2 = a / 4; Good example:

int num1 = a << 2;</code><code>int num2 = a >> 2;

4.4 Extract common sub‑expressions to avoid repeated calculations

Bad example:

double distance = Math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));

Good example:

double dx = x2 - x1;</code><code>double dy = y2 - y1;</code><code>double distance = Math.sqrt(dx * dx + dy * dy);

4.5 Avoid using ! for negation in conditionals

Bad example:

if (!(a >= 10)) {</code><code>    ... // case 1</code><code>} else {</code><code>    ... // case 2</code><code>}

Good example:

if (a < 10) {</code><code>    ... // case 1</code><code>} else {</code><code>    ... // case 2</code><code>}

4.6 Use switch for multiple constant branches

Bad example:

if (i == 1) {</code><code>    ...; // branch 1</code><code>} else if (i == 2) {</code><code>    ...; // branch 2</code><code>} else if (i == ...) {</code><code>    ...; // branch n</code><code>} else {</code><code>    ...; // branch n+1</code><code>}

Good example:

switch (i) {</code><code>    case 1 :</code><code>        ... // branch 1</code><code>        break;</code><code>    case 2 :</code><code>        ... // branch 2</code><code>        break;</code><code>    case ... :</code><code>        ... // branch n</code><code>        break;</code><code>    default :</code><code>        ... // branch n+1</code><code>        break;</code><code>}

Note: For complex logic, consider a Map‑based strategy pattern.

5. Strings

5.1 Avoid using regular expressions for matching

Bad example:

String source = "a::1,b::2,c::3,d::4";</code><code>String target = source.replaceAll("::", "=");</code><code>Stringp[] targets = source.spit("::");

Good example:

String source = "a::1,b::2,c::3,d::4";</code><code>String target = source.replace("::", "=");</code><code>Stringp[] targets = StringUtils.split(source, "::");

5.2 Prefer character replacement over string replacement

Bad example:

String source = "a:1,b:2,c:3,d:4";</code><code>int index = source.indexOf(":");</code><code>String target = source.replace(":", "=");

Good example:

String source = "a:1,b:2,c:3,d:4";</code><code>int index = source.indexOf(':');</code><code>String target = source.replace(':', '=');

5.3 Use StringBuilder for string concatenation

Bad example:

String s = "";</code><code>for (int i = 0; i < 10; i++) {</code><code>    if (i != 0) {</code><code>        s += ',';</code><code>    }</code><code>    s += i;</code><code>}

Good example:

StringBuilder sb = new StringBuilder(128);</code><code>for (int i = 0; i < 10; i++) {</code><code>    if (i != 0) {</code><code>        sb.append(',');</code><code>    }</code><code>    sb.append(i);</code><code>}

5.4 Avoid using ""+ for string conversion

Bad example: int i = 12345;</code><code>String s = "" + i; Good example:

int i = 12345;</code><code>String s = String.valueOf(i);

6. Arrays

6.1 Use System.arraycopy instead of manual loop copying

Bad example:

int[] sources = new int[] {1, 2, 3, 4, 5};</code><code>int[] targets = new int[sources.length];</code><code>for (int i = 0; i < targets.length; i++) {</code><code>    targets[i] = sources[i];</code><code>}

Good example:

int[] sources = new int[] {1, 2, 3, 4, 5};</code><code>int[] targets = new int[sources.length];</code><code>System.arraycopy(sources, 0, targets, 0, targets.length);

6.2 When converting a collection to a typed array, pass an empty array T[0]

Bad example:

List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5, ...);</code><code>Integer[] integers = integerList.toArray(new Integer[integerList.size()]);

Good example:

List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5, ...);</code><code>Integer[] integers = integerList.toArray(new Integer[0]); // do not use new Integer[]{}

Suggestion: Provide a toArray(Class clazz) method to avoid empty‑array allocation.

6.3 When converting a collection to an Object[] array, use toArray()

Bad example:

List<Object> objectList = Arrays.asList(1, "2", 3, "4", 5, ...);</code><code>Object[] objects = objectList.toArray(new Object[0]);

Good example:

List<Object> objectList = Arrays.asList(1, "2", 3, "4", 5, ...);</code><code>Object[] objects = objectList.toArray();

7. Collections

7.1 Specify collection size when initializing

Bad example:

List<UserDO> userDOList = ...;</code><code>Set<Long> userSet = new HashSet<>();</code><code>Map<Long, UserDO> userMap = new HashMap<>();</code><code>List<UserVO> userList = new ArrayList<>();</code><code>for (UserDO userDO : userDOList) {</code><code>    userSet.add(userDO.getId());</code><code>    userMap.put(userDO.getId(), userDO);</code><code>    userList.add(transUser(userDO));</code><code>}

Good example:

List<UserDO> userDOList = ...;</code><code>int userSize = userDOList.size();</code><code>Set<Long> userSet = new HashSet<>(userSize);</code><code>Map<Long, UserDO> userMap = new HashMap<>((int) Math.ceil(userSize * 4.0 / 3));</code><code>List<UserVO> userList = new ArrayList<>(userSize);</code><code>for (UserDO userDO : userDOList) {</code><code>    userSet.add(userDO.getId());</code><code>    userMap.put(userDO.getId(), userDO);</code><code>    userList.add(transUser(userDO));</code><code>}

7.2 Use JDK methods to copy collections instead of loops

Bad example:

List<UserDO> user1List = ...;</code><code>List<UserDO> user2List = ...;</code><code>List<UserDO> userList = new ArrayList<>(user1List.size() + user2List.size());</code><code>for (UserDO user1 : user1List) {</code><code>    userList.add(user1);</code><code>}</code><code>for (UserDO user2 : user2List) {</code><code>    userList.add(user2);</code><code>}

Good example:

List<UserDO> user1List = ...;</code><code>List<UserDO> user2List = ...;</code><code>List<UserDO> userList = new ArrayList<>(user1List.size() + user2List.size());</code><code>userList.addAll(user1List);</code><code>userList.addAll(user2List);

7.3 Use Arrays.asList to convert arrays to lists

Bad example:

List<String> typeList = new ArrayList<>(8);</code><code>typeList.add("Short");</code><code>typeList.add("Integer");</code><code>typeList.add("Long");</code><code>String[] names = ...;</code><code>List<String> nameList = ...;</code><code>for (String name : names) {</code><code>    nameList.add(name);</code><code>}

Good example:

List<String> typeList = Arrays.asList("Short", "Integer", "Long");</code><code>String[] names = ...;</code><code>List<String> nameList = ...;</code><code>nameList.addAll(Arrays.asList(names));

7.4 Iterate directly over the collection you need

Bad example:

Map<Long, UserDO> userMap = ...;</code><code>for (Long userId : userMap.keySet()) {</code><code>    UserDO user = userMap.get(userId);</code><code>    ...</code><code>}

Good example:

Map<Long, UserDO> userMap = ...;</code><code>for (Map.Entry<Long, UserDO> userEntry : userMap.entrySet()) {</code><code>    Long userId = userEntry.getKey();</code><code>    UserDO user = userEntry.getValue();</code><code>    ...</code><code>}

7.5 Use isEmpty() instead of size()==0

Bad example:

List<UserDO> userList = ...;</code><code>if (userList.size() == 0) {</code><code>    ...</code><code>}</code><code>Map<Long, UserDO> userMap = ...;</code><code>if (userMap.size() == 0) {</code><code>    ...</code><code>}

Good example:

List<UserDO> userList = ...;</code><code>if (userList.isEmpty()) {</code><code>    ...</code><code>}</code><code>Map<Long, UserDO> userMap = ...;</code><code>if (userMap.isEmpty()) {</code><code>    ...</code><code>}

7.6 For non‑random‑access lists, prefer iteration over index access

Bad example:

LinkedList<UserDO> userDOList = ...;</code><code>int size = userDOList.size();</code><code>for (int i = 0; i < size; i++) {</code><code>    UserDO userDO = userDOList.get(i);</code><code>    ...</code><code>}

Good example:

LinkedList<UserDO> userDOList = ...;</code><code>for (UserDO userDO : userDOList) {</code><code>    ...</code><code>}

In fact, iteration should be used regardless of RandomAccess support.

7.7 Use HashSet for existence checks

Bad example:

List<Long> adminIdList = ...;</code><code>List<UserDO> userDOList = ...;</code><code>List<UserVO> userVOList = new ArrayList<>(userDOList.size());</code><code>for (UserDO userDO : userDOList) {</code><code>    if (adminIdList.contains(userDO.getId())) {</code><code>        userVOList.add(transUser(userDO));</code><code>    }</code><code>}

Good example:

Set<Long> adminIdSet = ...;</code><code>List<UserDO> userDOList = ...;</code><code>List<UserVO> userVOList = new ArrayList<>(userDOList.size());</code><code>for (UserDO userDO : userDOList) {</code><code>    if (adminIdSet.contains(userDO.getId())) {</code><code>        userVOList.add(transUser(userDO));</code><code>    }</code><code>}

7.8 Avoid checking existence before getting from a map

Bad example:

public static UserVO transUser(UserDO user, Map<Long, RoleDO> roleMap) {</code><code>    UserVO userVO = new UserVO();</code><code>    userVO.setId(user.getId());</code><code>    ...</code><code>    if (roleMap.contains(user.getRoleId())) {</code><code>        RoleDO role = roleMap.get(user.getRoleId());</code><code>        userVO.setRole(transRole(role));</code><code>    }</code><code>}

Good example:

public static UserVO transUser(UserDO user, Map<Long, RoleDO> roleMap) {</code><code>    UserVO userVO = new UserVO();</code><code>    userVO.setId(user.getId());</code><code>    ...</code><code>    RoleDO role = roleMap.get(user.getRoleId());</code><code>    if (Objects.nonNull(role)) {</code><code>        userVO.setRole(transRole(role));</code><code>    }</code><code>}

8. Exceptions

8.1 Catch specific exceptions directly

Bad example:

try {</code><code>    saveData();</code><code>} catch (Exception e) {</code><code>    if (e instanceof IOException) {</code><code>        log.error("Save data IO exception", e);</code><code>    } else {</code><code>        log.error("Save data other exception", e);</code><code>    }</code><code>}

Good example:

try {</code><code>    saveData();</code><code>} catch (IOException e) {</code><code>    log.error("Save data IO exception", e);</code><code>} catch (Exception e) {</code><code>    log.error("Save data other exception", e);</code><code>}

8.2 Avoid catching exceptions inside loops

Bad example:

public Double sum(List<String> valueList) {</code><code>    double sum = 0.0D;</code><code>    for (String value : valueList) {</code><code>        try {</code><code>            sum += Double.parseDouble(value);</code><code>        } catch (NumberFormatException e) {</code><code>            return null;</code><code>        }</code><code>    }</code><code>    return sum;</code><code>}

Good example:

public Double sum(List<String> valueList) {</code><code>    double sum = 0.0D;</code><code>    try {</code><code>        for (String value : valueList) {</code><code>            sum += Double.parseDouble(value);</code><code>        }</code><code>    } catch (NumberFormatException e) {</code><code>        return null;</code><code>    }</code><code>    return sum;</code><code>}

8.3 Do not use exceptions for business flow control

Bad example:

public static boolean isValid(UserDO user) {</code><code>    try {</code><code>        return Boolean.TRUE.equals(user.getIsValid());</code><code>    } catch(NullPointerException e) {</code><code>        return false;</code><code>    }</code><code>}

Good example:

public static boolean isValid(UserDO user) {</code><code>    if (Objects.isNull(user)) {</code><code>        return false;</code><code>    }</code><code>    return Boolean.TRUE.equals(user.getIsValid());</code><code>}

9. Buffers

9.1 Specify buffer size during initialization

Bad example:

StringBuffer buffer = new StringBuffer();</code><code>StringBuilder builder = new StringBuilder();

Good example:

StringBuffer buffer = new StringBuffer(1024);</code><code>StringBuilder builder = new StringBuilder(1024);

9.2 Reuse the same buffer instead of creating new ones

Bad example:

StringBuilder builder1 = new StringBuilder(128);</code><code>builder1.append("update t_user set name = '").append(userName).append("' where id = ").append(userId);</code><code>statement.executeUpdate(builder1.toString());</code><code>StringBuilder builder2 = new StringBuilder(128);</code><code>builder2.append("select id, name from t_user where id = ").append(userId);</code><code>ResultSet resultSet = statement.executeQuery(builder2.toString());

Good example:

StringBuilder builder = new StringBuilder(128);</code><code>builder.append("update t_user set name = '").append(userName).append("' where id = ").append(userId);</code><code>statement.executeUpdate(builder.toString());</code><code>builder.setLength(0);</code><code>builder.append("select id, name from t_user where id = ").append(userId);</code><code>ResultSet resultSet = statement.executeQuery(builder.toString());

Note: setLength(0) resets the buffer.

9.3 Design to use a single buffer for related conversions

Bad example:

// Convert XML(UserDO)</code><code>public static String toXml(UserDO user) {</code><code>    StringBuilder builder = new StringBuilder(128);</code><code>    builder.append("<UserDO>");</code><code>    builder.append(toXml(user.getId()));</code><code>    builder.append(toXml(user.getName()));</code><code>    builder.append(toXml(user.getRole()));</code><code>    builder.append("</UserDO>");</code><code>    return builder.toString();</code><code>}</code><code>// Convert XML(Long)</code><code>public static String toXml(Long value) {</code><code>    StringBuilder builder = new StringBuilder(128);</code><code>    builder.append("<Long>");</code><code>    builder.append(value);</code><code>    builder.append("</Long>");</code><code>    return builder.toString();</code><code>}</code><code>// usage</code><code>UserDO user = ...;</code><code>String xml = toXml(user);

Good example:

// Convert XML(UserDO)</code><code>public static void toXml(StringBuilder builder, UserDO user) {</code><code>    builder.append("<UserDO>");</code><code>    toXml(builder, user.getId());</code><code>    toXml(builder, user.getName());</code><code>    toXml(builder, user.getRole());</code><code>    builder.append("</UserDO>");</code><code>}</code><code>// Convert XML(Long)</code><code>public static void toXml(StringBuilder builder, Long value) {</code><code>    builder.append("<Long>");</code><code>    builder.append(value);</code><code>    builder.append("</Long>");</code><code>}</code><code>// usage</code><code>UserDO user = ...;</code><code>StringBuilder builder = new StringBuilder(1024);</code><code>toXml(builder, user);</code><code>String xml = builder.toString();

This eliminates per‑method buffer allocation, saving time and memory.

9.4 Use buffered streams to reduce I/O operations

Bad example:

try (FileInputStream input = new FileInputStream("a");</code><code>    FileOutputStream output = new FileOutputStream("b")) {</code><code>    int size = 0;</code><code>    byte[] temp = new byte[1024];</code><code>    while ((size = input.read(temp)) != -1) {</code><code>        output.write(temp, 0, size);</code><code>    }</code><code>} catch (IOException e) {</code><code>    log.error("Copy file exception", e);</code><code>}

Good example:

try (BufferedInputStream input = new BufferedInputStream(new FileInputStream("a"));</code><code>    BufferedOutputStream output = new BufferedOutputStream(new FileOutputStream("b"))) {</code><code>    int size = 0;</code><code>    byte[] temp = new byte[1024];</code><code>    while ((size = input.read(temp)) != -1) {</code><code>        output.write(temp, 0, size);</code><code>    }</code><code>} catch (IOException e) {</code><code>    log.error("Copy file exception", e);</code><code>}

Optionally specify buffer sizes to maximize buffering effect.

10. Threads

10.1 In single‑threaded contexts, prefer non‑thread‑safe classes

Bad example:

StringBuffer buffer = new StringBuffer(128);</code><code>buffer.append("select * from ").append(T_USER).append(" where id = ?");

Good example:

StringBuilder buffer = new StringBuilder(128);</code><code>buffer.append("select * from ").append(T_USER).append(" where id = ?");

10.2 In multi‑threaded contexts, use thread‑safe classes

Bad example:

private volatile int counter = 0;</code><code>public void access(Long userId) {</code><code>    synchronized (this) {</code><code>        counter++;</code><code>    }</code><code>    ...</code><code>}

Good example:

private final AtomicInteger counter = new AtomicInteger(0);</code><code>public void access(Long userId) {</code><code>    counter.incrementAndGet();</code><code>    ...</code><code>}

10.3 Minimize the scope of synchronized blocks

Bad example:

private volatile int counter = 0;</code><code>public synchronized void access(Long userId) {</code><code>    counter++;</code><code>    ... // non‑synchronized operations</code><code>}

Good example:

private volatile int counter = 0;</code><code>public void access(Long userId) {</code><code>    synchronized (this) {</code><code>        counter++;</code><code>    }</code><code>    ... // non‑synchronized operations</code><code>}

10.4 Merge synchronized blocks when possible

Bad example:

// Handle single order</code><code>public synchronized handleOrder(OrderDO order) {</code><code>    ...</code><code>}</code><code>// Handle all orders</code><code>public void handleOrder(List<OrderDO> orderList) {</code><code>    for (OrderDO order : orderList) {</code><code>        handleOrder(order);</code><code>    }</code><code>}

Good example:

// Handle single order</code><code>public handleOrder(OrderDO order) {</code><code>    ...</code><code>}</code><code>// Handle all orders</code><code>public synchronized void handleOrder(List<OrderDO> orderList) {</code><code>    for (OrderDO order : orderList) {</code><code>        handleOrder(order);</code><code>    }</code><code>}

10.5 Use thread pools to reduce thread creation overhead

Bad example:

public void executeTask(Runnable runnable) {</code><code>    new Thread(runnable).start();</code><code>}

Good example:

private static final ExecutorService EXECUTOR_SERVICE = Executors.newFixedThreadPool(10);</code><code>public void executeTask(Runnable runnable) {</code><code>    EXECUTOR_SERVICE.execute(runnable);</code><code>}

Afterword

As a long‑time "IT laborer" on the front line, I have no chance to study deep theoretical concepts, but I focus on tangible technology, striving to "work hard, love the work, specialize, and perfect".

This article is a sister piece to the WeChat article "Java Programming Techniques – Data Structures". I hope readers will supplement and improve it.