标签: java-8

我正在编写一个Rest服务（HTTP Get端点），在下面的uri中执行以下操作

http://localhost:8080/customers/{customer_id}

1. 获取在uri中传递的customer_id的详细信息
2. 如果没有传递customer_id（http：// localhost：8080 / customers），则获取所有客户详细信息。

码：

@RequestMapping(method = RequestMethod.GET, value = "customers/{customer_id}")
public List<Customer> getCustomers(
@PathVariable(name = "customer_id", required = false) final String customerId) {
LOGGER.debug("customer_id {} received for getCustomers request", customerId);

}

但是，使用上面的代码，第二种情况下，控件流向getCustomers（）。

注意：我使用的是Java8和spring-web 4.3.10版本

非常感谢对此的任何帮助。

注意:我不一定在寻找下面描述的具体示例问题的解决方案.我真的很感兴趣为什么在Java 8中不可能开箱即用.

Java流是懒惰的.最后他们有一个终端操作.
我的解释是这个终端操作将通过流提取所有值.没有任何中间操作可以做到这一点.为什么没有中间操作通过流引入任意数量的元素？像这样的东西:

stream
    .mapMultiple(this::consumeMultipleElements) // or groupAndMap or combine or intermediateCollect or reverseFlatMap
    .collect(Collectors.toList());

当下游操作尝试使流一次前进时,中间操作可能尝试多次上行(或根本不上行).

我会看到几个用例:(
这些只是示例.所以你可以看到它确实可以处理这些用例,但它不是"流式传输方式",而且这些解决方案缺乏Streams所具有的理想的懒惰属性. )

