자바 8 구현 stream 대상 집합 list 에서 추출 속성 집합 을 map 또는 list 로 전환

우선 실체 클래스 Person 을 새로 만 듭 니 다.

@Data
public class Person {
 /**    */
 private String code;
 /**    */
 private String name;
 public Person(String code, String name) {
  this.code = code;
  this.name = name;
 }
}

세 개의 대상 을 실례 화하 여 list 집합 에 넣다

public static void main(String[] args) {
 Person person1 = new Person("001", "  ");
 Person person2 = new Person("002", "  ");
 Person person3 = new Person("002", "  ");
 List<Person> personList = new ArrayList<>();
 personList.add(person1);
 personList.add(person2);
 personList.add(person3);
 personList.forEach(t -> System.out.println(t.toString()));
}

출력 결 과 는:
Person(code=001,name=장삼)
Person(code=002,name=이사)
Person(code=002,name=왕 오)
1.추출 대상 의 code 를 key 로 하고 name 을 value 로 map 집합 으로 전환 합 니 다.
방법

private static HashMap<String, String> listToMap(List<Person> personList) {
 return (HashMap<String, String>)personList.stream()
   .filter(t -> t.getName()!=null)
   .collect(Collectors.toMap(Person::getCode,Person::getName,(k1,k2)->k2));
}

filter()방법 은 이름 이 비어 있 는 대상 을 걸 러 내 는 것 입 니 다.대상 의 이름 이 null 일 때 NPE 빈 포인터 이상 이 발생 합 니 다.
(k1,k2)->k2 는 같은 키 를 만 났 을 때 두 번 째 값 을 취한 다 는 뜻
(k1,k2)->k1 은 같은 키 를 만 났 을 때 첫 번 째 값 을 취한 다 는 뜻
이 방법 을 호출 하 다

HashMap<String,String> personMap = listToMap(personList);
personMap.forEach((k,v)-> System.out.println(k.toString() + " - " + v.toString()));

출력 결 과 는:
001-장삼
002-왕 오
2.대상 의 name 을 추출 하여 name 의 list 집합 을 가 져 옵 니 다.
방법

private static List<String> getNameList(List<Person> personList) {
 return personList.stream().map(Person::getName).collect(Collectors.toList());
}

이 방법 을 호출 하 다

List<String> nameList = getNameList(personList);
nameList.forEach(t -> System.out.println(t.toString()));

출력 결 과 는:
장삼
이사
왕 오
보충:자바 8 은 stream 을 사용 하여 List 를 맵 으로 바 꾸 거나 List 대상 에서 하나의 속성 List 를 가 져 옵 니 다.List 는 한 필드 에 따라 정렬 합 니 다.
1.학생 류

import lombok.Data; 
@Data
public class Student{ 
 private String stuId; 
 private String name; 
 private String age; 
 private String sex; 
}

2.테스트 클래스

public class Test {
 public static void main(String[] args) {
 
  //     List
  List<Student> list = createStudentList();
 
  // 1.  value Student  ，key   ID Map
  getStudentObjectMap(list);
 
  // 2.  value     ，key   ID Map
  getStudentNameMap(list);
 
  // 3.      List
  getStudentNameList(list);
 
  //4.List     id = 1   
 
  list.removeIf(student -> student.getStuId().equals(1));
 
  //5.  StudentId Long     ？
 
  Map<String, String> mapStr = list.stream().collect(Collectors.toMap(student -> student.getStuId().toString(), student -> JSON.toJSONString(student)));
 
  //6.  List Student       
  Collections.sort(list, (o1, o2) -> {
   if (o1.getName().compareTo(o2.getName()) > 0) {
    return 1;
   } else if (o1.getName().compareTo(o2.getName()) < 0) {
    return -1;
   } else {
    return 0;
   }
  });
  //7.List  
  List<String> listStr = new ArrayList<>(); 
  List<Student> listStu = new ArrayList<>(); 
  listStr.forEach(studentStr -> { 
   listStu.add(JSON.parseObject(studentStr, Student.class));
 
  });
 
  //List        、  
  listStu.stream()
    .filter(student -> student.getSex().equals(" "))
    .sorted(Comparator.comparing(Student::getName))
    .collect(Collectors.toList());
 
  //List        
  Map<String,List<Student>> sexGroupMap = listStu.stream()
              .collect(Collectors.groupingBy(Student::getSex));
  //  Map       ， studentId     
  Map<String,String> studentNameIdMap = listStu.stream()
              .collect(toMap(Student::getName,Student::getStuId,(s,a)->s+","+a));
 }
 
 public static List<Student> createStudentList() {
  List<Student> list = new ArrayList<Student>();
  Student lily = new Student();
  lily.setStuId("1");
  lily.setName("lily");
  lily.setAge("14");
  lily.setSex(" ");
  Student xiaoming = new Student();
  xiaoming.setStuId("2");
  xiaoming.setName("xiaoming");
  xiaoming.setAge("15");
  xiaoming.setSex(" ");
  list.add(lily);
  list.add(xiaoming);
  return list;
 }
 
 public static Map<Object, Object> getStudentObjectMap(List<Student> list) {
  Map<Object, Object> map = list.stream().collect(Collectors.toMap(Student::getStuId, student -> student));
  map.forEach((key, value) -> {
   System.out.println("key:" + key + ",value:" + value);
  });
  return map;
 }
 
 public static Map<String, String> getStudentNameMap(List<Student> list) {
  Map<String, String> map = list.stream().collect(Collectors.toMap(Student::getStuId, Student::getName));
  map.forEach((key, value) -> {
   System.out.println("key:" + key + ",value:" + value);
  });
  return map;
 }
 
 public static List<String> getStudentNameList(List<Student> list) {
  List<String> result = list.stream().map(student -> student.getName()).collect(Collectors.toList());
  for (String name : result) {
   System.out.println("name:" + name);
  }
  return result;
 }
}

이상 은 개인 적 인 경험 이 므 로 여러분 에 게 참고 가 되 기 를 바 랍 니 다.여러분 들 도 저 희 를 많이 응원 해 주시 기 바 랍 니 다.만약 잘못 이 있 거나 완전히 고려 하지 않 은 부분 이 있다 면 아낌없이 가르침 을 주시 기 바 랍 니 다.