像我们在C＃linq中一样在Java 8中获取匿名对象

Question

Let's suppose I have a Person class having fields like FirstName, LastName, Age, Salary etc. Now I've this code in C# linq, where persons is a List.

var lstFirstAndLastNamesOnly = persons.Where(x => x.Age > 35).Select(x => new {x.FirstName, x.LastName}).ToList();

This is going to get me an anonymous type having FirstName and LastName. How do I write something like this in Java 8? What could be the better ways so as only a handful of fields are returned when I have say 100 fields on the class.

Answer 1

Well, the Java programming language has anonymous types, but they aren't as useful as in that C# example. Ie, the following would work:

persons.stream().filter(x -> x.age > 35)
    .map(x -> new Object(){ String first=x.firstName, last=x.lastName; })
    .forEach(name -> System.out.println(name.first+" "+name.last));

As you will notice, the declaration of an anonymous type still requires a type specification, which will be the supertype of the anonymous type. Further, you have to formally declare the members holding the data with type and name.

Also, lambda expressions are the only place where you can declare a variable (the parameters) without specifying their type and letting the compiler infer it.

Since the relevant property of an anonymous type is to have no name, you can't declare a variable of that type, when an explicit type is required. And the Java programming language does not have the var name declaration syntax.

You may access it in a fluent context, without a variable, like

System.out.println(
    persons.stream().filter(x -> x.age > 35)
        .map(x -> new Object(){ String a=x.firstName, b=x.lastName; })
        .findFirst().get().a
);

but since this only allows accessing a single member, it's of little use, as, if you only need a single member, you could just map to the member value in the first place.

In this specific example, you could use a two element String array instead:

List<String[]> lstFirstAndLastNamesOnly = persons.stream()
    .filter(x -> x.age > 35)
    .map(x -> new String[] { x.firstName, x.lastName })
    .collect(Collectors.toList());
lstFirstAndLastNamesOnly
    .forEach(name -> System.out.println(name[0]+" "+name[1]));

but, of course, they are no replacement for real tuples, especially when you have heterogeneously typed elements.