java中常见的List、Map遍历方法总结及List排序相关方法总结

原创已于 2022-08-15 19:41:49 修改 · 3k 阅读

7 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#java #list #数据结构

于 2022-08-15 19:31:57 首次发布

本文详细介绍了Java中List和Map的常见遍历方式，包括普通for循环、增强for循环、迭代器遍历和lambda表达式。同时，还涵盖了数组和List的排序方法，包括使用内部类和lambda表达式的实现。这些基础知识对于日常Java开发至关重要。

文章目录

前言
一、List相关遍历方法总结
二、Map 相关遍历
三、数组排序
- - 1. 通过Arrays.sort + 内部类实现排序
  - 2. 通过Arrays.sort + lambda表达式实现排序
四、List排序
- - 1. 通过list.sort + 内部类实现排序
  - 2. 通过list.sort+ lambda表达式实现排序

前言

在java基础中， List和Map是两个最常见的与数据处理相关的数据结构，工作中大多数的数据处理也都离不开这两者。由此学习List和Map非常重要。以下是我总结的关于List和Map最常见的遍历方法与排序方法。

一、List相关遍历方法总结

1. 普通for i 循环

	public static void eachList01(List<String> list) {
        for (int i = 0; i < list.size(); i++) {
            String temp = list.get(i);
            System.out.println(temp);
        }
    }

2. 增强for循环

	public static void eachList02(List<String> list) {
        for (String str: list) {
            System.out.println(str);
        }
    }

3. 迭代器循环遍历

 	public static void eachList03(List<String> list) {
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String temp = iterator.next();
            System.out.println(temp);
        }
    }

4. lambda表达式

  public static void eachList04(List<String> list) {
        list.forEach(item -> System.out.println(item));
    }

二、Map 相关遍历

1. 通过map视图实现遍历

	public static void eachMap01(Map<Integer, String> map) {
        // map.entrySet()返回一个集合，那就遍历这个集合
        Set<Map.Entry<Integer, String>> entrySet = map.entrySet();
        for (Map.Entry<Integer, String> entry: entrySet) {
            System.out.println(entry);
        }
    }

2. 通过map视图遍历Key从而实现遍历

	public static void eachMap02(Map<Integer, String> map) {
        // map.keySet()可以返回一个map的所有key组成的集合
        Set<Integer> keySet = map.keySet();
        for (Integer integer: keySet) {
            System.out.println(integer + ": " + map.get(integer));
        }
    }

3. 通过迭代器实现遍历

	public static void eachMap03(Map<Integer, String> map) {
        //返回此映射中包含的映射关系的 Set 视图,Set接口继承自Collection，而Collection可以获取到迭代器
        Iterator<Map.Entry<Integer, String>> iterator = map.entrySet().iterator();
        System.out.println("while：");
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        System.out.println("for：");
        for(Iterator<Map.Entry<Integer, String>> iterator1 = map.entrySet().iterator(); iterator1.hasNext();) {
            System.out.println(iterator1.next());
        }
    }

4. 通过lambda表达式实现遍历

		public static void eachMap04(Map<Integer, String> map) {
        map.forEach((key, value) -> {
            System.out.println(key + ": " + value);
        });
    }

三、数组排序

1. 通过Arrays.sort + 内部类实现排序

		Arrays.sort(debits, new Comparator<Debit>() {
            @Override
            public int compare(Debit o1, Debit o2) {
                if(o1.getQuota() > o2.getQuota()) {
                    return 1;
                } else if(o1.getQuota() < o2.getQuota()) {
                    return -1;
                }
                return 0;
            }
        });
        for (Debit debit : debits) {
            System.out.println(debit);
        }

2. 通过Arrays.sort + lambda表达式实现排序

		Arrays.sort(debits, (o1, o2) -> {
            if(o1.getQuota() > o2.getQuota()) {
                return 1;
            } else if (o1.getQuota() < o2.getQuota()) {
                return -1;
            }
            return 0;
        });
        for (Debit debit : debits) {
            System.out.println(debit);
        }

四、List排序

1. 通过list.sort + 内部类实现排序

	public <T>void debitSort(List<T> list) {
        list.sort(new Comparator<T>() {
            @Override
            public int compare(T o1, T o2) {
                if(o1 instanceof Debit) {
                    Debit d1 = (Debit)o1;
                    Debit d2 = (Debit)o2;
                    if(d1.getQuota() > d2.getQuota()){
                        return 1;
                    } else if(d1.getQuota() < d2.getQuota()) {
                        return -1;
                    }
                }

                return 0;
            }
        });
        for (T item: list) {
            System.out.println(item);
        }
    }

2. 通过list.sort+ lambda表达式实现排序

	public <T>void debitSort1(List<T> list) {
        list.sort((o1, o2) -> {
            if (o1 instanceof Debit) {
                Debit d1 = (Debit)o1;
                Debit d2 = (Debit)o2;
                if(d1.getQuota() > d2.getQuota()){
                    return 1;
                } else if(d1.getQuota() < d2.getQuota()) {
                    return -1;
                }
            }
            return 0;
        });
        for (T item: list) {
            System.out.println(item);
        }
    }