排序

  1. // 数组
  2. Integer[] nums = { 3, 1, 4, 5, 8, 3, 2 };
  3. // 使用Arrays.sort方法，默认大小顺序排序，打印：[1, 2, 3, 3, 4, 5, 8]
  4. Arrays.sort(nums);
  5. // 使用Collections.reverseOrder方法，按照大小逆序排序，打印：[8, 5, 4, 3, 3, 2, 1]
  6. Arrays.sort(nums, Collections.reverseOrder());
  7. // 自定义顺序（用lambda表达式表示函数时间接口Comparator，实现compare方法），打印：[8, 5, 4, 3, 3, 2, 1]
  8. Arrays.sort(nums, (x, y) -> y - x);
  10. String[] strs = { "a", "bc", "zef", "knc", "bac", "jklh" };
  11. // 使用Arrays.sort方法，按照字母顺序排序，打印：[a, bac, bc, jklh, knc, zef]
  12. Arrays.sort(strs);
  13. // 使用Collections.reverseOrder方法，按照字母逆序排序，打印：[zef, knc, jklh, bc, bac, a]
  14. Arrays.sort(strs, Collections.reverseOrder()); 
  15. // 自定义顺序（用lambda表达式表示函数式接口Comparator，实现compare方法），打印：[jklh, bac, knc, zef, bc, a]
  16. Arrays.sort(strs, (x, y) -> y.length() - x.length());
  18. Dog[] dogs = new Dog[2];
  19. dogs[0] = new Dog("James", 150.0, "Kan", 1);
  20. dogs[1] = new Dog("kans", 140.0, "crash", 1);
  21. // 根据狗主人名字的长度，进行倒序排序（数组对象示例）
  22. Arrays.sort(dogs, (x, y) -> y.getMasterName().length() - x.getMasterName().length());
  24. // SmallDog实现了Comparable类，实现方法默认为根据值顺序
  25. SmallDog[] dogs = { new SmallDog(1), new SmallDog(3), new SmallDog(2) };
  26. // 打印：[SmallDog[age=1], SmallDog[age=3], SmallDog[age=2]]
  27. System.out.println(Arrays.toString(dogs));
  28. // 打印：[SmallDog[age=1], SmallDog[age=2], SmallDog[age=3]]
  29. Arrays.sort(dogs);
  30. // 打印：[SmallDog[age=3], SmallDog[age=2], SmallDog[age=1]]
  31. Arrays.sort(dogs, (x, y) -> Integer.compare(y.getAge(), x.getAge()));
  33. // 数组对象列表
  34. List<SmallDog> dogs1 = new ArrayList<>();
  35. dogs1.add(dogs[0]);
  36. dogs1.add(dogs[1]);
  37. dogs1.add(dogs[2]);
  39. // 直接使用Collections.sort方法（前提是SmallDog类实现了Comparable接口）
  40. // 打印：[SmallDog[age=1], SmallDog[age=2], SmallDog[age=3]]
  41. Collections.sort(dogs1);
  42. // 打印：[SmallDog[age=3], SmallDog[age=2], SmallDog[age=1]]
  43. Collections.sort(dogs1, (x, y) -> Integer.compare(y.getAge(), x.getAge()));

过滤

  1. /**
  2.  * 根据SmallDog对象中的age值进行过滤
  3.  */
  5. // 数组
  6. List<SmallDog> filters1 = new ArrayList<>();
  7. for (SmallDog item : dogs) {
  8.     if (item.getAge() == 2) {
  9.         filters1.add(item);
  10.     }
  11. }
  12. // 打印：[SmallDog[age=2]]
  13. System.out.println(filters1);
  15. // 数组列表
  16. List<SmallDog> filters2 = dogs1.stream()
  17.         .filter(x -> x.getAge() == 1)
  18.         .collect(Collectors.toList());
  19. // 打印：[SmallDog[age=1]]
  20. System.out.println(filters2);

批量处理

  1. for (SmallDog item : dogs) {
  2.     item.setName("DD" + item.getAge());
  3. }
  4. // 打印：SmallDog[name=DD1,age=1]]
  5. System.out.println(Arrays.toString(dogs));
  7. dogs1.stream().forEach(item -> {
  8.     item.setName("DD" + item.getAge());
  9. });
  10. // 打印：[SmallDog[name=DD3,age=3], SmallDog[DD2,age=2], SmallDog[name=DD1,age=1]]
  11. System.out.println(dogs1);

聚合返回数据

  1. String[] namesStr = new String[dogs.length()];
  2. List<String> names = new ArrayList<>();
  3. for (int i = 0; i < dogs.length(); i++) {
  4.     namesStr[i] = dogs[i].getName();
  5.     names.add(dogs[i].getName());
  6. }
  8. List<String> names1 = dogs1.stream()
  9.         .map(item -> item.getName())
  10.         .collect(Collectors.toList());