5.8 KiB
title, source, author, published, created, description, tags
| title | source | author | published | created | description | tags | ||
|---|---|---|---|---|---|---|---|---|
| 10 Performance Tips I Discovered After Years of Coding in JAVA | https://medium.com/@code-geass/10-performance-tips-i-discovered-after-years-of-coding-in-java-3f57a0125ae3 |
|
2024-10-13 | 2024-10-29 | Hey Everyone!! I wanted to share these Java Performance tips, that i feel everyone should be aware of since it took a lot of effort and mistakes for me to learn it. So, here are eight performance… |
|
[
Hey Everyone!! I wanted to share these Java Performance tips, that i feel everyone should be aware of since it took a lot of effort and mistakes for me to learn it. So, here are eight performance tips that have made a real difference in my projects. Dont forget to bookmark them for further reference.
1. Use StringBuilder for Joining Strings
If you’re adding strings together, especially inside a loop, it’s better to use a StringBuilder. When you use the + operator, Java creates a new string each time, which can slow things down.
Instead of:
String result = "";for (String s : words) { result += s;}
Try:
StringBuilder result = new StringBuilder();for (String s : words) { result.append(s);}String finalResult = result.toString();
2. Reuse Objects Whenever Possible
Whenever you create new objects, it consumes lot of memory and time. We should try to reuse objects whenever possible. Its important to note that we should also consider using them wisely, like we need to go for it only if the object’s state changes frequently or its lifecycle require being used multiple times.
Example:
MyClass obj = new MyClass();for (int i = 0; i < 1000; i++) { obj.doSomething();}
3. Use Primitive Types Instead of Wrapper Classes
We need to be aware that Integer, Double and Boolean are slower than the primitive data types like int, double and boolean. So we need to avoid the reduntant usage of
So, prefer:
int number = 5;
Over:
Integer number = new Integer(5);
4. Choose the Right Data Structures
Whenever you need something really quick, go for HashMap or HashSet instead of List.
Example:
Set<String> names = new HashSet<>();names.add("Alice");names.add("Bob");if (names.contains("Alice")) { }
5. Avoid Unnecessary Casting
Casting can slow things down. If you know what type of objects you’re working with, try to avoid casting them.
Instead of:
Object obj = "Hello";String str = (String) obj;
Just use:
String str = "Hello";
6. Cache Frequently Used Values
Cache can be a double edged sword. So we need to use it wisely. We should not to much cache or should not completely avoid it. But whenever a heavy calculation or a frequent data access is required that usually doesn’t change much, we should go for it.
Example:
Map<Integer, Integer> cache = new HashMap<>();int getFactorial(int n) { if (cache.containsKey(n)) { return cache.get(n); } else { int result = calculateFactorial(n); cache.put(n, result); return result; }}
7. Limit the Use of Synchronization
In multi-threaded programs, synchronization can cause delays. Use it only when necessary, and keep synchronized blocks short.
Example:
synchronized (this) { sharedResource.update();}
8. Be Careful with Exceptions Inside Loops
Throwing and catching exceptions is slower than regular code execution. Try to avoid them inside loops.
Instead of:
for (int i = 0; i < data.length; i++) { try { process(data[i]); } catch (Exception e) { }}
Validate before processing:
for (int i = 0; i < data.length; i++) { if (isValid(data[i])) { process(data[i]); }}
But in case if the the problem lies with the data itself, you should filter or validate the data before processing.
Stream.of(data) .filter(this::isValid) .forEach(this::process);
So checkout what is the best approach in your case
9. Use Efficient Loops
Sometimes, the way you write your loops can make a difference. For example, when looping through lists, use an indexed loop if you can.
Example:
for (int i = 0; i < list.size(); i++) { doSomething(list.get(i));}
10. Profile Your Code to Find Slow Spots
Finally, use tools to see where your program is spending the most time. Profiling helps you focus on the parts that really need optimization.
Tip:
- Use tools like VisualVM.
- Identify methods that take the most time and optimize them.
11. Use the Most Readable Loop for the Job
As pointed out by Karl in the comment section, I noticed the importance of readability when writing loops.Using Java Streams can make your code cleaner and easier to understand.
Example with for-each:
for (String item : list) { doSomething(item);}
Example with Streams:
list.stream().forEach(item -> doSomething(item));
Wrapping Up
These are some tips that I gained over the years after making lots of mistakes. I acknowledge that every project is a bit different, and you really your solution addressing your problem and be mindful of these things whenever you are facing some kind of bottleneck.
Oh, and before I forget: always make sure to test and profile your code after making changes. Sometimes, what we think is an optimization might not have the desired effect.
If you’ve got any cool Java tricks up your sleeve,Please mention in the comments
Happy coding!