标签: java-8

我正在尝试SELECT MAX(COUNT DISTINCT field_x) FROM stream GROUP BY field_y;使用Java Streams/Collectors在一个groovy脚本中做一个.基本上,我想要一个解决方案COUNT DISTINCT,我可以接受.max.

我一直在尝试这篇文章中的解决方案:java 8 - stream,map和count distinct

但得到错误:

unexpected token: : @ line 65, column 114.
   ")}, Collectors.toSet()), Set::size).val

Groovy中似乎有一个问题Set::size和Map::size.

我已经导入都java.util.Map和java.util.Set无济于事.这是Groovy语法/导入Java类的问题还是我正在使用的问题Collectors？作为参考,我只是尝试在原始后期解决方案中在此地图上实现forEach println:

Map<Integer, Integer> map = bids.stream().collect(
    groupingBy(
            Bid::getBidderUserId,
            collectingAndThen(
                    mapping(Bid::getAuctionId, toSet()),
                    Set::size)));

如果这更适合作为评论而道歉,但显然需要更多的声誉来评论而不是提问.

BigDecimal getInterest(List<Investment> investments) {
        BigDecimal interest = BigDecimal.ZERO;
        for (Investment i: investments) {
            i.getTransactions().stream()
                    .map(Transaction::getAmount)
                    .forEach(interest::add);
        }
        return interest;
    }

这种方法的问题是它总是返回零.看起来好像 .forEach()没有消耗它的论点.但是如果我按照下面的方式编写它,一切都运行正常.任何人都知道为什么第一种方法不起作用？

BigDecimal getInterest(List<Investment> investments) {
        BigDecimal interest = BigDecimal.ZERO;
        for (Investment i: investments) {
            interestPaid = interest.add(i.getTransactions().stream()
                    .map(Transaction::getAmount)
                    .reduce(BigDecimal.ZERO, BigDecimal::add));
        }
        return interest;
    }

我正在尝试使用Java中的Lambda表达式来理解以下方法参考代码:

interface MyFunc<T> {

    boolean func(T v1, T v2);
}

class HighTemp {

    private int hTemp;

    HighTemp(int ht) {
        hTemp = ht;
    }

    boolean sameTemp(HighTemp ht2) {
        return hTemp == ht2.hTemp;
    }

    boolean lessThanTemp(HighTemp ht2) {
        return hTemp < ht2.hTemp;
    }
}

class InstanceMethWithObjectRefDemo {

    static <T> int counter(T[] vals, MyFunc<T> f, T v) {
        int count = 0;
        for (int i = 0; i < vals.length; i++) {
            if (f.func(vals[i], v)) {
                count++;
            }
        }
        return count;
    }

    public …

我在a中有大约5-10M条目HashMap,我无法更改代码结构.我正在java用-Xms=512m -Xmx=1024m.HashMap要避免的构造函数中的最佳容量/负载因子值是java.lang.OutOfMemoryError: GC overhead limit exceeded多少？

private final Map<String, ReportResultView> aggregatedMap = new HashMap<>(????, ????);

我有如下方法

private Map<String,List<String>>  createTableColumnListMap(List<Map<String,String>> nqColumnMapList){

        Map<String, List<String>> targetTableColumnListMap = 
                nqColumnMapList.stream()
                     .flatMap(m -> m.entrySet().stream())
                     .collect(groupingBy(Map.Entry::getKey, mapping(Map.Entry::getValue, toList())));
        return targetTableColumnListMap;
    }

我想大写地图键，但找不到一种方法。有没有Java 8的方法来实现这一目标？

我在一个基于JCR的应用程序上工作,当我的查询包含非法字符时,我的查询会中断.

所以我承担了一个非常简单的任务:给定一个查询字符串和一个包含"狡猾"字符列表的地图,依次用允许的字符替换那些狡猾的字符.我想使用lambdas,可悲的是有点卡住了:

public static Map<String, String> DODGY_CHARS = getDodgyCharMapping();

static Map<String, String> getDodgyCharMapping(){
    Map<String, String> map = new HashMap<>();
    map.put("'", "''");
    return map;
}

private String sanitizeQueryString(String query){
    DODGY_CHARS.keySet().forEach(key->{
        query = replaceCharacter(query, key, DODGY_CHARS.get(key));
    });
    return query;
}

lambda中的查询变量是J8不满意的,导致以下错误:

error: local variables referenced from a lambda expression must be final or effectively final

有一个接收"someObj"的方法,其目的是检查类型Set <>的var ASet,迭代它并用数据库对象替换它的对象.为此,我写了以下代码:

if(!CollectionUtils.isEmpty(someObj.getASet())){
        someObj.setASet(
            someObj.getASet()
                    .stream()
                    .map( c -> AService.getExistingA(c.getId()))
                    .collect(Collectors.toSet())
       );
    }

这样做的目的,但我真的不满意它的可读性.

 Optional.ofNullable(someObj.getASet())
            .ifPresent( ASet->  someObj.setASet(
                                                ASet.stream()
                                                .map( c -> AService.getExistingA(c.getId()))
                                                .collect(Collectors.toSet())
            ));

现在它看起来更不易读,你能推荐更好的方法吗？我认为最糟糕的问题是someObj.setASet,它看起来很奇怪,是否有任何功能方式可以在收集后替换该对象？

这个问题只是为了好玩.

我有这个方法:

private static String getBaseDomain(String fullDomain) {
    // we take the base domain from the usual xxx.yyy.basedomain.tld: we 
    // want only the last 2 elements: basedomain.tld
    List<String> elements = Arrays.asList(fullDomain.split("\\."));
    if( elements.size() > 2){
        elements = elements.subList(elements.size()-2, elements.size());
    }
    return String.join(".", elements);
}

我想知道如何使用java流API获得相同的结果(实际上,我想知道哪种方法是最节省资源的).

我无法想象如何仅从流中获取最后2个元素:limit(2)将给出前两个元素,并且skip(XXX)我不知道如何提取流"inline"的大小.

你能告诉我你会怎么做吗？

是否有一种方便的Java8流API方式从List<T> to Map<T, (index)>以下示例进行转换：

    List<Character> charList = "ABCDE".chars().mapToObj(e->(char)e).collect(Collectors.toList());

    Map<Character, Integer> map = new HashMap<>();
    for (int i = 0; i < charList.size(); i++) {
        map.put(charList.get(i), i);
    }

映射= {A = 0，B = 1，C = 2，D = 3，E = 4}

我已经阅读了如何计算方法在Java中的执行时间？并了解定时执行方法的常用可能性(启动/停止计时器执行,使用方面等).

我想知道Java 8的新方法引用和lambdas是否为实现以下目标带来了任何帮助.

普通代码:

String r;
r = methodCall("foo","bar");

在性能调优期间,将代码修改为类似的内容,以测量执行方法所花费的时间

String r;
time(() -> {
  r = methodCall("foo", "bar"); // doesn't work as r needs to be effectively final
});

我明白我能做到

String r;
r = time1(() -> 
    methodCall("foo", "bar)
);

(注意结尾处缺少的分号),使用类似的time1方法

public static <R> R time1(Supplier<R> s){
    long start = System.currentTimeMillis();
    R result  = s.get();
    System.out.println("Execution took " + (System.currentTimeMillis() - start));
    return result;
}

或者我能做到

r = time2(this::methodCall, "foo", "bar");

用time2方法就好

public static <A,B,R> R time2(BiFunction<A, B, …