关于List、Set、Map、Array、Enum遍历方式总结

关于List、Set、Map、Array遍历方式总结：

public class Tests {

    public static void main(String[] args) {

        //set ===========================================================
        Set<String> demoSet = new HashSet<>();
        demoSet.add("test1");
        demoSet.add("test2");

        System.out.println("Set : lambda -----------------------------");
        demoSet.stream().forEach(System.out::println);

        System.out.println("Set : foreach -----------------------------");
        demoSet.forEach(item -> System.out.println(item));

        System.out.println("Set : iterator -----------------------------");
        Iterator<String> iteratorSet = demoSet.iterator();
        while (iteratorSet.hasNext()){
            System.out.println(iteratorSet.next());
        }

        System.out.println("Set : for -----------------------------");
        for (String item : demoSet) {
            System.out.println(item);
        }

        //Map ===========================================================
        Map<String, String> demoMap = new HashMap<>();
        demoMap.put("a", "aa");
        demoMap.put("b", "bb");
        demoMap.put("c", "cc");
        System.out.println("Map : entrySet -----------------------------");
        for (Map.Entry item : demoMap.entrySet()) {
            System.out.println(item.toString());
        }

        System.out.println("Map : keySet -----------------------------");
        for (String item : demoMap.keySet()) {
            System.out.println(item);
        }

        System.out.println("Map : iterator -----------------------------");
        Iterator<Entry<String, String>> iterator = demoMap.entrySet().iterator();
        while (iterator.hasNext()) {
            Entry<String, String> item = iterator.next();
            System.out.println(item.getValue());
        }

        System.out.println("Map : values -----------------------------");
        for (String item : demoMap.values()) {
            System.out.println(item);
        }

        System.out.println("Map : forEach -----------------------------");
        demoMap.forEach((key, val) -> System.out.println(val + "-:-" + key));

        //List ===========================================================
        List<Integer> itemsList = new ArrayList<>();
        itemsList.add(1);
        itemsList.add(3);
        itemsList.add(5);

        System.out.println("List : for -----------------------------");
        for (int i = 0; i < itemsList.size(); i++) {
            System.out.println(itemsList.get(i));
        }

        System.out.println("List : foreach -----------------------------");
        for (Integer item : itemsList) {
            System.out.println(item);
        }

        System.out.println("List : lambda -----------------------------");
        itemsList.forEach(item -> System.out.println(item));

        System.out.println("List : lambda -----------------------------");
        itemsList.forEach(System.out::println);

        System.out.println("List : stream -----------------------------");
        itemsList.stream().forEach(item -> {
            if (item.equals(5)) {
                System.out.println(item);
            }
        });

        System.out.println("List : stream -----------------------------");
        itemsList.stream().filter(a -> a.equals(3)).forEach(System.out::println);

        //Array ===========================================================
        Integer[] items = {1, 2, 3, 4, 5};

        System.out.println("Array : for -----------------------------");
        for (int i = 0; i < items.length; i++) {
            System.out.println(items[i]);
        }
        System.out.println("Array : foreach -----------------------------");
        for (Integer item :
            items) {
            System.out.println(item);
        }
        System.out.println("Array : lambda -----------------------------");
        Arrays.asList(items).forEach(a -> System.out.println(a));

        System.out.println("Array : lambda -----------------------------");
        Arrays.asList(items).forEach(System.out::println);

    }
}

关于枚举遍历的方式总结：

enum AlarmGrade {
    WARNING("warning", "警告"),
    ATTENTION("attention", "提示"),
    UNKNOWN("unknown", "未知");

    private String key;
    private String name;

    AlarmGrade(String key, String name) {
        this.key = key;
        this.name = name;
    }


    public String getKey() {
        return key;
    }

    public String getName() {
        return name;
    }

    public static AlarmGrade getEnumByType(String key) {
        AlarmGrade[] items = AlarmGrade.values();
        for (AlarmGrade item : items) {
            if (item.getKey().equals(key)) {
                return item;
            }
        }
        return AlarmGrade.UNKNOWN;
    }

    public static AlarmGrade getEnumByType1(String key) {
        AlarmGrade[] alarmGrades = AlarmGrade.values();
        for (int i = 0; i < alarmGrades.length; i++) {
            if (alarmGrades[i].getKey().equals(key)) {
                return alarmGrades[i];
            }
        }
        return AlarmGrade.UNKNOWN;
    }

    public static AlarmGrade getEnumByType2(String key) {
        return Arrays.asList(AlarmGrade.values()).stream().filter(item -> item.getKey().equals(key)).findFirst()
            .orElse(AlarmGrade.UNKNOWN);
    }

    public static void main(String[] args) {
        System.out.println(AlarmGrade.getEnumByType("warning"));
        System.out.println(AlarmGrade.getEnumByType("aa"));
        System.out.println(AlarmGrade.getEnumByType1("warning"));
        System.out.println(AlarmGrade.getEnumByType1("aa"));
        System.out.println(AlarmGrade.getEnumByType2("warning").getName());
        System.out.println(AlarmGrade.getEnumByType2("aa"));
    }
}