本文详细介绍了Java Stream API的使用，包括过滤、映射、短路操作、去重、排序等，并展示了如何在Employee类中实现自然排序。通过实例展示了如何根据年龄和薪水对员工列表进行排序，同时探讨了字符串比较的Unicode规则。
package com.zs.boot.controller;
public class Employee {
private int id;
private String name;
private int age;
private double salary;
private Status status;
public Employee() {
}
public Employee(String name) {
this.name = name;
}
public Employee(String name, int age) {
this.name = name;
this.age = age;
}
public Employee(int id, String name, int age, double salary) {
this.id = id;
this.name = name;
this.age = age;
this.salary = salary;
}
public Employee(int id, String name, int age, double salary, Status status) {
this.id = id;
this.name = name;
this.age = age;
this.salary = salary;
this.status = status;
}
public Employee(String name, int age, double salary) {
this.name = name;
this.age = age;
this.salary = salary;
}
public Status getStatus() {
return status;
}
public void setStatus(Status status) {
this.status = status;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public String show() {
return "测试方法引用！";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + id;
result = prime * result + ((name == null) ? 0 : name.hashCode());
long temp;
temp = Double.doubleToLongBits(salary);
result = prime * result + (int) (temp ^ (temp >>> 32));
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Employee other = (Employee) obj;
if (age != other.age)
return false;
if (id != other.id)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (Double.doubleToLongBits(salary) != Double.doubleToLongBits(other.salary))
return false;
return true;
}
@Override
public String toString() {
return "Employee [id=" + id + ", name=" + name + ", age=" + age + ", salary=" + salary + ", status=" + status
+ "]";
}
public enum Status {
FREE, BUSY, VOCATION;
}
}
package com.zs.boot.controller;
import org.junit.Test;
import java.util.*;
import java.util.stream.Stream;
public class TestStream2API {
List<Employee> employees = Arrays.asList(
new Employee("刘德华",48,8000),
new Employee("张学友",28,8500),
new Employee("黎明",45,6500),
new Employee("黎明",45,6500),
new Employee("郭富城",51,5500));
//过滤出年龄大于35
//内部迭代：迭代操作由StreamAPI完成
@Test
public void test1(){
//中间操作，不会执行任何操作
Stream<Employee> s = employees.stream().filter(e -> e.getAge()>35);
/*
s.forEach(System.out::println);这样写会打印对象所有信息，不会只打印姓名，而我只打印姓名
可以参考这样写Stream<String> namesStream = employees.stream().map(Employee::getName);
Stream<String> namesStream = s.map(employees -> employees.getName());//用Employee::getName更简洁
namesStream.forEach(System.out::println);
即：
employees.stream().filter(e -> e.getAge()>35).map(Employee::getName).forEach(System.out::println);
*/
//中间操作后必须加终止操作才执行
s.forEach((str) -> System.out.println(str.getName()));
/*
刘德华
黎明
郭富城
*/
}
//外部迭代
@Test
public void test2(){
Iterator<Employee> it = employees.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
}
@Test
public void test3(){
/*Employee [id=0, name=刘德华, age=48, salary=8000.0, status=null]
Employee [id=0, name=张学友, age=28, salary=8500.0, status=null]
Employee [id=0, name=黎明, age=45, salary=6500.0, status=null]*/
employees.stream().filter(e -> e.getSalary()>6000).limit(3).forEach(System.out::println);
System.out.println("------------------------------------------------------");
/*短路！
Employee [id=0, name=刘德华, age=48, salary=8000.0, status=null]
短路！
Employee [id=0, name=张学友, age=28, salary=8500.0, status=null]*/
//找到满足条件的两条数据后，后续的迭代操作就不再进行了
employees.stream().filter(e -> {
System.out.println("短路！");
return e.getSalary()>6000;
}).limit(2).forEach(System.out::println);
}
/*Employee [id=0, name=黎明, age=45, salary=6500.0, status=null]*/
//跳过前两个
@Test
public void test4(){
employees.stream().filter(e -> e.getSalary()>6000).skip(2).forEach(System.out::println);
}
/*Employee [id=0, name=刘德华, age=48, salary=8000.0, status=null]
Employee [id=0, name=张学友, age=28, salary=8500.0, status=null]
Employee [id=0, name=黎明, age=45, salary=6500.0, status=null]*/
//去重，注意要去实体类中重写hashcode和equals
@Test
public void test5(){
employees.stream().filter(e -> e.getSalary()>6000).distinct().forEach(System.out::println);
}
//==================================================================================
/*
AA
BB
CC
DD
*/
@Test
public void test6(){
List<String> list = Arrays.asList("aa","bb","cc","dd");
list.stream().map(str -> str.toUpperCase(Locale.ROOT)).forEach(System.out::println);
System.out.println("----------------------------");
//取出员工姓名
employees.stream().map(e -> e.getName()).forEach(System.out::println);
//等效写法
employees.stream().map(Employee::getName).forEach(System.out::println);
System.out.println("----------------------------");
/*a
a
b
b
c
c
d
d*/
//Stream<Stream<Character>> stream = list.stream().map(s ->filterCharacter(s));
//等效写法
Stream<Stream<Character>> stream = list.stream().map(TestStream2API::filterCharacter);
stream.forEach(sm -> sm.forEach(
System.out::println
));
System.out.println("----------------------------");
/*a
a
b
b
c
c
d
d*/
Stream<Character> stream1 = list.stream().flatMap(TestStream2API::filterCharacter);
stream1.forEach(
System.out::println
);
}
public static Stream<Character> filterCharacter(String str){
List<Character> list = new ArrayList<>();
for (Character ch: str.toCharArray()) {
list.add(ch);
}
return list.stream();
}
//==================================================================================
/**
* 排序
* sorted()------自然排序Comparable
* sorted(Comparator com)------定制排序Comparator
*/
@Test
public void test7(){
List<String> list = Arrays.asList("cc","aa","dd","bb");
list.stream().sorted().forEach(System.out::println);
System.out.println("----------------------------");
//定制排序
employees.stream().sorted((e1,e2) -> {
if (String.valueOf(e1.getAge()).equals(e2.getAge())){
return e1.getName().compareTo(e2.getName());
}else{
//废弃return String.valueOf(e1.getAge()).compareTo(String.valueOf(e2.getAge()));
//age是int类型，还是用Integer
return Integer.valueOf(e1.getAge()).compareTo(Integer.valueOf(e2.getAge()));
//如果要年龄从大到小排序
//return -String.valueOf(e1.getAge()).compareTo(String.valueOf(e2.getAge()));
}
}).forEach(System.out::println);
//不用lambda，用过去传统的写法也可以
/*employees.stream().sorted(new Comparator<Employee>() {
@Override
public int compare(Employee e1, Employee e2) {
if(String.valueOf(e1.getAge()).equals(e2.getAge())){
return e1.getName().compareTo(e2.getName());
}else{
return String.valueOf(e1.getAge()).compareTo(String.valueOf(e2.getAge()));
}
}
}
).forEach(System.out::println);*/
/*Employee [id=0, name=张学友, age=28, salary=8500.0, status=null]
Employee [id=0, name=黎明, age=45, salary=6500.0, status=null]
Employee [id=0, name=黎明, age=45, salary=6500.0, status=null]
Employee [id=0, name=刘德华, age=48, salary=8000.0, status=null]
Employee [id=0, name=郭富城, age=51, salary=5500.0, status=null]*/
}
}
拓展：
如果Employee implements Comparable<Employee>
重写了compareTo方法，那就可以直接自然排序了
employees.stream().sorted().forEach(System.out::println);
package com.zs.boot.controller;
public class Employee implements Comparable<Employee>{
private int id;
private String name;
private int age;
private double salary;
private Status status;
public Employee() {
}
public Employee(String name) {
this.name = name;
}
public Employee(String name, int age) {
this.name = name;
this.age = age;
}
public Employee(int id, String name, int age, double salary) {
this.id = id;
this.name = name;
this.age = age;
this.salary = salary;
}
public Employee(String name, int age, double salary, Status status) {
this.name = name;
this.age = age;
this.salary = salary;
this.status = status;
}
public Employee(String name, int age, double salary) {
this.name = name;
this.age = age;
this.salary = salary;
}
public Status getStatus() {
return status;
}
public void setStatus(Status status) {
this.status = status;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public String show() {
return "测试方法引用！";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + age;
result = prime * result + id;
result = prime * result + ((name == null) ? 0 : name.hashCode());
long temp;
temp = Double.doubleToLongBits(salary);
result = prime * result + (int) (temp ^ (temp >>> 32));
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Employee other = (Employee) obj;
if (age != other.age)
return false;
if (id != other.id)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (Double.doubleToLongBits(salary) != Double.doubleToLongBits(other.salary))
return false;
return true;
}
@Override
public String toString() {
return "Employee [id=" + id + ", name=" + name + ", age=" + age + ", salary=" + salary + ", status=" + status
+ "]";
}
/*
重写compareTo()方法是实现Comparable接口的使用（自然排序）规则：
如果当前对象this大于形参对象obj，则返回正整数，
如果当前对象this小于形参对象obj,则返回负整数,
如果当前对象this等于形参对象obj,则返回零。*/
//重写compareTo
@Override
public int compareTo(Employee o) {
/*if(String.valueOf(this.getAge()).equals(o.getAge())){
return this.getName().compareTo(o.getName());
}else{
//age是int,以后都改用Integer.compareTo
//废弃return String.valueOf(this.getAge()).compareTo(String.valueOf(o.getAge()));
return Integer.valueOf(this.getAge()).compareTo(Integer.valueOf(o.getAge()));
}*/
//这种写法和上面等效
if(this.getAge() > o.getAge()){
return 1;
}else if(this.getAge() < o.getAge()){
return -1;
}else{//如果年龄相等，比较姓名
return this.getName().compareTo(o.getName());
}
}
/*参考例子
public int compareTo(Person p) {
if(this.score>p.getScore()) {
return 1;
}else if(this.score<p.getScore()) {
return -1;
}else {//分数一样比较年龄
if(this.age>p.getAge()) {
return 1;
}else if(this.age<p.getAge()) {
return -1;
}else {//年龄一样，比较姓名
return this.name.compareTo(p.getName());
}
}
}*/
public enum Status {
FREE, BUSY, VOCATION;
}
}
package com.zs.boot.controller;
import org.junit.Test;
import java.util.*;
import java.util.stream.Stream;
public class TestStream2API {
List<Employee> employees = Arrays.asList(
new Employee("刘德华",48,8000),
new Employee("张学友",28,8500),
new Employee("黎明",45,6500),
new Employee("黎明",45,6500),
new Employee("郭富城",51,5500));
/**
* 排序
* sorted()------自然排序Comparable
* sorted(Comparator com)------定制排序Comparator
*/
@Test
public void test7(){
/*如果Employee implements Comparable<Employee>
重写了compareTo方法，可以直接employees.stream().sorted().forEach(System.out::println);*/
/*
@Override
public int compareTo(Employee o) {
if(String.valueOf(this.getAge()).equals(o.getAge())){
return this.getName().compareTo(o.getName());
}else{
//age是int,用Integer.compareTo
return String.valueOf(this.getAge()).compareTo(String.valueOf(o.getAge()));
}
}
*/
/*Employee [id=0, name=张学友, age=28, salary=8500.0, status=null]
Employee [id=0, name=黎明, age=45, salary=6500.0, status=null]
Employee [id=0, name=黎明, age=45, salary=6500.0, status=null]
Employee [id=0, name=刘德华, age=48, salary=8000.0, status=null]
Employee [id=0, name=郭富城, age=51, salary=5500.0, status=null]*/
employees.stream().sorted().forEach(System.out::println);
/*
28
45
48
51
*/
Stream list = employees.stream().sorted().map(Employee::getAge);
list.forEach(System.out::println);
}
}
关于中文字符串是怎么比较大小的？
中文是按照Unicode编码比较的
/**
* 字符串比较案例
*/
public class StringComparisonDemo {
public static void main(String[] args) {
String foo = "ABC";
// 前面和后面每个字符完全一样，返回 0
String bar01 = "ABC";
System.out.println(foo.compareTo(bar01));
// 前面每个字符完全一样，返回：后面就是字符串长度差
String bar02 = "ABCD";
String bar03 = "ABCDE";
System.out.println(foo.compareTo(bar02)); // -1 (前面相等,foo 长度小 1)
System.out.println(foo.compareTo(bar03)); // -2 (前面相等,foo 长度小 2)
// 前面每个字符不完全一样，返回：出现不一样的字符 ASCII 差
String bar04 = "ABD";
String bar05 = "aABCD";
System.out.println(foo.compareTo(bar04)); // -1 (foo 的 'C' 字符 ASCII 码值为 67，bar04 的 'D' 字符 ASCII 码值为 68。返回 67 - 68 = -1)
System.out.println(foo.compareTo(bar05)); // -32 (foo 的 'A' 字符 ASCII 码值为 65，bar04 的 'a' 字符 ASCII 码值为 97。返回 65 - 97 = -32)
String bysocket01 = "泥瓦匠";
String bysocket02 = "瓦匠";
System.out.println(bysocket01.compareTo(bysocket02));// -2049 （泥 和 瓦的 Unicode 差值）
}
}
原文链接：https://blog.youkuaiyun.com/weixin_41922289/article/details/90463971拓展：age是int类型，以后都改用
Integer.valueOf(e1.getAge()).compareTo(Integer.valueOf(e2.getAge()));
不要使用String.valueOf(this.getAge()).compareTo(String.valueOf(o.getAge()));
employees.stream().sorted( (e1,e2) -> {
//方法1：
/*int ageValue = Integer.compare(e1.getAge(),e2.getAge());
if(ageValue != 0){
return ageValue;
}else{
//按照薪水从小到大
return Double.compare(e1.getSalary(),e2.getSalary());
//按照薪水从大到小
//return -Double.compare(e1.getSalary(),e2.getSalary());
}*/
//方法2：用大于>，小于<
/*if(e1.getAge() > e2.getAge()){
return 1;
}else if(e1.getAge() < e2.getAge()){
return -1;
}else{//按照薪水从小到大
return Double.compare(e1.getSalary(),e2.getSalary());
}*/
//方法3：
//等效代码
if(String.valueOf(e1.getAge()).equals(String.valueOf(e2.getAge()))){
return Double.compare(e1.getSalary(),e2.getSalary());
}else{
//return Integer.compare(e1.getAge(),e2.getAge());
//或者用compareTo，点进去看源码，也就是调用上面的Integer.compare
/*public int compareTo(Integer anotherInteger) {
return compare(this.value, anotherInteger.value);
}
public static int compare(int x, int y) {
return (x < y) ? -1 : ((x == y) ? 0 : 1);
}*/
return Integer.valueOf(e1.getAge()).compareTo(Integer.valueOf(e2.getAge()));
}
}).forEach(System.out::println);java.lang.String.compareTo() 方法比较两个字符串的字典。比较是基于字符串中的每个字符的Unicode值。此String对象表示的字符序列的参数字符串表示的字符序列进行比较字典. 其结果是负的整数，如果此String对象字典前面的参数字符串 其结果是一个正整数，如果此String对象字典如下的参数字符串 结果是零，如果两个字符串相等，CompareTo返回0时，equal（Object）方法将返回true。
java.lang.Integer.compareTo() 方法比较两个Integer对象的数字. 此方法如果这个整数是相等于的参数整数返回的值为0，如果这个整数数值小于参数整数则返回小于0的值，如果这个整数数值大于该参数的整数返回一个大于0的值.
扫一扫
5482
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
