小编shm*_*sel的帖子

为什么Java可以推断多个上限类型的共同祖先,而不是下限类型的共同祖先？

更具体地说,请考虑以下示例:

static class Test {

    static <T> T pick(T one, T two) {
        return two;
    }

    static void testUpperBound() {
        List<? extends Integer> extendsInteger = new ArrayList<>();

        // List<? extends Integer> is treated as a subclass of List<? extends Number>
        List<? extends Number> extendsNumber = extendsInteger;

        // List<? extends Number> is inferred as the common superclass
        extendsNumber = pick(extendsInteger, extendsNumber);
    }

    static void testLowerBound() {
        List<? super Number> superNumber = new ArrayList<>();

        // List<? super Number> is treated as …

我有人员名单，如果输入列表是3,0,2,7,0,8

我想要的输出是2,3,7,8,0,0

使用以下代码，我可以仅对非零数字进行排序以获取2,3,7,8输出。

sortedList = personList.stream()
                       .filter(Person -> Person.getAge()>0)
                       .sorted(Comparator.comparingInt(Person::getAge))
                       .collect(Collectors.toList());

zeroList=personList.stream()
                       .filter(Person -> Person.getAge()==0)
                       .collect(Collectors.toList());

sortedList.addAll(zeroList);

上述两个语句可以合并为一个语句吗？

我有一个问题,我相信你帮我解决了皱纹问题.

我有

List<Predicate<TaskFx>> predicates

我想在这里使用这些谓词

taskFxList.stream().filter(predicates).collect(Collectors.toList());

作为一个谓词合并如下:

predicate1.and(predicate2).and...

我有一个表(13列),其中包含一些结果(在JavaFx中)和6个字段,可以通过这些字段中的值在此表中搜索.我只能输入3个字段的值,所以我的

predicates.size() = 3;

问题是如何最好地动态准备一个

Predicate<TaskFx> predicate

包含由x.and(y).和(z)合并的所有谓词

非常感谢您的帮助!

我在我的项目中遇到了以下代码.我想知道它是否可以进一步优化可能是通过使用java 8流或一般的集合API.

private Set<Student> getFilteredSet() {
    Set<Student> unfilteredSet = getAllStudents();
    Set<Student> adminAreaSet = getAdminStudents();

    Set<String> adminAreaID = new HashSet<>();
    Set<Student> filteredSet = new HashSet<>();

    for (final Student student : adminAreaSet) {
        adminAreaID.add(student.getId());
    }
    for (final Student student : unfilteredSet) {
        if (adminAreaID.contains(student.getId())) {
            filteredSet.add(student);
        }
    }   
    return filteredSet;
}

注意: unfilteredSet并adminAreaSet保持不同的子类型Student

我试图理解为什么 Java 不允许像在泛型方法中那样在泛型类中使用隐式类型。

我已经在网上搜索了有关此问题的答案，但还没有找到为什么Java 不支持以下内容的原因：

// This will not compile:
public <T> interface ElementPicker<L extends List<T>> { ... }

// This on the other hand will
public interface ElementPicker<T, L extends List<T>> { ... }

因此我们必须在类泛型参数中明确提及类型 T。这当然意味着我们现在必须总是这样写：

ElementPicker<Integer, List<Integer>>
// instead of just:
ElementPicker<List<Integer>>

这导致我的代码一直头疼，我试图明智地平衡使用泛型，同时使我的类型可读和简短。

不幸的是，在我当前的项目中，我正在处理一堆嵌套的泛型类型，它们的类型参数冒泡到顶部，因此我有很长的顶级类，必须包含所有泛型类型数据。

要了解这如何成为问题，请考虑：

interface ScalarValue<T extends Number> {
  T toNumber();
}

interface ScalarAdder<T, U extends ScalarValue<T>> {
  T add(U v1, U v2);
}

class ScalarAccumulator<T, U extends ScalarValue<T>, 
                           A extends ScalarAdder<T, U>> {
  ... …

重构时，我在子类中遇到了以下方法：

public void disposeResultsTable() {
    super.disposeResultsTable();
}

保留此方法而不是简单地允许调用继承的超类方法有什么好处？

我有以下 Java Stream 流语句，并根据 typeId 值过滤记录 types.getIds().contains(x.getType().getId())：

return petRepository.findAll().stream()
                .filter(x -> types.getIds().contains(x.getType().getId()))
                .collect(Collectors.groupingBy(x -> x.getType().getName(), Collectors.counting()));

但是，我想在types.getIds().size() == 0尝试以下 shpon 时获取所有值：

.filter(types.getIds().size() > 0 ? x -> types.getIds().contains(x.getType().getId()) : <NO FILTERING>)

那么，我怎样才能跳过过滤呢types.getIds().size() == 0？

说我有以下代码:

Map<String, Boolean> map = ...
map.put("foo", true);

从理论上讲,true必须进行自动装箱,与插入相比会导致轻微的性能损失Boolean.TRUE.但是由于我们正在处理一个文字值,编译器是否有可能用一个盒装文字替换原始文字,因此没有额外的运行时开销？

在任何人攻击我之前,我通常会为了代码清晰度而选择原始文字,即使性能成本很低.这个问题大多是理论上的.

我想在List的每个元素上调用lambda函数,并将结果放在一个新的List中.

我目前的版本是这样的:

b = a.stream().map(i-> i+1).collect(Collectors.toList());

但它似乎相当冗长,并且通过从列表到流的转换所需的所有样板代码隐藏了代码的意图,反之亦然.其他语言(例如ruby)中的相同代码将更加简洁,如下所示:

b = a.map{|i| i+1}

当然可以做这样的事情:

for (int i: a) {
    b.add(i+1);
}

但它看起来有点过时,而且不如lambda版本灵活.

为了改变现有的List,Holger的评论 list.replaceAll(i->i+1)很好,但我有兴趣创建一个新的List对象.

是否有一种方法可以在列表的每个元素上调用lambda并创建一个带有结果的新元素？

我正在研究java 8并行流并且想要在并行流中打印元素是一些顺序(比如插入顺序,逆序或顺序顺序).

为此,我尝试了以下代码:

        System.out.println("With forEachOrdered:");
        listOfIntegers
            .parallelStream()
            .forEachOrdered(e -> System.out.print(e + " "));
        System.out.println("");

        System.out.println("With Sequential:");
        listOfIntegers.parallelStream()
                    .sequential()
                    .forEach(e -> System.out.print(e + " "));

对于这两个,我得到相同的输出如下:

With forEachOrdered:
1 2 3 4 5 6 7 8 
With Sequential:
1 2 3 4 5 6 7 8 

从api文档中,我可以看到:

forEachOrdered - >这是一个终端操作.

和

顺序 - >这是一个中间操作.

所以我的问题是哪一个更好用？在哪种情况下,一个应该优先于其他情况？