This document provides an overview of various Java concepts including collections, exceptions, logging, and enums. Some key points covered include: - Collections like List, Set, and Map are commonly used data structures in Java. The appropriate collection depends on the data type and requirements. - Exceptions communicate errors and should follow best practices like specific exception types and avoiding null returns. - Logging is important for debugging and monitoring. Logs should have readable messages in the correct severity type. - Enums allow a variable to be a set of predefined constants and have benefits like type safety and singleton instances. Immutable objects are preferable unless mutability is explicitly needed.

1. 1

2. What you get today.
Common to all.
Annotations
Log entries
Enumerations
Object creation.
Collections
Exception handling
Generics
2Java for SE

3. toString
•Always override toString.
•When practical, the toString method should return all of the
interesting information contained in the object.
•Keep updating whenever a new attribute added to the class.
•Let IDE to generate it for you.
3Java for SE

4. equals()
•Obey the general contract when overriding equals.
•A well defined equals method must follow,
Reflexivity
Symmetry
Transitivity
Consistent
For any non-null reference it should return,false.
•It is really hard to implement a correct equals method so use IDE
for generate it.
4Java for SE

5. hashcode()
•Always override hashCode when you override equals.
• You must override hashCode in every class that overrides equals
•It is some thing like a fingerprint of the object.
•“hashCode” method must consistently return the same integer
whenever it invoked for same object.
•If hashcose returns true for both object then equals also returns
true but not the vice versa.
•Let the IDE to generate a hashcode for you.
5Java for SE

6. Commons to all - summery
•Always override toString.
•Obey the general contract when overriding equals.
•Always override hashCode when you override equals.
•Override clone judiciously.
•Consider implementing Comparable.
6Java for SE

7. Generics
Let's’ assume, we wanted to define a collection of course objects.
We define a List data structure,
List data = new ArrayList();
Issue here is , it can contain any type of data. Processing a
heterogeneous collection will be a nightmare.
With Java 5 we can generalize collections to use only specific
data types (type safety), we call it generics.
List<Course> data = new ArrayList<Course> ();
7Java for SE

8. Generics and byte code.
A. List data = new ArrayList();
B. List<Course> data = new ArrayList<Course> ();
Let's’ assume we have define a non generalized list in class A
and Generalized list class B . Once compiled you get two byte
codes.
Will they be same ?
YES , When compiling, java will remove all the Generics after
they being evaluated and make sure collections does not contain
heterogeneous data. That's why you are not getting same code if
you're generate the source from byte code.
8Java for SE

9. Use generics everywhere.
Ensure type safety to your method inputs.
void createCourses(List<Course> courses){
}
Ensure type safety to your method outputs
List<Course> createCourses(List<Course> courses){
return new ArrayList<Course>();
}
9Java for SE

10. Collection Framework
Collection
Map List
10Java for SE
List

11. Map
Use MAP implementation if your data can be model as a Key
Value pair.
Some notable implementations
•HashMap.
•WeakHashMap
You can use an object as Key for the map but using null value
as key is not permitted.
11Java for SE

12. Map Performance
Searching an entry from a Map should take consistent
amount of time.It does not matter you have 10000 record or 1
record in the map. We call it O(1) performance.
But this depends on a factor called a load factor.
Load Factor = available data size / total capacity.
It's being proven that, O(1) only be achievable if the load
factor is near to 0.75
12Java for SE

13. Map Performance
Searching an entry from a Map should take consistent
amount of time.It does not matter you have 10000 record or 1
record in the map. We call it O(1) performance.
But this depends on a factor called a load factor.
Load Factor = available data size / total capacity.
It's being proven that, O(1) only be achievable if the load
factor is near to 0.75
13Java for SE

14. Map Performance
What will happen if you instantiate a Map as follow.
Map<String,String> users = new HashMap<>();
Other Constructors
HashMap()
HashMap(int initialCapacity)
HashMap(int initialCapacity, float loadFactor)
HashMap(Map<? extends K,? extends V> m)
14Java for SE

15. List
If your data is linear or having multiple copies of same data
or containing null data, this is the better data structure for the
scenario.
There are two basic implementations.
•ArrayList.
‒Array based implementation which is having better performance
but you do not have ability to traverse through the list.
•LinkList.
‒Doubly link list based implementation which is enabling traversals
through the list.
15Java for SE

16. Set
If your data is nonlinear or having null value ( not all
implementations ) but there are not any duplicate values this will
be suitable for use.
Commonly used implementations.
•HashSet.
‒Hash Table based implementation but there is no grantee on the
order.
•LinkedHashSet.
‒Hash Table and link list based implementation which is having
predictable order.
Performance of both above will be determine by the load factor
16Java for SE

