小编Tag*_*eev的帖子

说我有以下代码

data.stream()
    .map(x -> {
        Object a = maybeReturnsNull(x);
        return a == null ? defaultValue : a;
    })

我有一些可能正在返回的函数,null我将它应用于流的一个元素.然后我想确保将任何null结果更改为某个默认值.与使用上一个定义辅助变量a并在lambda表达式中使用代码块的示例相比,使用两个映射(如下例)之间是否存在任何显着差异？

data.stream()
    .map(x -> maybeReturnsNull(x))
    .map(x -> x == null ? defaultValue : x)

有没有标准在哪里或不避免使用lambda函数的块语句？

我正在阅读J. Bloch的有效Java,现在我在数组与列表部分.以下是他提供的未经检查的演员的示例:

interface Function<T> {
    T apply(T arg1, T arg2);
}

public class Main{
    public static void main( String[] args ){
        Function<String> f = null;
        List<String> str = Arrays.asList("asd");
        //staff
        reduce(str, f, ""); //E's deduced to String. Where is type-unsafe?
    }
    static <E> E reduce(List<E> list, Function<E> f, E initVal) {
        E[] snapshot = (E[]) list.toArray(); // Unchecked cast
        E result = initVal;
        for (E e : snapshot)
            result = f.apply(result, e);
        return result;  
    }
}

他说这种方法不是类型安全的,我们可以轻松搞定ClassCastException.但我不知道怎么做.哪里是类型不安全的,类型变量E …

我是lambda表达的新手,并试图在我的任务中使用它.

问题:

我有两个地图m1和m2类型Map<Integer, String>,必须合并到一个地图中 Map<Integer, List<String>>,其中两个地图中相同键的值被收集到一个列表中并放入一个新的地图中.

基于我探索的解决方案:

Map<Integer, List<String>> collated = 
                Stream.concat(m1.entrySet().stream(), m2.entrySet().stream()).collect(
                        Collectors.toMap(Entry::getKey,
                                Entry::getValue, (a, b) -> {
                                    List<String> merged = new ArrayList<String>(a);
                                    merged.addAll(b);
                                    return merged;
                                }));

但是,这种解决方案预计源List是Map<Integer, List<String>>如在toMap合并函数需要操作数和结果是相同的类型.

我不想更改源集合.请提供您使用lambda表达式实现此目的的输入.

我正在阅读有关ArrayListJava 如何发展的文档.我不明白为什么该hugeCapacity(int minCapacity)方法选择返回Integer.MAX_VALUE或MAX_ARRAY_SIZE.

从MAX_ARRAY_SIZE课堂上的定义来看,

244 |     private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

Integer.MAX_VALUE除了一个整数(32 bits)的大小外几乎相同.

264 |     private static int hugeCapacity(int minCapacity) {
265 |         if (minCapacity < 0) // overflow
266 |             throw new OutOfMemoryError();
267 |         return (minCapacity > MAX_ARRAY_SIZE) ?
268 |             Integer.MAX_VALUE :
269 |             MAX_ARRAY_SIZE;
270 |     }

谁能告诉我的细微差别是什么返回Integer.MAX_VALUE与MAX_ARRAY_SIZE？无论哪种方式,都不应该OutOfMemoryError发生？

我需要在正文中发送我的网站的URL,以便邮件收件人可以点击它以加入我的网站.

但是,当前邮件客户端会像这样呈现邮件:

链接到这里http://www.example.com/foo.php?this=a

URL在&符号上被截断,因此整个加入过程失败.如何在mailto正文中传递http://www.example.com/foo.php?this=a&join=abc&user454这样的网址？

我目前的HTML如下:

<a href="mailto:test@test.test?body=Link goes here http://www.example.com/foo.php?this=a&amp;really=long&amp;url=with&amp;lots=and&amp;lots=and&amp;lots=of&prameters=on_it
">Link text goes here</a>

假设我有两个int[]数组input1和input2.我想从第一个中取正数,从第二个中取出不同的数字,将它们合并在一起,排序并存储到结果数组中.这可以使用流执行:

int[] result = IntStream.concat(Arrays.stream(input1).filter(x -> x > 0), 
                   Arrays.stream(input2).distinct()).sorted().toArray();

