Here are some advanced examples illustrating Java code optimization techniques. Remember that optimization should always be done based on profiling and identifying actual bottlenecks.
1. String Concatenation Optimization with StringBuilder
Repeatedly concatenating strings using the + operator creates many intermediate String objects, which can be inefficient. StringBuilder (or StringBuffer for thread-safe scenarios) should be used for building strings in loops or when performing multiple concatenations.
// Inefficient
String result = "";
for (int i = 0; i < 10000; i++) {
result += "Item " + i + ", ";
}
// Efficient
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10000; i++) {
sb.append("Item ").append(i).append(", ");
}
String resultSB = sb.toString();
Reducing object creation during string manipulation.
2. Collection Initialization and Resizing
When creating collections like ArrayList or HashMap, providing an initial capacity can avoid frequent resizing, which can be an expensive operation, especially for large collections.
// Potentially inefficient (default initial capacity, frequent resizing)
List<Integer> numbersList = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
numbersList.add(i);
}
// More efficient (setting initial capacity)
List<Integer> numbersListOptimized = new ArrayList<>(1000);
for (int i = 0; i < 1000; i++) {
numbersListOptimized.add(i);
}
// Similarly for HashMap
Map<String, Integer> map = new HashMap<>(); // Default capacity
Map<String, Integer> mapOptimized = new HashMap<>(1000); // Initial capacity
Reducing overhead from dynamic collection resizing.
3. Using Primitive Types Instead of Wrapper Objects
Autoboxing and unboxing between primitive types (int, long, double, etc.) and their wrapper objects (Integer, Long, Double, etc.) can introduce performance overhead. Use primitive types whenever possible, especially in performance-critical sections.
// Less efficient (autoboxing/unboxing in loop)
List<Integer> integerList = new ArrayList<>();
long sumWrapper = 0L;
for (int i = 0; i < 10000; i++) {
integerList.add(i);
sumWrapper += integerList.get(i); // Unboxing Integer to int, then autoboxing to Long for sum
}
// More efficient (using primitive long)
List<Integer> integerListOptimized = new ArrayList<>();
long sumPrimitive = 0L;
for (int i = 0; i < 10000; i++) {
integerListOptimized.add(i);
sumPrimitive += i; // Direct primitive addition
}
Avoiding overhead from autoboxing and unboxing.
4. Loop Optimization: Reducing Computations Inside Loops
Avoid performing the same calculations repeatedly inside a loop. Move such computations outside the loop if the result doesn’t change within the loop.
// Inefficient (Math.sqrt calculated in every iteration)
for (int i = 0; i < 1000; i++) {
double result = Math.sqrt(100) + i;
// ...
}
// Efficient (Math.sqrt calculated once)
double sqrtOf100 = Math.sqrt(100);
for (int i = 0; i < 1000; i++) {
double result = sqrtOf100 + i;
// ...
}
Minimizing redundant calculations within loops.
5. Utilizing Lazy Initialization
Delay the creation of objects or expensive resources until they are actually needed. This can improve startup time and reduce memory consumption if those resources are not always used.
public class ExpensiveResourceUser {
private ExpensiveResource resource;
public ExpensiveResource getResource() {
if (resource == null) {
resource = new ExpensiveResource(); // Lazy initialization
System.out.println("ExpensiveResource created.");
}
return resource;
}
public void doSomething() {
// ... potentially doesn't need the resource
}
public void useResource() {
ExpensiveResource res = getResource();
res.performTask();
}
}
class ExpensiveResource {
public ExpensiveResource() {
System.out.println("ExpensiveResource constructor called.");
// Simulate expensive initialization
try { Thread.sleep(100); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
}
public void performTask() {
System.out.println("Expensive task performed.");
}
}
Deferring object creation until necessary.
6. Object Pooling for Reusable Objects
For frequently created and destroyed expensive objects (e.g., database connections, threads), object pooling can significantly reduce the overhead of object creation and garbage collection.
import java.util.LinkedList;
import java.util.Queue;
class ReusableObject {
private boolean inUse = false;
public boolean isInUse() { return inUse; }
public void setInUse(boolean inUse) { this.inUse = inUse; }
public void performAction() { System.out.println("Object performing action."); }
}
class ObjectPool {
private final Queue<ReusableObject> pool;
private final int maxSize;
public ObjectPool(int maxSize) {
this.maxSize = maxSize;
this.pool = new LinkedList<>();
for (int i = 0; i < maxSize; i++) {
pool.offer(new ReusableObject());
}
}
public ReusableObject acquire() {
ReusableObject obj = pool.poll();
if (obj == null) {
obj = new ReusableObject(); // Create new if pool is empty (consider limiting)
}
obj.setInUse(true);
return obj;
}
public void release(ReusableObject obj) {
obj.setInUse(false);
pool.offer(obj);
}
}
public class ObjectPoolExample {
public static void main(String[] args) {
ObjectPool pool = new ObjectPool(5);
ReusableObject obj1 = pool.acquire();
obj1.performAction();
pool.release(obj1);
}
}
Reducing object creation and GC overhead for reusable resources.
7. Careful Use of Regular Expressions
Regular expressions can be powerful but also computationally expensive. Compile regular expressions that are used multiple times and avoid overly complex or backtracking-heavy patterns if performance is critical.
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexOptimization {
private static final Pattern EMAIL_PATTERN = Pattern.compile("^[a-zA-Z0-9_+&*-]+(?:\\.[a-zA-Z0-9_+&*-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,7}$");
public boolean isValidEmail(String email) {
Matcher matcher = EMAIL_PATTERN.matcher(email);
return matcher.matches();
}
public static void main(String[] args) {
RegexOptimization optimizer = new RegexOptimization();
System.out.println(optimizer.isValidEmail("test@example.com"));
System.out.println(optimizer.isValidEmail("invalid-email"));
}
}
Pre-compiling frequently used regular expressions.
These examples illustrate some advanced Java optimization techniques. The key is to always profile your application to identify the real bottlenecks and then apply targeted optimizations. Avoid premature optimization, as it can lead to complex code with minimal performance gains.
Leave a Reply