java map遍历方式，零基础入门到精通，收藏这篇就够了

一、Map集合遍历日常开发最常使用，简单总结五种方法差异。

①、Iterator+entrySet写法【推荐JDK8以下】，Map.Entry是Map接口的内部接口，获取迭代器，然后依次取出每个迭代器里面的Map.Entry

Iterator<Map.Entry<Integer,String>> iterator=map.entrySet().iterator(); while(iterator.hasNext()){ Map.Entry<Integer,String> entry=iterator1.next(); System.out.println(entry.getKey()); System.out.println(entry.getValue()); }

②、Iterator+keyset写法【不推荐，只能获取key，然后通过key获取对应的value,重复计算】

Iterator<Integer> iterator=map.keySet().iterator(); while (iterator.hasNext()){ Integer key=iterator.next(); System.out.println(key); System.out.println(map.get(key)); }

③、foreach遍历方式【JDK8以下推荐写法】

for(Map.Entry<Integer,String> entry:map.entrySet()){ System.out.println(entry.getKey()); System.out.println(entry.getValue()); };

④：lambda表达式遍历【JDK8推荐写法，简捷】

map.forEach((key,value)->{ System.out.println(key); System.out.println(value); });

⑤：stream流遍历Map【JDK8不推荐写法，重复计算】

map.entrySet().stream().forEach((Map.Entry<Integer, String> entry) -> { System.out.println(entry.getKey()); System.out.println(entry.getValue()); });

如果Map集合存在一些中间处理，可以过滤操作，使用流式遍历也很方便。

附【List和Map删除集合元素】，业务实现里面经常需要清理集合中的指定的对象，这里以List和Map为例介绍一下正常的删除方式。

JDK8以下写法，迭代器会动态感知集合的变化。

List<Integer> list=new ArrayList<>(); list.add(1); list.add(2); list.add(3); list.add(4); list.add(5); Iterator<Integer> integerIterator=list.iterator(); while(integerIterator.hasNext()){ Integer integer=integerIterator.next(); if(integer.equals(5)){ integerIterator.remove(); } } System.out.println(list);

JDK8及以上的写法，新增一个removeIf方法

list.removeIf(key ->key.equals(4));

Map的写法。

JDK1.8一下

Iterator<Map.Entry<String,String>> iterator=map.entrySet().iterator(); while(iterator.hasNext()){ Map.Entry<String, String> entry=iterator.next(); if(entry.getKey().equals("2")){ iterator.remove(); } }

JDK1.8及以上

map.keySet().removeIf(key -> key.equals("3"));

【附录 JAVA的ArrayList的遍历方式】