我想加快任务,所以我考虑使流并行.通常这只意味着我可以.parallel()在流构造和终端操作之间插入任何地方,结果将是相同的.IntDream.concat的JavaDoc 表示如果任何输入流是并行的,则生成的流将是并行的.所以,我认为做parallel()任何input1流或input2流或级联的流将产生相同的结果.

实际上我错了:如果我添加.parallel()到结果流,似乎输入流保持顺序.此外,我可以将输入流(它们中的任何一个或两者)标记为.parallel(),然后将结果流转换为.sequential(),但输入保持平行.所以实际上有8种可能性:input1,input2和连接流都可以是并行的:

int[] sss = IntStream.concat(Arrays.stream(input1).filter(x -> x > 0),
                Arrays.stream(input2).distinct()).sorted().toArray();
int[] ssp = IntStream.concat(Arrays.stream(input1).filter(x -> x > 0),
                Arrays.stream(input2).distinct()).parallel().sorted().toArray();
int[] sps = IntStream.concat(Arrays.stream(input1).filter(x -> x > 0), 
                Arrays.stream(input2).parallel().distinct()).sequential().sorted().toArray();
int[] spp = IntStream.concat(Arrays.stream(input1).filter(x -> x > 0), 
                Arrays.stream(input2).parallel().distinct()).sorted().toArray();
int[] pss = IntStream.concat(Arrays.stream(input1).parallel().filter(x -> x > 0),
                Arrays.stream(input2).distinct()).sequential().sorted().toArray(); …

考虑以下方法,如果字段存在,则返回字段,或者在找到字段之前递归调用自身:

private Field getField(Class<?> clazz, String p) {
    Optional<Field> field = Arrays.stream(clazz.getDeclaredFields())
            .filter(f -> p.equals(f.getName()))
            .findFirst();

    return field.isPresent() ? field.get() : getField(clazz.getSuperclass(), p);
}

虽然这有效,但我认为我可以缩短它:

private Field getField(Class<?> clazz, String p) {
    return Arrays.stream(clazz.getDeclaredFields())
            .filter(f -> p.equals(f.getName()))
            .findFirst()
            .orElse(getField(clazz.getSuperclass(), p));
}

但奇怪的是,这.orElse部分似乎总是被称为.

我在这里错过了什么？

我正在使用早期版本的java 8工作代码,我用它从列表中获取唯一值但是因为我升级到JDK 66它给了我一个错误

类型不匹配:无法转换List<Object>为List<String>

List<String> instList = new ArrayList<String>();

while (res.next()) {
    instList.add(res.getString("INST").toString());
}           

List<String> instListF = instList.stream().distinct().collect(Collectors.toList());

当水库的结果集我是从数据库中获取,不知道什么是错的任何想法？

我正在使用.txt文件读取数字BufferedReader.我想颠倒这种蒸汽中元素的顺序,这样当它们被收集时,它们将从最高到最低排列.我不想在构建数组后进行排序,因为我不知道它中可能有多少个元素,我只需要最高的N个元素.

in = new BufferedReader(reader);
                int[] arr = in.lines()
                        .mapToInt(Integer::parseInt)
                        .sorted()
                        .limit((long) N)
                        .toArray();

我有一组供应商,它们都有相同的结果,但速度不同(且不同).

我想要一种优雅的方式同时启动供应商,并且只要其中一个产生了价值,就将其退回(丢弃其他结果).

我已经尝试过使用并行流,Stream.findAny()但是它总是会阻塞,直到产生所有结果.

这是一个单元测试,展示了我的问题:

import org.junit.Test;

import java.util.Collections;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Supplier;
import java.util.stream.Stream;

import static org.junit.Assert.*;

public class RaceTest {

    @Test
    public void testRace() {
        // Set up suppliers
        Set<Supplier<String>> suppliers = Collections.newSetFromMap(new ConcurrentHashMap<>());
        suppliers.add(() -> "fast"); // This supplier returns immediately
        suppliers.add(() -> {
            try {
                Thread.sleep(10_000);
                return "slow";
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }); // This supplier takes 10 seconds to produce a value

        Stream<Supplier<String>> stream = …