标签: java-8

for (int i=0; i<100000; i++) {
    // REST API request. 
restTemplate.exchange(url, HttpMethod.GET, request, String.class);
}

我有一种情况,我必须为10万用户请求一个资源,它需要70分钟才能完成.我试图尽可能地清理我的代码,我只能将它减少4分钟).

由于每个请求彼此独立,我很乐意并行发送请求(可能是10s,100s甚至1000s的块,每次快速完成).我希望我能把时间减少到10分钟或者接近的时间.如何计算哪个块大小可以快速完成工作？

我找到了以下方法,但我不知道该程序是否一次处理所有20个; 或一次5个; 或者一次10个.

IntStream.range(0,20).parallel().forEach(i->{
     ... do something here
});

我知道你的帮助.我对任何建议或评论都持开放态度!

更新:我能够使用IntStream,并在28分钟内完成任务.但我不确定这是我能做的最好的.

什么是创造了最地道的方式Comparator<T>在Java中8定义对象的排序例如,基于在其相对指标给定的List,但仍然是一个对象在该列表中不存在定义为"后"那些是是列表中？- 如果我只是使用List.indexOf(Object),不在列表中的对象将总是在列表中的对象之前,因为-1对于不在列表中的所有对象返回的事实,这小于任何"真"索引:

    final List<String> ordering = Arrays.asList("foo", "bar");
    final Comparator<String> orderingComparator = Comparator.comparingInt(ordering::indexOf);
    final String str1 = "foo";
    final String str2 = "baz";
    final String msg;
    final int cmp = orderingComparator.compare(str1, str2);
    if (cmp < 0) {
        msg = String.format("Element \"%s\" is ordered before \"%s\".", str1, str2);
    } else if (cmp > 0) {
        msg = String.format("Element \"%s\" is ordered after \"%s\".", str1, str2);
    } else {
        msg …

我有一个文件,其中包含JSON格式的数据.我正在逐行阅读它,每行都有1个JSON记录,所以格式确实不是问题.以下是一个示例行:

{"url": "http://ldrlongdistancerider.com/bikers_rights_motorcycle/rightsriders0163.php", "timestamp": 1257072412, "tags": ["nscensorship", "cloudmark", "network", "solutions", "content", "based", "spam", "signatures"]}

我需要做的是计算所有重复的URL并将其打印为:

 http://ldrlongdistancerider.com/bikers_rights_motorcycle/rightsriders0163.php"  1

如何使用流来实现这一目标？顺便说一下,我需要根据时间戳过滤记录.因此,如果有人通过了一系列日期,我将不得不计算落在该范围内的网址.我已经完成了大部分工作,但这个计算部分对我来说很困惑.

这是我到目前为止所做的:

for (Path filePath : files) {
        try {
            Files.lines(Paths.get(filePath.toUri()))
                 .filter(s -> Link.parse(s).timestamp() > startSeconds)
                 .filter(s -> Link.parse(s).timestamp() < stopSeconds)
                 .forEach(s -> countMap.put(Link.parse(s).url(), 1));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

countMap是String,Integer的HashMap

我在jdk8中找到了HashMap函数resize()的源代码:

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    if (oldCap > 0) {
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = …

我是Java 8的新手,对Lambda Expression的范围感到有点困惑.我读了一些文章表示Lambda Expression减少了执行时间,所以要找到我写的两个程序之后的相同内容

1)不使用Lambda Expression

import java.util.*;

public class testing_without_lambda
{
  public static void main(String args[])
  {
    long startTime =  System.currentTimeMillis();       
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
    for (int number : numbers) 
    {
        System.out.println(number); 
    }   
    long stopTime =  System.currentTimeMillis();
    System.out.print("without lambda:");
    System.out.println(stopTime - startTime);
  }//end main
}

输出:

2)使用Lambda Expression

import java.util.*;
public class testing_with_lambda
{
  public static void main(String args[])
  {  
    long startTime =  System.currentTimeMillis();
    List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);    
    numbers.forEach((Integer …

我使用Java 8实现了以下代码.

Map<String, String> coMap = getHashMap();

String newCoName = coMap.entrySet()
                     .stream()
                     .filter(coEntry -> coEntry.getValue().equals(newcoId))
                     .map(coEntry -> coEntry.getKey())
                     .collect(Collectors.joining());


String oldCoName = coMap.entrySet()
                     .stream()
                     .filter(coEntry -> coEntry.getValue().equals(oldcoId))
                     .map(coEntry -> coEntry.getKey())
                     .collect(Collectors.joining());

现在.我想知道更好的方法,而不是重复相同的代码行两次.

在Java 8之前,我们通常必须执行以下操作才能快速执行Null值.

Objects.requireNonNull(pointer, "Your Error Message");

根据Java 8 Documentation,如果传递的参数为null ,Optional.of则抛出NullPointerException.

// Optional.of - throws NullPointerException if passed parameter is null
Optional<Integer> b = Optional.of(value2);

有没有什么办法来定义错误消息为NullPointerException在Java中8 Optional？

在传统方式中,我已经编写了这个简单的java for循环

public String setString(String string) {  
StringBuilder stringBuilder = new StringBuilder();

    // This for loop I want to convert into stream. 
    for (char c : string.toCharArray()) {
       if (Character.isSpaceChar(c))
           stringBuilder.append(c);
       else if (isBangla(c))
           stringBuilder.append(get(c));
    }
    return stringBuilder.toString();
}

String get(int c) {
    return keyMap.getMap((char) c); // Map<Character, String> keyMap
}

boolean isBangla(int codePoint) {
    return ((codePoint >= BANGLA_CHAR_START && codePoint <= BANGLA_CHAR_END) &&
        (codePoint <= BANGLA_NUMBER_START || codePoint >= BANGLA_NUMBER_END)));
}

我试过这样的事情.

String str = string.chars()
            .filter(i -> Character.isSpaceChar(i)) …

我有一段使用传统for循环编写的代码,如下所示.我想重构它以使用java 8流并删除for循环.以下代码的输出应为3,因为这是最长的连续数字列表(4,5和6)

    List<Integer> weekDays = Lists.newArrayList(1, 2, 4, 5, 6);

    List<Integer> consecutiveIntervals = Lists.newArrayList();
    int maxConsecutiveTillNow = 1;
    for (int i = 1; i < weekDays.size(); i++) {
        if (weekDays.get(i) - weekDays.get(i - 1) == 1) {
            maxConsecutiveTillNow++;
        } else {
            consecutiveIntervals.add(maxConsecutiveTillNow);
            maxConsecutiveTillNow = 1;
        }
    }
    consecutiveIntervals.add(maxConsecutiveTillNow);

    System.out.println(consecutiveIntervals.stream()
                                           .max(Integer::compareTo)
                                           .get()
                      );

我有一个对象列表，可以说形状。我想使用流来处理它们，并根据列表中的内容返回另一个对象-ShapeType。

通常，我只返回ShapeType.GENERIC，但是如果其中存在Rectangle，我想返回ShapeType.RECT。如果列表中有一个六角形，我想返回ShapeType.HEXA。当同时存在矩形和正方形时，我想返回ShapeType.HEXA。

现在，当涉及到代码时，我想要这样的东西：

  public ShapeType resolveShapeType(final List<Shape> shapes) {
    shapes.stream()
    .filter(shape -> shape.getSideCount() == 6 || shape.getSideCount() == 4)
    // I should have a stream with just rectangles and hexagons if present.
    // what now?
  }