public static void main(String[] args) { // 1、普通for循环遍历 List<String> list = getList(); for(int i=0;i<list.size();i++){ System.out.println(list.get(i)); } // 2、迭代器遍历 Iterator<String> iterator = list.iterator(); while (iterator.hasNext()){ System.out.println(iterator.next()); } // 3、增强for-each遍历,底层通过迭代器遍历实现,迭代器遍历提供容器统一遍历接口 for(String str:list){ System.out.println(str); } // 4、Lambda遍历 list.stream().forEach(str->{ System.out.println(str); }); // 5、ListIterator迭代,前向迭代 ListIterator<String> listIterator = list.listIterator(); while(listIterator.hasNext()){ System.out.println(listIterator.next()); } // 6、ListIterator迭代,反向迭代 while(listIterator.hasPrevious()){ System.out.println(listIterator.previous()); } } private static List<String> getList() { List<String> list=new ArrayList<>(); list.add("Map"); list.add("HashMap"); list.add("LinkedHashMap"); list.add("TreeMap"); list.add("ConcurrentHashMap"); return list; }

附录：开发中常用的各种类型List集合,util包下

import java.util.Collections;

// 1、空集合,底层自定义一个EmptyList实现,接口空list返回,不像new ArrayList分配不必要的内存空间 Collections.emptyList(); // 2、单值List,底层定义SingletonList,size为1 Collections.singletonList(new Object()); // 3、线程安全的List,底层定义SynchronizedList,方法定义通过synchronized代码实现线程安全,定义了一个SynchronizedCollection Collections.synchronizedList(new ArrayList<>()); // 4、不可变List,不支持修改,定义一个UnmodifiableCollection,UnmodifiableList Collections.unmodifiableList(new ArrayList<>());

List转换Map整理.

/** * 转换Map,保存后者 * @return Map<String,Book> */ private static Map<String,Book> convertOldValueMap(){ List<Book> bookList=new ArrayList<>(); bookList.add(new Book("The King","Tom","1955")); bookList.add(new Book("The King Tail","Jack","1956")); bookList.add(new Book("The King Tail","Bean","1957")); bookList.add(new Book("The King Help","Bean","1957")); // 注意Key值重复时处理,这里是保存旧的值,之前加入的数据 // Function<? super T, ? extends K> keyMapper // Function<? super T, ? extends U> valueMapper->Function.identity() // BinaryOperator<U> mergeFunction return bookList.stream().collect(Collectors.toMap(Book::getReleaseYear, Function.identity(),(oldValue,newValue)->oldValue)); } @Data @AllArgsConstructor @NoArgsConstructor class Book{ private String name; private String author; private String releaseYear; }

①、合并不覆盖旧值.

/** * 转换Map,保存后者 * @return Map<String,Book> */ private static Map<String,Book> convertNewValueMap(){ List<Book> bookList=new ArrayList<>(); bookList.add(new Book("The King","Tom","1955")); bookList.add(new Book("The King Tail","Jack","1956")); bookList.add(new Book("The King Tail","Bean","1957")); bookList.add(new Book("The King Help","Bean","1957")); // 注意Key值重复时处理,这里是保存新的值,也就是后面加入的数据 // Function<? super T, ? extends K> keyMapper // Function<? super T, ? extends U> valueMapper->Function.identity() // BinaryOperator<U> mergeFunction return bookList.stream().collect(Collectors.toMap(Book::getReleaseYear, Function.identity(),(oldValue,newValue)->newValue)); }

②、合并覆盖旧值.

**List对象属性分组过滤**

class UserInfo{ private Long id; private String name; private Integer age; public UserInfo(Long id, String name, Integer age) { this.id = id; this.name = name; this.age = age; } public Long getId() { return id; } public void setId(Long id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } @Override public String toString() { return "UserInfo{" + "id=" + id + ", name='" + name + '\'' + ", age=" + age + '}'; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; UserInfo userInfo = (UserInfo) o; return Objects.equals(id, userInfo.id) && Objects.equals(name, userInfo.name) && Objects.equals(age, userInfo.age); } @Override public int hashCode() { return Objects.hash(id, name, age); } }

List对象去重，记得重写hashcode和equals方法.

List<UserInfo> infoList = userInfoList.stream().distinct().collect(Collectors.toList()); System.out.println(infoList);

List<UserInfo> userInfoList=new ArrayList<>(); userInfoList.add(new UserInfo(1L, "Tom", 23)); userInfoList.add(new UserInfo(2L, "Jack", 24)); userInfoList.add(new UserInfo(3L, "Luck", 25)); userInfoList.add(new UserInfo(4L, "Luck", 26)); // Stream属性分组过滤 Map<String, List<UserInfo>> collect = userInfoList.stream().collect(Collectors.groupingBy(UserInfo::getName)); System.out.println(collect);

传统的Map属性分组

Map<String, List<UserInfo>> result = new HashMap<>(); // 转换 for(UserInfo userInfo:userInfoList){ String name = userInfo.getName(); List<UserInfo> list = result.get(name); if(CollectionUtils.isEmpty(list)){ list = new ArrayList<>(); result.put(name, list); } // 存在直接添加list中即可 list.add(userInfo); }

List<Map<String,Object>>过滤指定的值，返回过滤后的集合。Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)

public static void testObjectMap(){ List<Map<String,Object>> list = new ArrayList<>(); Map<String,Object> mapOne = new HashMap<>(); mapOne.put("key1","value1"); mapOne.put("key2","value2"); mapOne.put("key3","value3"); mapOne.put("key4","value4"); Map<String,Object> mapTwo = new HashMap<>(); mapTwo.put("key1","value1"); mapTwo.put("key2","value2"); mapTwo.put("key3","value3"); mapTwo.put("key4","value4"); Map<String,Object> mapThree = new HashMap<>(); mapThree.put("key1","value1"); mapThree.put("key2","value2"); mapThree.put("key3","value3"); mapThree.put("key4","value4"); list.add(mapOne); list.add(mapTwo); list.add(mapThree); // List的条件过滤 List<Map<String, Object>> collect = list.stream().map (m -> m.entrySet().stream().filter(map -> !map.getKey().equals("key4")).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue))).collect(Collectors.toList()); System.out.println(collect); // Map的条件过滤 Map<String, Object> result = mapThree.entrySet().stream().filter(map -> !map.getKey().equals("key4")).collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); System.out.println(result); } }

Stream流下的map和flapMap使用示例

package com.boot.skywalk.stream; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class FlatMap { public static void main(String[] args) { List<TempOut> result = new ArrayList<>(); TempOut tempOut1 = new TempOut("01", Arrays.asList(new TempEntity("001", "temp1"), new TempEntity("002", "temp1"), new TempEntity("003", "temp1"))); TempOut tempOut2 = new TempOut("02", Arrays.asList(new TempEntity("001", "temp2"), new TempEntity("002", "temp2"), new TempEntity("003", "temp2"))); TempOut tempOut3 = new TempOut("03", Arrays.asList(new TempEntity("001", "temp3"), new TempEntity("002", "temp3"), new TempEntity("003", "temp3"))); result.add(tempOut1); result.add(tempOut2); result.add(tempOut3); // map转换 List<List<TempEntity>> mapResult = result.stream().map(item -> item.getTempEntityList()).collect(Collectors.toList()); // flatMap转换 List<TempEntity> flatMapResult = result.stream().flatMap(item -> item.getTempEntityList().stream()).collect(Collectors.toList()); System.out.println(mapResult); System.out.println(flatMapResult); } } class TempOut { private String id; private List<TempEntity> tempEntityList; public TempOut(String id, List<TempEntity> tempEntityList) { this.id = id; this.tempEntityList = tempEntityList; } public String getId() { return id; } public void setId(String id) { this.id = id; } public List<TempEntity> getTempEntityList() { return tempEntityList; } public void setTempEntityList(List<TempEntity> tempEntityList) { this.tempEntityList = tempEntityList; } @Override public String toString() { return "TempOut{" + "id='" + id + '\'' + ", tempEntityList=" + tempEntityList + '}'; } } class TempEntity { private String id; private String name; public TempEntity(String id, String name) { this.id = id; this.name = name; } public String getId() { return id; } public void setId(String id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } @Override public String toString() { return "TempEntity{" + "id='" + id + '\'' + ", name='" + name + '\'' + '}'; } }

Java开发的就业市场正在经历结构性调整，竞争日益激烈

传统纯业务开发岗位（如仅完成增删改查业务的后端工程师）的需求，特别是入门级岗位，正显著萎缩。随着企业技术需求升级，市场对Java人才的要求已从通用技能转向了更深入的领域经验（如云原生、微服务）或前沿的AI集成能力。这也导致岗位竞争加剧，在一、二线城市，求职者不仅面临技术内卷，还需应对学历与项目经验的高门槛。

大模型为核心的AI领域正展现出前所未有的就业热度与人才红利

2025年，AI相关新发岗位数量同比激增543%，单月增幅最高超过11倍，大模型算法工程师位居热门岗位前列。行业顶尖人才的供需严重失衡，议价能力极强，跳槽薪资涨幅可达30%-50%。值得注意的是，市场并非单纯青睐算法研究员，而是急需能将大模型能力落地于复杂业务系统的工程人才。这使得具备企业级架构思维和复杂系统整合经验的Java工程师，在向“Java+大模型”复合人才转型时拥有独特优势，成为企业竞相争夺的对象，其薪资天花板也远高于传统Java岗位。

说真的，这两年看着身边一个个搞Java、C++、前端、数据、架构的开始卷大模型，挺唏嘘的。大家最开始都是写接口、搞Spring Boot、连数据库、配Redis，稳稳当当过日子。

结果GPT、DeepSeek火了之后，整条线上的人都开始有点慌了，大家都在想：“我是不是要学大模型，不然这饭碗还能保多久？”

先给出最直接的答案：一定要把现有的技术和大模型结合起来，而不是抛弃你们现有技术！掌握AI能力的Java工程师比纯Java岗要吃香的多。

即使现在裁员、降薪、团队解散的比比皆是……但后续的趋势一定是AI应用落地！大模型方向才是实现职业升级、提升薪资待遇的绝佳机遇！