Normalisation écriture du code Java

Normalisation écriture du code Java

A, itération entrySet () Récupère la carte de la clé et la valeur

Lorsque la boucle n'a besoin que d'acquérir la carte clé de clé primaire, itération keySet () est correct, mais lorsque vous avez besoin d'une clé de clé primaire et de la valeur de la valeur, l'itération entrySet () est une approche plus efficace, ce qui keySet que la première itération () alors aller chercher la valeur de meilleures performances.

//Map 获取key & value 正例:
HashMap<String, String> map = new HashMap<>();
for (Map.Entry<String,String> entry : map.entrySet()){
 String key = entry.getKey();
 String value = entry.getValue();
}

//Map 获取value 反例:
HashMap<String, String> map = new HashMap<>();
for (String key : map.keySet()){
    String value = map.get(key);
}

En second lieu, l'utilisation Collection.isEmpty () détecte un vide

L'utilisation d'une collection, () est vide n'est pas détecté sur les problèmes logiques, mais en utilisant Collection.isEmpty () rend le code plus lisible, de meilleures performances peuvent être obtenues, en outre, tout Collection.isEmpty () mis en œuvre complexité est en O (1), plusieurs cycles ne doivent pas traverser, mais par une certaine complexité temporelle d'une implémentation de la méthode Collection, () peut être O (n)

//正例：
LinkedList<Object> collection = new LinkedList<>();
if (collection.isEmpty()){
    System.out.println("collection is empty.");
}

//检测是否为null 可以使用CollectionUtils.isEmpty()
if (CollectionUtils.isEmpty(collection)){
    System.out.println("collection is null.");

}

//反例
LinkedList<Object> collection = new LinkedList<>();
if (collection.size() == 0){
 System.out.println("collection is empty.");
}

Troisièmement, pour rappeler la méthode Collection.contains utilisent fréquemment le Set

Dans la bibliothèque de classes de collection Java, Liste contient la méthode générale de la complexité temporelle de O (n), si le code contient des appels de méthode trouvent souvent le premier ensemble de données sont converties en une liste obtenue HashSet, O (n) complexité temporelle sera O (1).

//频繁调用Collection.contains() 正例
List<Object> list = new ArrayList<>();
Set<Object> set = new HashSet<>();
for (int i = 0; i <= Integer.MAX_VALUE; i++){
    //时间复杂度为O(1)
    if (set.contains(i)){
        System.out.println("list contains "+ i);
    }
}

//频繁调用Collection.contains() 反例
List<Object> list = new ArrayList<>();
for (int i = 0; i <= Integer.MAX_VALUE; i++){
    //时间复杂度为O(n)
    if (list.contains(i))
    System.out.println("list contains "+ i);
}

L'utilisation de blocs de code statique outils d'affectation variable membre statique

Pour les variables membres statiques types de collecte, vous devez utiliser l'attribution de blocs de code statique, au lieu d'utiliser un ensemble de mise en œuvre à la cession

//赋值静态成员变量正例
private static Map<String, Integer> map = new HashMap<String, Integer>();
static {
    map.put("Leo",1);
    map.put("Family-loving",2);
    map.put("Cold on the out side passionate on the inside",3);
}

private static List<String> list = new ArrayList<>();
static {
    list.add("Sagittarius");
    list.add("Charming");
    list.add("Perfectionist");
}

//赋值静态成员变量反例
private static Map<String, Integer> map = new HashMap<String, Integer>(){
    {
        map.put("Leo",1);
        map.put("Family-loving",2);
        map.put("Cold on the out side passionate on the inside",3);
    }
};
private static List<String> list = new ArrayList<>(){
    {
        list.add("Sagittarius");
        list.add("Charming");
        list.add("Perfectionist");
    }
};

V. constructeur de bouclier outils

Tools est une collection d'un tas de champs statiques et les fonctions, qui ne doit pas être instancié, mais, Java ajoute un constructeur public implicite pour chaque classe n'est pas explicitement défini constructeur, afin d'éviter instanciation inutile, devrait définition explicite des constructeurs privés pour protéger le constructeur public implicite.

