标签: java-stream

我有一个函数在a上执行一些流操作(特别是一个过滤器)List.

public List<String> getAndFilterNames(List<Person> people, Predicate<Person> nameFilter){
  List<String> allNames = people.stream()
    .map(person -> person.getName())
    .filter(nameFilter)
    .collect(Collectors.toList());
  return allNames;
}

我希望能够通过中间流操作(filter,distinct等),并有我的功能运行的终端操作之前执行该操作.就像是:

public List<String> getAndProcessNames(List<Person> people, <intermediate stream operation>){
  List<String> allNames = people.stream()
    .map(person -> person.getName())
    // perform <intermediate stream operation> here
    .collect(Collectors.toList());
  return allNames;
}

虽然,根据我目前的经验水平,似乎是不可能的.一些中间操作有一个参数(比如filter),有些没有(比如distinct),所以我不能设置一个能处理所有情况的参数类型...我想我可以创建一些签名,但是Function和Supplier.

即便如此,该功能界面与参数的功能需要变化...... filter需要Predicate,map需要Function,并从我的理解,是没有办法来表示一个通用的功能接口.那是对的吗？它们都没有真正的公共类或接口.

那么,到底,看来我最好的选择是公正map和collect,然后运行所需的我流操作的情况下,逐案的基础,如:

public List<String> getNames(List<Person> people){
  List<String> allNames = …

我通过实现Collector接口并覆盖其方法来实现自定义收集器.Collector实现如下:

class MyCustomCollector implements Collector<Person, StringJoiner, String>{

    @Override
    public Supplier<StringJoiner> supplier() {
        // TODO Auto-generated method stub
        return () -> new StringJoiner("|");
    }

    @Override
    public BiConsumer<StringJoiner, Person> accumulator() {
        // TODO Auto-generated method stub
        return (joiner,person) -> joiner.add(person.name.toUpperCase());
    }

    @Override
    public BinaryOperator<StringJoiner> combiner() {
        // TODO Auto-generated method stub
        return (joiner1, joiner2) -> joiner1.merge(joiner2);
    }

    @Override
    public Function<StringJoiner, String> finisher() {
        // TODO Auto-generated method stub
        return StringJoiner::toString;
    }

    @Override
    public Set<java.util.stream.Collector.Characteristics> characteristics() {
        // TODO Auto-generated method stub
        return …

我有一个包含嵌套和内部类的类.在某些程序中,我使用遗留java方式中的相等运算符检查对象的空值.以下是我的代码片段:

class Outer {
    Nested nested;
    Nested getNested() {
        return nested;
    }
}
class Nested {
    Inner inner;
    Inner getInner() {
        return inner;
    }
}
class Inner {
    String foo;
    String getFoo() {
        return foo;
    }
}

这是我如何对引用变量进行空检查:

Outer outer = new Outer();
if (outer != null && outer.nested != null && outer.nested.inner != null) {
    System.out.println(outer.nested.inner.foo);
}

我知道这也可以使用java 8的Optional类来完成,但是我没有办法在上面的特定场景中做同样的事情.有什么建议吗？

我有一个文件,其中包含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

我使用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 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?
  }

我必须遵循以下代码:

import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;

public class TimeZonesExample
{
    public static void main(String[] args)
    {
        Set<String> allZones = ZoneId.getAvailableZoneIds();
        LocalDateTime localDateTime = LocalDateTime.now();

        List<String> zoneList = new ArrayList<>(allZones);

        for (String s : zoneList)
        {
            ZoneId zoneId = ZoneId.of(s);
            ZonedDateTime zoneDateTime = localDateTime.atZone(zoneId);
            ZoneOffset zoneOffset = zoneDateTime.getOffset();
            String out = String.format("%35s %10s%n", zoneId, zoneOffset);

            System.out.printf(out);
        }
    }
}

这产生了这样一个列表:

                  Asia/Aden     +03:00
             America/Cuiaba     -03:00
                  Etc/GMT+9     -09:00
                  Etc/GMT+8     -08:00
             Africa/Nairobi     +03:00
            America/Marigot     -04:00 …

嗨,我在执行代码时遇到错误:

java.lang.IllegalStateException: Duplicate key ad.ecs.core.scriptengine.SiteIDAndNPI@3a75ce6f
at java.util.stream.Collectors.lambda$throwingMerger$0(Collectors.java:133)
at java.util.HashMap.merge(HashMap.java:1253)
at java.util.stream.Collectors.lambda$toMap$58(Collectors.java:1320)
at java.util.stream.ReduceOps$3ReducingSink.accept(ReduceOps.java:169)
at java.util.ArrayList$ArrayListSpliterator.forEachRemaining(ArrayList.java:1374)
at java.util.stream.AbstractPipeline.copyInto(AbstractPipeline.java:481)
at java.util.stream.AbstractPipeline.wrapAndCopyInto(AbstractPipeline.java:471)
at java.util.stream.ReduceOps$ReduceOp.evaluateSequential(ReduceOps.java:708)
at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:234)
at java.util.stream.ReferencePipeline.collect(ReferencePipeline.java:499)
at ad.ecs.core.scriptengine.Utils.getInterfaceIDsWithSiteIDAndNPI(Utils.java:689)

我正在尝试将我的列表分组到地图中:

public static Map<Integer, SiteIDAndNPI> getInterfaceIDsWithSiteIDAndNPI(Session session) {
    @SuppressWarnings("unchecked")
    List<Srvsetup> srvsetups = session.createCriteria(Srvsetup.class)
            .add(Restrictions.gt("scriptinterfaceid", 0))
            .list(); 
    Map<Integer, SiteIDAndNPI> interfaceIDs = srvsetups.stream()
            .collect(Collectors.toMap(srv -> srv.getScriptinterfaceid(), 
                    srv -> getSiteIDAndNPI(srv.getId().getSiteid(), session)));

    @SuppressWarnings("unchecked")
    List<Facsetup> facsetups = session.createCriteria(Facsetup.class)
            .add(Restrictions.gt("scriptinterfaceid", 0))
            .list(); 
    interfaceIDs.putAll(facsetups.stream()
            .collect(Collectors.toMap(fac -> fac.getScriptinterfaceid(), 
                    fac -> getSiteIDAndNPI(fac.getPlid(), session))));
    return interfaceIDs;
}

public static SiteIDAndNPI getSiteIDAndNPI(int siteID, Session …