Cách Viết code Cơ Bản Trong Java.

// Không nên:
static String firstLineOfFile(String path) throws IOException {
   BufferedReader br = new BufferedReader(new FileReader(path));
   try {
      return br.readLine();
   } finally {
      br.close();
   }
}

// Nên:
static String firstLineOfFile(String path) throws IOException {
   try (BufferedReader br = new BufferedReader(new FileReader(path))) {
      return br.readLine();
   }
}

// Không Nên:
static void copy(String src, String dst) throws IOException {
   InputStream in = new FileInputStream(src);
   try {
      OutputStream out = new FileOutputStream(dst);
      try {
         byte[] buf = new byte[BUFFER_SIZE];
         int n;
         while ((n = in.read(buf)) = 0)
            out.write(buf, 0, n);
      } finally {
         out.close();
      }
   } finally {
      in.close();
   }
 }

// Nên:
static void copy(String src, String dst) throws IOException { 
   try (InputStream in = new FileInputStream(src); 
        OutputStream out = new FileOutputStream(dst)) { 
      byte[] buf = new byte[BUFFER_SIZE]; 
      int n; 
      while ((n = in.read(buf)) = 0)
         out.write(buf, 0, n); 
   } 
}

1. remove Setter method.
2. final class: không cho class dc extend 
3. final private fields, thì phải có constructor full parameters để khởi tạo.
4. Chắc chắc những Getter method không phải thay đổi giá trị, lưu ý những fields kiểu Date hay kiểu Object thì nên clone trước để bảo đảm giá trị không bị reference.

public final class FinalClassExample {
   private final int id;
   private final String name;
   private final Date birthDate;
   private final Map<String, String> testMap;

   public FinalClassExample(int id, String name, Date birthDate, Map<String, String> testMap) {    // (3)
      this.id = id;
      this.name = name;

      birthDate = birthDate.clone();   // (4)
      //
      Map<String, String> tempMap = new HashMap<>();
      String key;
      Iterator<String> it = testMap.keySet().iterator();
      while (it.hasNext()) {
         key = it.next();
         tempMap.put(key, testMap.get(key));
      }
      this.testMap=tempMap;
   }

   public int getId() {
      return id;
   }

   public String getName() {
      return name;
   }

   public Date getBirthDate() {
      return birthDate.clone(); 
   }

   public Map<String, String> getTestMap() {
      // need to clone like code in constructor.
   }
}

// Không Nên:
public interface PhysicalConstants {
   // Avogadro's number (1/mol)
   static final double AVOGADROS_NUMBER = 6.022_140_857e23;
   
   // Boltzmann constant (J/K)
   static final double BOLTZMANN_CONSTANT = 1.380_648_52e-23; 
   
   // Mass of the electron (kg)
   static final double ELECTRON_MASS = 9.109_383_56e-31;
}

// Nên:
public final class PhysicalConstants {
   private PhysicalConstants();      // không cho khởi tạo.

   // Avogadro's number (1/mol)
   static final double AVOGADROS_NUMBER = 6.022_140_857e23;
   
   // Boltzmann constant (J/K)
   static final double BOLTZMANN_CONSTANT = 1.380_648_52e-23; 
   
   // Mass of the electron (kg)
   static final double ELECTRON_MASS = 9.109_383_56e-31;
}

// Không nên:

   // The int enum pattern - severely deficient!
   public static final int APPLE_FUJI         = 0;
   public static final int APPLE_PIPPIN       = 1;
   public static final int APPLE_GRANNY_SMITH = 2;

   public static final int ORANGE_NAVEL  = 0;
   public static final int ORANGE_TEMPLE = 1;
   public static final int ORANGE_BLOOD  = 2;

   // Nên: 
   public enum Apple { FUJI, PIPPIN, GRANNY_SMITH } 
   public enum Orange { NAVEL, TEMPLE, BLOOD } 

Lợi ích: 
1/ Đối tượng hoá và có thể dùng switch ...case. 
2/ An toàn về kiểu và giá trị, giống như constants không thể gõ nhầm dc. 
3/ Dùng Enum.valueOf để validate dễ dàng. 
4/ Có lưu xuống database thì nhìn cũng rõ nghĩa hơn là những con số.

// Không nên:
ArrayList<String> item = new ArrayList<String>();

// Nên:
List<String> item = new ArrayList<>();

// Không nên
// Anonymous class instance as a function object - lỗi thời rồi!
   Collections.sort(words, new Comparator<String>() {
      public int compare(String s1, String s2) {
          return Integer.compare(s1.length(), s2.length());
      }
});

// Nên:
// Lambda expression as function object (replaces anonymous class)     
Collections.sort(words,
                  <span class="_4yxo">(s1, s2) -> Integer.compare(s1.length(), s2.length()</span>));  

// Có thể viết theo một cách khác
Collections.sort(words, comparingInt(String::length));

// Hoặc 
words.sort(comparingInt(String::length));  

// Không nên:    
static int min(int... args) {
   if (args.length == 0) { 
      throw new IllegalArgumentException("Too few arguments"); 
   }
   int min = args[0];
   for (int i = 1; i < args.length; i++) {
      if (args[i] < min) {
         min = args[i];
      }
   }
   return min; 
} 

// Sẽ bị lỗi khi không truyền parameters nào.

// Nên: 
static int min(int firstArg, int... remainingArgs) {
   int min = firstArg;
   for (int arg : remainingArgs) {
      if (arg < min) {      
         min = arg;
      }
   }
   return min; 
} 
// Cho nên mới cần Unit Test.

// Không Nên:
public List<Cheese> getCheeses() {
   final List<Cheese> cheeseInStock = .....;
   return cheesesInStock.isEmpty() ? null : new ArrayList<>(cheesesInStock);
} 

// Nên:
public List<Cheese> getCheeses() {
   final List<Cheese> cheeseInStock = .....;
   return cheesesInStock.isEmpty() ? Collections.emptyList() : 
                                    new ArrayList<>(cheesesInStock);
} 

System.out.println(1.03 - 0.42);

Output:   0.6100000000000001 

.collect(Collectors.toList());

// Group by id and a object
Map<Long, ClientEntity> idAndClientMap = entities.stream().collect(Collectors.toMap(c -> c.getId(), Function.identity()));

// Group by id and object list
Map<Long, List<ClientEntity>> idAndClientsMap = entities.stream().collect(Collectors
                .groupingBy(c -> c.getId(), Collectors.mapping(Function.identity(), Collectors.toList())));