public class PasswordUtils {
//工具类构造函数正例
private static final Logger LOG = LoggerFactory.getLogger(PasswordUtils.class);

//定义私有构造函数来屏蔽这个隐式公有构造函数
private PasswordUtils(){}

public static final String DEFAULT_CRYPT_ALGO = "PBEWithMD5AndDES";

public static String encryptPassword(String aPassword) throws IOException {
    return new PasswordUtils(aPassword).encrypt();
}	

public class PasswordUtils {
//工具类构造函数反例
private static final Logger LOG = LoggerFactory.getLogger(PasswordUtils.class);

public static final String DEFAULT_CRYPT_ALGO = "PBEWithMD5AndDES";

public static String encryptPassword(String aPassword) throws IOException {
   

Sixième, la conversion de chaîne en utilisant String.valueOf (valeur) au lieu de « » + valeur

Lorsque le type ou d'autres objets dans une chaîne, en utilisant String.valueOf (valeur) « » + est supérieure à la valeur d'efficacité.

//把其它对象或类型转化为字符串正例：
int num = 520;
// String.valueOf() 效率更高
String strLove = String.valueOf(num);

//把其它对象或类型转化为字符串反例：
int num = 520;
// "" + value
String strLove = "" + num;

Sept, évitez d'utiliser BigDecimal (double)

BigDecimal (double) la présence du risque de perte de précision, le calcul exact des valeurs de comparaison ou la scène peut provoquer l'exception de la logique métier.

// BigDecimal 正例
BigDecimal bigDecimal1 = bigDecimal.valueOf(0.11D);

// BigDecimal 反例    
BigDecimal bigDecimal = new BigDecimal(0.11D);

Huit, retourne un tableau vide plutôt que nulle et collections

Si le rendement d'exécution du programme null, null carrés besoins de tests obligatoires à appeler, sinon il va jeter exception de pointeur NULL renvoie un tableau vide ou un ensemble vide, éviter efficacement la situation parce que l'appelant ne détecte pas exception de pointeur null null est lancée, vous pouvez aussi supprimer l'appelant détecte instruction vide rend le code plus concis.

//返回空数组和空集正例
public static Result[] getResults() {
    return new Result[0];
}

public static List<Result> getResultList() {
    return Collections.emptyList();
}

public static Map<String, Result> getResultMap() {
    return Collections.emptyMap();
}

//返回null 反例
public static Result[] getResults() {
    return null;
}

public static List<Result> getResultList() {
    return null;
}

public static Map<String, Result> getResultMap() {
    return null;
}

Neuf, la valeur de priorité égale appel de méthode à l'aide constante ou déterminée

Procédé égaux exception de pointeur de court-circuit facilement, doit être utilisé avec une valeur constante ou objet déterminé est égal à appeler la méthode.

//调用 equals 方法正例
private static boolean fileReader(String fileName)throws IOException{

    // 使用常量或确定有值的对象来调用 equals 方法
    return "Charming".equals(fileName);

    //或使用：java.util.Objects.equals() 方法
   return Objects.equals("Charming",fileName);
}

//调用 equals 方法反例
private static boolean fileReader(String fileName)throws IOException{

 // 可能抛空指针异常
 return fileName.equals("Charming");
}

Dix, énumération des champs d'attribut doit être privé et immuable

Énumération est généralement utilisé comme une constante, ou si les méthodes d'énumération commune du champ de réglage du champ d'attributs existent, les propriétés constantes d'énumération peut facilement être modifié, idéalement, les champs de propriétés de dénombrement sont privés, propriétaires et constructeur, affectation, il n'y a pas de méthode correspondant Setter, de préférence conjointement avec le modificateur final.

正例：

public enum SwitchStatus {
    // 枚举的属性字段正例
    DISABLED(0, "禁用"),
    ENABLED(1, "启用");

    // final 修饰
    private final int value;
    private final String description;

    private SwitchStatus(int value, String description) {
        this.value = value;
        this.description = description;
    }

    // 没有Setter 方法
    public int getValue() {
        return value;
    }

    public String getDescription() {
        return description;
    }
}

public enum SwitchStatus {
    // 枚举的属性字段反例
    DISABLED(0, "禁用"),
    ENABLED(1, "启用");

    public int value;
    private String description;

    private SwitchStatus(int value, String description) {
        this.value = value;
        this.description = description;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }
}

supprimer les opérations / add pas réalisées dans les éléments dans la boucle foreach

Si vous souhaitez supprimer l'opération, vous pouvez appeler la méthode de suppression de la classe iterator plutôt que de supprimer la méthode de collecte. Si vous modifiez la liste, car après la iterator est créée à partir de la structure à tout moment, de quelque manière que par vos propres méthodes / retirons du iterator, l'itérateur lancera une ConcurrentModificationException, qui est mécanisme à rapide produite par un seul état de fil.

fail-fast 机制 ：多个线程对 fail-fast 集合进行修改的时，可能会抛出ConcurrentModificationException，单线程下也会出现这种情况，上面已经提到过。

package java.util ensemble suivant de toutes les classes sont fail-rapide, et le paquet java.util.concurrent ci-dessous toutes les classes sont de sécurité.

//强制，不要在foreach循环里进行元素的remove/add操作。remove元素需要使用Iterator方式，如果并发操作，需要对Iterator对象加锁。
//正例
List<String> list = new ArrayList<>();
list.add("1");
list.add("2");
Iterator<String> iterator  = list.iterator();
while(iterator.hasNext()){
	String item = iterator.next();
	if(删除元素的条件){
		iterator.remove();
	}
}

//反例
for(String item : list){
	if("1".equals(item)){
		list.remove(item);
	}
}