标签: java-8

我试图通过具有特定区域设置的字段对列表进行排序.我如何结合以下陈述？

names.stream().sorted(Comparator.comparing(AClass::getName)).collect(Collectors.toList());

Collator coll = Collator.getInstance(new Locale("tr","TR"));
coll.setStrength(Collator.PRIMARY);

    _logger.info("data size : "+saleData.size);

    saleData.parallelStream().forEach(data -> {
                SaleAggrData saleAggrData = new SaleAggrData() {
                    {
                        setCatId(data.getCatId());
                        setRevenue(RoundUpUtil.roundUpDouble(data.getRevenue()));
                        setMargin(RoundUpUtil.roundUpDouble(data.getMargin()));
                        setUnits(data.getUnits());
                        setMarginRate(ComputeUtil.marginRate(data.getRevenue(), data.getMargin()));
                        setOtd(ComputeUtil.OTD(data.getRevenue(), data.getUnits()));
                        setSaleDate(data.getSaleDate());
                        setDiscountDepth(ComputeUtil.discountDepth(data.getRegularPrice(), data.getRevenue()));
                        setTransactions(data.getTransactions());
                        setUpt(ComputeUtil.UPT(data.getUnits(), data.getTransactions()));
                    }
                };
                salesAggrData.addSaleAggrData(saleAggrData);
            });

代码的问题是当我从DB获得响应时,并且在使用并行流进行迭代时,每次数据大小都不同,而使用顺序流时,它工作正常.

我不能使用顺序Stream因为数据很大并且需要时间.

任何领导都会有所帮助.

假设我有一个ArrayList<String>500的大小,然后我想有效地连接索引(从1开始)的字符串:1-100,101-200,...,401-500字符串(所以我想得到5个字符串而不是500).我以为我可以使用StringBuilder,然后使用.toString,但.toString()方法StringBuilder创建一个新字符串,所以有效地我将创建5 * 2 = 10的字符串这是坏的(这些字符串是真正巨大的,我很短的空间).什么是最好的内存和时间有效的方法呢？

到目前为止我尝试过的:

有一个错字:我的意思是StringBuilder代替StringBuffer.我使用了StringBuilder一个简单的for循环ArrayList<String>.所以我使用了3x空间(1x - 初始ArrayList,2x - for StringBuilder,3x - 当sb.toString()有效创建返回时调用new String(value, 0, count);)

如果我做

try(Lock lock = lockProvider.lock()) {
    // some code that doesn't use variable lock
}

编译器或JITer是否存在删除锁创建的风险,因为它在块中看到它未使用？

后来编辑:

一点背景.我来自.NET背景,在C#中,它允许执行以下操作:

using(Transaction tx = BeginTransaction())
{
    // code that does things without touching the tx variable, such as SQL connections and stuff
}

事实上它甚至可以缩短为

using(BeginTransaction())
{
    // code that does things without touching the tx variable, such as SQL connections and stuff
}

静态编译器和JIT编译器将保持BeginTransaction调用,并且在运行时它将始终发生.

然而,在Java似乎是一个很大的问题和消极周围使用try-与资源用于其他的东西,是资源.

我有一个ArrayList,其中包含以下内容 - CHENNAI,MUMBAI,DELHI,CHENNAI,DELHI,CHENNAI.此外,假设这3个城市名称被定义为具有针对每个城市的值的ENUM.(CHENNAI = 1,MUMBAI = 2和DELHI = 3)

我的Java 8 Streams,我能够计算城市值的总和,在这种情况下,它将是1 + 2 + 3 + 1 + 3 + 1 = 11.

问题是,如果有一个额外的标准,我怎么能计算相同ArrayList的城市值之和,

如果城市名称出现两次,则必须仅添加一次.即在这种情况下,CHENNAI存在3次.因此,当添加其值时,我们应该只考虑1(对于前2次出现)+ 1 = 2而不是3.同样,DELHI出现2次.因此,德里的价值应该只采取一次.因此,如前所述,最终结果将是2 + 2 + 3 = 7而不是11.

请帮助如何在Java 8中实现这一点

我正在努力学习同步.根据我学到的东西卡在这里下面的代码应该给8000作为最终结果,但我得到一个随机的结果,如下面的
包线程;

import java.time.LocalDateTime;

public class A implements Runnable {
    String name;
    static Integer j=0;
    A(String name){
        this.name=name;
    }
    @Override
    public synchronized void  run() {
        for(int i=1;i<=1000;i++){
            synchronized(this){
            A.j++;
            }
        }
        System.out.println(j);
    }

package threads;

public class MainClass {
public static void main(String args[]){
    Thread t1=new Thread(new A("i am thread A "));
    Thread t2=new Thread(new A("i am thread B "));
    Thread t3=new Thread(new A("i am thread C "));
    Thread t4=new Thread(new A("i am thread D "));
    Thread t5=new Thread(new A("i …

我正在研究Java 8中的Stream API,我遇到了一个问题.问题是我试图理解 以下代码之间()->new StringBuilder和 之间的差异StringBuilder::new:

Stream<String> stream = Stream.of(new String[]{"b", "a", "s", "i", "l",});
StringBuilder basil = stream.collect(StringBuilder::new, StringBuilder::append, StringBuilder::append);
System.out.println("basil");

和

Stream<String> stream = Stream.of(new String[]{"b", "a", "s", "i", "l",});
    StringBuilder basil = stream.collect(()->new StringBuilder(), StringBuilder::append, StringBuilder::append);
    System.out.println("basil");

我何时应该使用第一种语法,何时应该选择第二种语法？

为什么上面的代码接受StringBuilder::append并且不接受StringBuilder::reverse

我正在尝试使用增强的for循环来添加数组中的元素.如果我使用正常的for循环,它可以工作.但是,当我使用增强的for循环时,它会引发IndexOutOfBounds异常,我不确定为什么会发生这种情况？

int[ ] array = {1,2,3};
int total = 0; 
for(int counter : array) {
    total = total + array[counter];
}
System.out.println(total);

下面的代码打印：

should Not have called
hello world

为什么orElse即使有包含值的Optional也要执行？

public static void main(String[] args){
    String o = Optional.ofNullable("world").map(str -> "hello" + str).orElse(dontCallMe());
    System.out.println(o);
}

private static String dontCallMe() {
    System.out.println("should Not have called");
    return "why god why";
}

在使用java时我遇到了一个奇怪的情况,让我们先从代码开始.

public static String constructMessage(final String reason, final String xId,
        final String yId, final IonStruct metadataStruct) throws DataSanityException {
    String message = "";
        switch (reason) {
            case "NOT_ACTIVE":
                if (xId != null) {
                    message = String.format("Y %s X %s not active: status is inactive%n", yId, xId);
                } else {
                    message = String.format("Y %s not active: status is inactive%n", yId);
                }
                break;
            case "PRICE_GONE":
                if (metadataStruct.containsKey("applied")) {
                    final String applied = metadataStruct.get("applied");
                    if (applied.equals("single")) {
                        message = String.format("X %s is not …