17. Natural Ordering
There are two types of ordering in a collection,
•Insert order - you can access data from the way you have inserted.
•Natural order- Data will be stored based on the properties of the
inserted object.
Example Scenario
You have set of student objects but you need to get the youngest
student whenever you get the first element but this need to be
fast as possible.
In such scenario you can use TreeSet implementation which
restructure the set based on the comparator provided.
17Java for SE

18. Avoid return null values.
What is the issue here ?
List<Course> retreiveCourses(List<Course> courses){
List<Course> courses= null;
// Invoke db but it returns null
return courses;
}
● Caller has to be careful since method may return null values
instead of a List.This will introduce more checks in callers
side.
● Returning a Null from a method is an anti pattern.
18Java for SE

19. Collections.
Collections is a utility class which provide plenty of useful
methods. Collection class provide few immutable , singleton
objects to safeguards us from returning null values.
Option 1 :
public static final List EMPTY_LIST
Option 2:
List<String> s = Collections.emptyList();
We can use both options instead of returning a null, but use
Option 2 since Option 1 does not provide the type safety.
19Java for SE

20. Collections.
Some other useful methods in collections.
By default, most of the collection are not thread safe, but with the
help of Collections we can make them safe.
List list = Collections.synchronizedList(new ArrayList());
Collections.replaceAll
Collections.sort
Collections.reverse
20Java for SE

21. Diamond Operator
Old approach:
Map<String,MyClass> classes = new HashMap<String,MyClass>();
New approach:
Map<String,MyClass> classes = new HashMap<>();
21Java for SE

22. Static factory method
Consider static factory methods instead of constructors.
In normal way , we invoke public constructor for creating an
object. Static factory method is an alternative which has more
benefits when compared to the constructors.
Sample from Boolean class
public static Boolean valueOf(boolean b) {
return b ? Boolean.TRUE : Boolean.FALSE;
}
22Java for SE

23. Benefits of a static factory
method
•Unlike constructors, they have names.
•Unlike constructors,they are not required to create a new object
each time they’re invoked.
•Unlike constructors,they can return an object of any subtype of their
return type.
•they reduce the verbosity of creating parameterized type instances.
23Java for SE

24. Object creation.
•Consider static factory methods instead of constructors.
•Consider a builder when faced with many constructor parameters.
24Java for SE

25. Builder
Problem
NutritionFacts cocaCola = new NutritionFacts(240, 8, 100, 0, 35, 27);
Bad Solution
NutritionFacts cocaCola = new NutritionFacts();
cocaCola.setServingSize(240);
cocaCola.setServings(8);
cocaCola.setCalories(100);
cocaCola.setSodium(35);
cocaCola.setCarbohydrate(27);
Demo : builder pattern
25Java for SE

26. Immutability.
Create immutable unless you have good reason to be mutable.
What is an immutable object ?
Object which is not able to modify once it's being created.
What are the advantages of immutability ?
•Immutable objects are inherently thread-safe; they require no
synchronization so you can share them freely.
•Immutable objects are simple.
26Java for SE

27. Make a class immutable
•Don’t provide any methods that modify the object’s state.
•Ensure that the class can’t be extended.
•Make all fields final.
•Make all fields private.
•Ensure exclusive access to any mutable components.
27Java for SE

28. Well known immutable
class
•String is the well known immutable class
28Java for SE

29. Exception hierarchy.
29Java for SE

30. Check or Unchecked
•Use checked exceptions, if you think that caller should handle
the exception.
•Use runtime exceptions to indicate a programming errors. Such
as precondition violations.
30Java for SE

31. Standard exceptions
31Java for SE
Exception Occasion for Use
IllegalArgumentException Non-null parameter value is
inappropriate
IllegalStateException Object state is inappropriate for
method invocation
NullPointerException Parameter value is null where
prohibited
IndexOutOfBoundsException Index parameter value is out of
range
UnsupportedOperationExceptionObject does not support method

32. Do not ignore
try {
...
} catch (SomeException e) {
}
At the very least, the catch block should contain a comment
explaining why it is appropriate to ignore the exception.
32Java for SE

33. Catch what you can
handle.
try {
...
} catch (Exception e) {
}
•Catch only what you can handle, else throw it to higher level.
•Use smallest bucket to handle exception.
‒Do not use Exception class to catch all of your exceptions.
33Java for SE

