标签: java-8

我想PowerMockerRule在我的单元测试中使用,以便我可以在使用Spring的JUnit Runner运行它们时使用PowerMockito.但是,当我将规则添加到我的测试中时,我得到了java.lang.VerifyError.

java.lang.VerifyError: Expecting a stackmap frame at branch target 47
Exception Details:
  Location:
    com/sample/package/MyClass.<init>(Ljava/lang/String;Ljava/lang/String;[Ljava/lang/String;)V @25: if_icmpge
  Reason:
    Expected stackmap frame at this location.
  Bytecode:
    0x0000000: 2a2b 2c01 c000 32b7 0050 2d3a 0419 04be
    0x0000010: 3605 0336 0615 0615 05a2 0016 1904 1506
    0x0000020: 323a 072a 1907 b600 4984 0601 a7ff e9b1
    0x0000030:

到目前为止我所做的一直是根据我的初始搜索将我的javassist依赖关系更新为3.20.0-GA,这通常是问题所在.但是,它仍然无法解决我的问题.还有其他想法吗？

有没有办法使用一些谓词和java流过滤内部和外部列表？例如:

Class outerObject{
    int num;
    List<innerObject> innerObjectList;
}
Class innerObject{
    int num;
}
List <outerObject> outerObjectList

有没有办法过滤列表,使outerObject列表有字段num = 10,相应字段的innerObject's 列表outerObject也被相应的字段过滤num = 10？

我试过了:

outerObjectList.stream()
               .filter(i -> i.getNum() == 10)
               .filter(i -> i.getOrders().stream().anyMatch(s -> getNum() == 10))
               .collect(Collectors.toList());

但它似乎没有过滤内部列表.

描述性示例:

如果外部列表中有3个对象,num = 10并且3个对象中的每个对象都有1个内部对象innerObjectList,num = 10那么它应该给我一个3 outerObject的列表,innerObject每个列表为1 .

我希望以下Java代码将字符串拆分为三个项目:

    String csv = "1,2,";
    String[] tokens = csv.split(",");
    System.out.println(tokens.length);

但是,我只收到两件物品.

我必须承认,我没有深入分析这一点,但这对我来说似乎是违反直觉的.Python和C#都在Python中生成三个项目,如下所示:

def test_split(self):
    line = '1,2,'
    tokens = line.split(",")
    for token in tokens:
        print('-' + token)
-1
-2
-

在C#中:

   [Test]
    public void t()
    {
        string s = "1,2,";
        var tokens = s.Split(',');
        foreach (var token in tokens)
        {
            Console.WriteLine("-" + token);
        }
    }
-1
-2
-

我错过了什么？

这是Java 1.8.0_101.

我有一个从文件中读取的以下线路流

1 2 4.5

1 6 3 5.5 5.3 6

1 7.2 5 7

如何只考虑整数,我如何在单个列表中收集这些行？(请注意,在每一行中,数字由一个或多个空格分隔)

这是我尝试过的,但这给了我一个所有整数元素的列表.

        list = reader.lines()
            .map(m -> m.split("\\n"))
            .flatMap(Arrays::stream)
            .map(m -> m.split("\\s+"))
            .flatMap(Arrays::stream)
            .filter(f -> !f.contains("."))
            .map(Integer::parseInt)
            .collect(Collectors.toList());

我正在使用一些Java 8 StreamAPI.我很困惑看到以下两个解决方案之间的性能差异,即只打印内容Stream.

解决方案1:

int[] array = new int[] { 0, 1, 2, 3, 4, 5 };
start = System.nanoTime();
Arrays.stream(array).forEach(System.out::println);
System.out.println((System.nanoTime() - start) / 1000000.0f);

解决方案2:

int[] array = new int[] { 0, 1, 2, 3, 4, 5 };
start = System.nanoTime();
Arrays.stream(array).forEach(new IntConsumer() {
    @Override
    public void accept(int value) {
        System.out.println(value);
    }
});
System.out.println((System.nanoTime() - start) / 1000000.0f);

执行时,Solution 1约需要 比时间长5-6倍Solution 2.

系统配置:

• JRE: 1.8.0_101 64 bit
• OS: Windows 10 Home …

为什么我们不能为地图创建流？

我有一个类似于下面的代码,由于某种原因,当我调用一个Consumer<BigDecimal>带有lambda参数的方法时,lambda参数是类型Object而不是BigDecimal.如果BigDecimal调用lambda param的任何方法,则会导致lambda 中的"无法解析方法" .只有当采用消费者的方法属于泛型类时,才会发生这种情况,但非泛型参与者采用这种消费者方法.

public class Creator<T> {

    private T something;

    private Consumer<BigDecimal> consumer;

    public Creator(T something) {
        this.something = something;
    }

    public void create(Consumer<BigDecimal> consumer) {
        this.consumer = consumer;
    }

}

public class Processor {
    public void process(Creator creator) {
        creator.create(big -> big.abs());
                                  ^^^^^-------------------- Cannot resolve method
    }
}

如果我<T>从Creator类中删除泛型参数,它就可以工作,即使泛型不接触该create()方法

这有什么问题？

寻找一种简单的方法来收集KeyAndValues having fields - String and List<T>到ImmutableListMultimap<String,T>？试图做一些像,

 Collector.of(
          ImmutableListMultimap.Builder::new,
          ImmutableListMultimap.Builder<String,List<T>>::putAll,
          (b1, b2) -> b1.putAll(b2.build()),
          (builder) -> builder.build());

putAll需要Key,List<T>.我不知道如何在组合器中实现这一点.

编辑:

 @Value(staticConstructor = "of")
 private static class KeyAndValues<T> {

    private final String key;
    private final List<T> values;
}

是否有一种优雅的方法来存储方法的返回值,apply()因此不必多次调用它？因为我能想到的唯一方法是创建一个本地映射变量来存储函数 - "返回值"对.

@Autowired
private List<Function<String, String>> evaluators; 
//...
private String evaluate(String code) {  
    return evaluators.stream().filter(f -> f.apply(code) != null).findFirst().get().apply(code); 
}

是否可以将方法的引用作为参数传递？

例如:

public static void main(String[] args) {
    String data = "name: John, random text, address: leetStreet";
    Person person;

    //if regex matches, use method reference, to send the result. 
    applyDataToPerson(data, "name: (\\w+)", person, Person::setName);
    applyDataToPerson(data, "address: (\\w+)", person, Person::setAddress);
}

private static void applyDataToPerson(String data, String regex, Person person, 
 Function<Person> f) {
    Matcher match = Pattern.compile(regex).matcher(data);
    if (match.matches()) person.f(match.group(1));
}

class Person {
    private String name;
    private String address;

    public void setName(String name) {
        this.name = name;
    }

    public void …