• 将多个元素组合到一个新元素中,以传递到流的其余部分.(例如,成对(1,2,3,4,5,6) ? ((1,2),(3,4),(5,6)))

  // Something like this,
  // without needing to consume the entire stream upfront,
  // and also more generic. (The combiner should decide for itself how many elements to consume/combine per resulting element. Maybe the combiner is a Consumer<Iterator<E>> or a Consumer<Supplier<E>>)
  public <E, R> Stream<R> combine(Stream<E> stream, BiFunction<E, E, R> combiner) {
      List<E> completeList …

  Run Code Online (Sandbox Code Playgroud)

我有一个class(Say FOO),它有一个具有default可见性的方法,如下所示:

void sayHi() {}

现在,如果在扩展类I时覆盖此方法无法降低其可见性.所以我只能使用default或public.

public class MyClassTest extends FOO {
    @Override
    // Or I can use public void sayHi()
    void sayHi() {
        System.out.println("Overriden sayHi");
    }
}

现在,如果我使用下面的默认方法在Java 8中编写接口:

public interface InterfaceX {

    // Java-8 defalu method
    default String printName() {
        System.out.println("Interface1 default metod");
        return "Interface1 default metod";
    }
}

现在,如果我在类中重写此方法它应该编译,如果保持重写方法的可见性default.

public class Java8InterfaceTest implements InterfaceX{
    @Override
     void printHello() {
        System.out.println("Printing..!");
        Interface1.super.printName();
    }
 }

它说

无法从InterfaceX降低继承方法的可见性

我已经知道,在每一个方法interface …

我即将从字符串创建二维数组:

char[][] chars;
String alphabet = "abcdefghijklmnopqrstuvwxyz";

所以数组将说明这个矩阵:

但是我怎么能用Java 8 Streams做到这一点,因为我不想通过休闲循环来做到这一点？

我正在玩java lambdas,这是我目前的代码:

public class TypeChecker<T> {
    private T value;
    private Class clazz;
    private UnaryOperator<T> callback;

    private TypeChecker(T value) {
        this.value = value;
    }

    public static TypeChecker<String> when(String v) {
        return new TypeChecker<>(v);
    }

    public static TypeChecker<Integer> when(int v) {
        return new TypeChecker<>(v);
    }

    public TypeChecker<T> is(Class clazz) {
        this.clazz = clazz;
        return this;
    }

    public TypeChecker<T> then(UnaryOperator<T> callback) {
        this.callback = callback;
        return this;
    }

    public void execute() {
        if (clazz.isInstance(value)) {
            callback.apply(value);
        }
    }
}

TypeChecker.when("123").is(String.class).then(s -> {
    return …

我有以下代码:

public boolean foo(List<JSONObject> source, String bar, String baz) {
    List<String> myList = newArrayList();

    source.forEach(json -> {
        if (!(json.get(bar) instanceof JSONObject)) {
            myList.add(json.get(bar).toString());
        } else {
            myList.add(json.getJSONObject(attribute).get("key").toString());
        }
    });

    /**
     * do something with myList and baz
     */
}

我只是想知道是否有办法if-else使用过滤器进行内联条件.

有点像:

List<String> myList = source.stream()
                .filter(json -> !(json.get(bar) instanceof JSONObject))
                .map(item -> item.get(attribute).toString())
                .collect(Collectors.toList());

如果我按照上面的方法进行,我将错过应该是"其他"的条件.如何使用更多java-8方式实现我想要的目标？

提前致谢!

我最近开始使用collectAndThen,发现与其他编码程序相比,它需要花费相当长的时间,我用它来执行类似的任务.

这是我的代码:

        System.out.println("CollectingAndThen");
        Long t = System.currentTimeMillis();
        String personWithMaxAge = persons.stream()
                                        .collect(Collectors.collectingAndThen(
                                                                Collectors.maxBy(Comparator.comparing(Person::getAge)),
                                                                (Optional<Person> p) -> p.isPresent() ? p.get().getName() : "none"
                                                ));


        System.out.println("personWithMaxAge - "+personWithMaxAge + " time taken = "+(System.currentTimeMillis() - t));
        Long t2 = System.currentTimeMillis();
        String personWithMaxAge2 = persons.stream().sorted(Comparator.comparing(Person::getAge).reversed())
                                                    .findFirst().get().name;
        System.out.println("personWithMaxAge2 : "+personWithMaxAge2+ " time taken = "+(System.currentTimeMillis() - t2));

在这里输出:

CollectingAndThen
personWithMaxAge - Peter time taken = 17
personWithMaxAge2 : Peter time taken = 1

这表明收集和收集时间相对较长.

所以我的问题是 - 我应该继续收集和其他建议吗？

上下文:我有一个Web服务,它返回一个带有menbers的家庭.一个家庭将永远有一个父亲和一个母亲,没有孩子或多个孩子.该服务在下面由wsdl描述.

目的:我想有效地使用Java 8中的Optional,并避免使用经典方法来检查null.经典,我的意思是我们习惯于在Java 7之前完成的方式.

如果我假设webservice将始终返回一个家庭,这就足够了:

@Test
public void test1() {
    Family f = helloWorldClientImplBean.allFamily();

    f.getChildren().stream().filter(x -> x.getFirstName().equalsIgnoreCase("John")).findFirst()
            .ifPresent(y -> System.out.println(y.getLastName()));
}

我测试了,我可以看到,只要我得到一个家庭通过服务回答,如果我有孩子,这将完全无关紧要.我的意思是,在下面的服务实现中,如果我评论了oldSon和youngSon代码,那么根本就没有null异常.

当服务返回null时,问题会引发.

在阅读了几篇博客并讨论了它之后,我得到了这个代码,它正确地检查了服务的返回是否为空.

@Test
public void testWorkingButSeemsOdd() {

    //Family f = helloWorldClientImplBean.allFamily();
    Family f = null; //to make simple the explanation

    Optional<Family> optFamily = Optional.ofNullable(f);

    if (optFamily.isPresent()) {

        optFamily.filter(Objects::nonNull).map(Family::getChildren).get().stream().filter(Objects::nonNull)
                .filter(x -> x.getFirstName().equalsIgnoreCase("John")).findFirst()
                .ifPresent(y -> System.out.println("Optional: " + y.getLastName()));

    }

对我来说更干净的是这些方法中的一种(所有这些方法都令人费解,但我相信它们可以展示我一直在尝试做的事情):

//这里我尝试在映射之前过滤f是否为null

@Test
public void testFilterNonNull() {
    Family f = null;
    Optional.ofNullable(f).filter(Objects::nonNull).map(Family::getChildren).get().stream().filter(Objects::nonNull)
            .filter(x -> x.getFirstName().equalsIgnoreCase("John")).findFirst()
            .ifPresent(y -> System.out.println(y.getLastName()));

}

我知道下一个没有编译,但我想有可能达到类似的东西 …

我有这段代码,我想返回一个postCodes列表:

List<String> postcodes = new ArrayList<>();
List<Entry> entries = x.getEntry(); //getEntry() returns a list of Entry class
for (Entry entry : entries) {
    if (entry != null) {
       Properties properties = entry.getContent().getProperties();
       postcodes.addAll(Arrays.asList(properties.getPostcodes().split(",")));
   }
} 
return postcodes;

这是我尝试使用stream()方法和以下链式方法:

...some other block of code
List<Entry> entries = x.getEntry.stream()
    .filter(entry -> recordEntry != null)
    .flatMap(entry -> {
        Properties properties = recordEntry.getContent().getProperties();
        postCodes.addAll(Arrays.asList(properties.getPostcodes().split(",")));
});

我正在使用lambda表达式.相当于这个:

for (Integer id: ids) {
    if (!repository.exists(id)) {
        throw new Exception .....
    }
}

我试过用这个:

ids.stream().filter(id-> repository.exists(idStatut)).findAny().orElseThrow(() ->
                new Exception...
            );

但它效果不好