34. Multi Catch Exceptions
Before
catch (IOException ex) {
logger.log(ex);
throw ex;
catch (SQLException ex) {
logger.log(ex);
throw ex;
}
Now
catch (IOException|SQLException ex) {
logger.log(ex);
throw ex;
}
34Java for SE

35. Annotation
Annotations, a form of metadata, provide data about a program
that is not part of the program itself.By adding an annotation,
you can modify the functionality of the code without modifying.
Each annotation has two properties,
1. Where it can be used ( Retention Policy )
Ex . Class , Method, Attribute
2. Which time its being considered
Ex . Run time, Compile time, Source code
35Java for SE

36. Predefined annotations
There are plenty of predefined annotations, here we have listed
few commonly used.
•Deprecated - Indicate this is outdated and will be removed.
•Override - Instruct compiler, method is overridden from the parent.
•SuppressWarnings - Instruct compiler to ignore any warning
‒Ex : If you use a List without generic, compiler will throw a warning
‒This is a very risky annotation, do not use it if you know what you
are doing..
36Java for SE

37. Data Validation
Object orientation is all about, objects and message passing
among them. The common way of message passing is calling a
method or a function so its developers responsibility to protect
the internals of the object from the passed data.
Data Validation Strategies.
•Accept known good.
•Reject known bad.
•Sanitize
•No validation.
You should follow the top to bottom order when you do a data
validation.
37Java for SE

38. Accept known good.
This strategy is also known as "whitelist" or "positive" validation. The idea is
that you should check that the data is one of a set of tightly constrained
known good values. Any data that doesn't match should be rejected. Data
should be:
•Strongly typed at all times.
•Length checked and fields length minimized.
•Range checked if a numeric
•Unsigned unless required to be signed.
•Syntax or grammar should be checked prior to first use or inspection
If you expect a postcode, validate for a postcode (type, length and syntax):
38Java for SE

39. Accept known good.
Sample post code validation
public String isPostcode(String postcode) {
return (postcode != null && Pattern.matches("^(((2|8|9)d{2})|((02|08|09)d{2})|([1-
9]d{3}))$", postcode)) ? postcode : "";
}
More info :
https://www.owasp.org/index.php/Data_Validation
39Java for SE

40. Log file.
Log file is the first location you should look at in case of an
incident, since in most cases you do not have luxury to do a
remote debugging is not permitted.
Follow are few properties of a good log entry.
•It should be readable and meaningful.
•Log should be lightweight.
•Make sure log does not introduce a new bug.
•It should fall into correct log type.
•Always try to minimize the memory consumption by the log entry.
40Java for SE

41. Choose correct log type.
•ERROR
‒If you encounter an exception or an error make sure to log under
this type.
LOGGER.error(" Exception while order creation " , e));
•WARN
‒If you think something bad can happen due to some reason, then
log a warning message.
LOGGER.warn(" Disconnected from order processing service" ));
41Java for SE

42. Choose correct log type.
•DEBUG
‒If you need to log more data for tracking an issue ( during
the development phase)
LOGGER.debug(" order processing initiated for order id : " + 100 + "
by " + userID ));
•INFO
‒Use these type of logs to keep track of informations.
LOGGER.info(" Nightly order bulk processing process started ");
42Java for SE

43. Reduce memory
consumption by a log entry
When we log a debug entry, most of the time it associate with
plenty of string operations. Let's take below log entry.
List<MyClass> classes = new ArrayList<MyClass>();
LOGGER.debug("Class objects " + classes);
Better way to log highly memory consuming log entry.
if(LOGGER.isDebugEnabled()){
LOGGER.debug("Class objects " + classes);
}
43Java for SE

44. Enum
An enum type is a special data type that enables for a variable to
be a set of predefined constants.
Advantages of using enum.
•You can group constants with enum.
•They are compile time constants which means they are type safe.
•By default enum is singleton.
•Like other classes they can have constructors, attributes or methods.
•You can use enums for switch cases.
Always use enum type instead of int constants.
44Java for SE

45. Enumpublic enum Planet {
MERCURY (3.303e+23, 2.4397e6),
NEPTUNE (1.024e+26, 2.4746e7);
private final double mass; // in kilograms
private final double radius; // in meters
Planet(double mass, double radius) {
this.mass = mass;
this.radius = radius;
}
private double mass() { return mass; }
private double radius() { return radius; }
// universal gravitational constant (m3 kg-1 s-2)
public static final double G = 6.67300E-11;
double surfaceGravity() {
return G * mass / (radius * radius);
}
double surfaceWeight(double otherMass) {
return otherMass * surfaceGravity();
}
}
45Java for SE

46. Further Reading
Effective java is one of the few books
where any java developer should read.
46Presentation Title Arial Bold 7 pt
Image by Photographer's Name (Credit in black type) or
Image by Photographer's Name (Credit in white type)