Prefer Immutable Objects
Best practice — Prefer Immutable Objects.
Use Optional Correctly
Best practice — Use Optional Correctly.
Avoid Null Returns
Best practice — Avoid Null Returns.
Validate Method Arguments
Best practice — Validate Method Arguments.
Use Meaningful Names
Best practice — Use Meaningful Names.
Keep Methods Short
Best practice — Keep Methods Short.
Single Responsibility Principle
Best practice — Single Responsibility Principle.
Fail Fast Validation
Best practice — Fail Fast Validation.
Use Standard Exceptions
Best practice — Use Standard Exceptions.
Close Resources with Try-With-Resources
Best practice — Close Resources with Try-With-Resources.
Prefer Composition Over Inheritance
Best practice — Prefer Composition Over Inheritance.
Program to Interfaces
Best practice — Program to Interfaces.
Minimize Mutability
Best practice — Minimize Mutability.
Use Enum for Constants
Best practice — Use Enum for Constants.
Avoid Raw Types
Best practice — Avoid Raw Types.
Use Bounded Wildcards
Best practice — Use Bounded Wildcards.
Prefer Method References
Best practice — Prefer Method References.
Use Stream API Idiomatically
Best practice — Use Stream API Idiomatically.
Avoid Parallel Streams by Default
Best practice — Avoid Parallel Streams by Default.
Use Concurrent Collections
Best practice — Use Concurrent Collections.
Minimize Lock Scope
Best practice — Minimize Lock Scope.
Avoid Thread Groups
Best practice — Avoid Thread Groups.
Use Executor Framework
Best practice — Use Executor Framework.
Handle InterruptedException Properly
Best practice — Handle InterruptedException Properly.
Prefer Time API over Date
Best practice — Prefer Time API over Date.
Use UTC for Storage
Best practice — Use UTC for Storage.
Avoid Calendar Class
Best practice — Avoid Calendar Class.
Use BigDecimal for Money
Best practice — Use BigDecimal for Money.
Compare BigDecimal with compareTo
Best practice — Compare BigDecimal with compareTo.
Cache Expensive Computations
Best practice — Cache Expensive Computations.
Use Lazy Initialization Carefully
Best practice — Use Lazy Initialization Carefully.
Avoid Premature Optimization
Best practice — Avoid Premature Optimization.
Profile Before Tuning
Best practice — Profile Before Tuning.
Use Appropriate Collection
Best practice — Use Appropriate Collection.
Size Collections When Known
Best practice — Size Collections When Known.
Override equals and hashCode Together
Best practice — Override equals and hashCode Together.
Make Classes Immutable When Possible
Best practice — Make Classes Immutable When Possible.
Use Builder for Many Parameters
Best practice — Use Builder for Many Parameters.
Avoid Excessive Logging
Best practice — Avoid Excessive Logging.
Use Structured Logging
Best practice — Use Structured Logging.
Never Log Passwords
Best practice — Never Log Passwords.
Sanitize User Input
Best practice — Sanitize User Input.
Use Parameterized Queries
Best practice — Use Parameterized Queries.
Validate All External Input
Best practice — Validate All External Input.
Principle of Least Privilege
Best practice — Principle of Least Privilege.
Keep Dependencies Updated
Best practice — Keep Dependencies Updated.
Use Dependency Injection
Best practice — Use Dependency Injection.
Separate Configuration from Code
Best practice — Separate Configuration from Code.
Write Testable Code
Best practice — Write Testable Code.
Aim for High Cohesion
Best practice — Aim for High Cohesion.
Reduce Coupling
Best practice — Reduce Coupling.
Document Public APIs
Best practice — Document Public APIs.
Use JavaDoc for Libraries
Best practice — Use JavaDoc for Libraries.
Follow Code Conventions
Best practice — Follow Code Conventions.
Use Static Analysis Tools
Best practice — Use Static Analysis Tools.
Review Code Regularly
Best practice — Review Code Regularly.
Refactor Incrementally
Best practice — Refactor Incrementally.
Delete Dead Code
Best practice — Delete Dead Code.
Avoid Magic Numbers
Best practice — Avoid Magic Numbers.
Use Constants Class
Best practice — Use Constants Class.
Handle Errors at Right Level
Best practice — Handle Errors at Right Level.
Use Custom Exceptions Sparingly
Best practice — Use Custom Exceptions Sparingly.
Return Empty Collections Not Null
Best practice — Return Empty Collections Not Null.
Defensive Copy for Mutable Args
Best practice — Defensive Copy for Mutable Args.
Use CopyOnWrite for Read-Heavy
Best practice — Use CopyOnWrite for Read-Heavy.
Prefer ArrayList over Vector
Best practice — Prefer ArrayList over Vector.
Use EnumSet and EnumMap
Best practice — Use EnumSet and EnumMap.
Avoid Double-Checked Locking
Best practice — Avoid Double-Checked Locking.
Use volatile for Visibility
Best practice — Use volatile for Visibility.
Document Thread Safety
Best practice — Document Thread Safety.
Limit Serialization
Best practice — Limit Serialization.
Use transient for Sensitive Fields
Best practice — Use transient for Sensitive Fields.
Prefer Interface Serialization
Best practice — Prefer Interface Serialization.
Version Serializable Classes
Best practice — Version Serializable Classes.
Use Module System for Encapsulation
Best practice — Use Module System for Encapsulation.
Export Only Public API
Best practice — Export Only Public API.
Avoid Deep Inheritance Hierarchies
Best practice — Avoid Deep Inheritance Hierarchies.
Favor Delegation Over Inheritance
Best practice — Favor Delegation Over Inheritance.
Use Records for Data Carriers
Best practice — Use Records for Data Carriers.
Use Sealed Classes for Restricted Hierarchies
Best practice — Use Sealed Classes for Restricted Hierarchies.