小编mic*_*wth的帖子

<? extends T>形成只读集合

<? super T>形成只写集合

我以某种方式明白为什么使用只读集合，例如在多线程环境中使用它（还有其他情况吗？）

但为什么要使用只写集合呢？如果您无法在某些时候读取它并使用它的值，那还有什么意义呢？我知道你可以从中获取一个对象，但这违反了类型安全。

编辑：@Thomas 链接的问题（Java 中 <? super T> 和 <? extends T> 之间的差异）确实展示了如何创建只写集合，但没有回答“为什么”你首先需要一个集合。所以它不是重复的

 public static <T, U, R> Function<U, R> partial(BiFunction<T, U, R> f, T x) {
        return (y) -> f.apply(x, y);
    }

在上面的表达式中，我可以理解函数partial返回另一个函数，Function<U, R>。它Function<U, R>本身返回一个 R 值。其余的static <T, U, R>代表什么？我的意思是如果Function<U, R>返回一个 R 是怎么回事<T, U, R>？

是新的Google Play应用程序签名服务,主要目的是解决必须将您的发布者公钥硬编码到APK的源代码中的问题,如 base64EncodedPublicKey ="ABCjjjjas ..."？

Webassembly可以将C#编译成字节码，浏览器可执行。它在浏览器中呈现的形式是什么？HTML 与 JavaScript？或者像 Silverlight 或在浏览器中运行的 Java 小程序（例如具有丰富 GUI 的商业应用程序）？

很简单：

import java.util.stream.*;

public class MyClass {
  public static void main(String args[]) {
    Long x = Stream.of(1, 2, 3).map(i -> {
      System.out.println(i);
      return i + 4;
    }).count();

    System.out.println(x); // prints '3'
  }
}

这里count()用于触发中间操作，其中包括System.out.println(i)，但不会从内部打印任何内容map()。这是为什么？

最新的提交应该是逐步包含先前提交的所有更改的提交,对吧？

如果是这样,那么-squash用于将所有提交压缩为一个用于清理历史记录的用途是什么？

什么壁球实际上只是删除除最新提交之外的所有提交？

樱桃采摘也是如此.如果最新提交包含先前提交的所有更改,那么为什么需要选择较旧的提交？

使用jdk11需要什么版本的jre？我找不到晚于8update192的jre版本。

通常，JDK版本是否与Java语言版本相关？适用于Java 8的JDK 8和适用于Java 11的JDK 11？

如果使用JDK 11，我可以运行使用较少运行时的应用程序，例如8吗？那就是JDK 11和Jre 8

这不是一个重复的问题,因为我特别询问编译器如何允许将一个Cat添加到List<? super Cat> catListALREADY包含Dog 的集合中.你看到animaList已经包含了Cats and Dogs因为它们是动物但是调用addCat需要List<? super Cat>添加一个新的猫,add(new RedCat());即使该列表已经包含一只狗.难道编译器不允许这样做以便完成List<? super Cat>签名,因为它试图将Cats添加到已经包含Dogs的列表中吗？

然而明确地呼吁

catList.add(new Dog());

强制执行约束.所以问题是为什么行为的差异？

原始问题:我一直在玩Java泛型并注意到一个奇怪的(？)问题.在下面的代码片段中,您可以将Dog和Cat添加到animalList中,然后将此列表传递到addCat(List<? super Cat> catList)
并添加另一个Cat实例.因此,我们有一个包含Dogs和Cats的List,它们覆盖了？超级猫的边界,因为它不应该允许狗？

但是一旦你取消注释了

//catList.add(new Dog());

你得到一个编译时错误

(参数不匹配;狗不能转换为CAP#1)

这里发生了什么？该代码是从这个修改教程

 package com.tutorialspoint;

    import java.util.ArrayList;
    import java.util.List;

    public class GenericsTester {

       public static void addCat(List<? super Cat> catList) {
         catList.add(new RedCat());
         catList.add(new Cat());

         //catList.add(new Dog());

          System.out.println("Cat Added");
       }

       public static void main(String[] args) {
          List<Animal> animalList= new ArrayList<Animal>();
          List<Cat> catList= new ArrayList<Cat>(); …

摘自/sf/answers/1346223371/

public class Test {

    public class A {}

    public class B extends A {}

    public class C extends B {}

    public void testContraVariance(List<? super B> myBlist) {
        B b = new B();
        C c = new C();
        myBlist.add(b);
        myBlist.add(c);
        A a = myBlist.get(0); // does not compile
    }
}

如果 myBlist 接受 B 的超类型，这意味着 B 或 up，那么为什么还可以像中那样向它添加一个子类型myBlist.add(c)？

import java.util.stream.*;

public class MyClass {
    public static void main(String args[]) {
      Stream.of(1, 2, 3).map(i -> {
          System.out.println(i+":inside map");
          return i+4;
       }).forEach(t->System.out.println(t + ":inside foreach"));
    }
}

// 印刷：

1:inside map
5:inside foreach
2:inside map
6:inside foreach
3:inside map
7:inside foreach

输出不应该是：

1:inside map
2:inside map
3:inside map
5:inside foreach
6:inside foreach
7:inside foreach

我的印象是，每个中间操作结束后，它都会返回一个新的流。所以 foreach 应该得到 (5,6,7) 并因此打印

 5:inside foreach
 6:inside foreach
 7:inside foreach

但案例表明，foreach 是对map 的每个条目一一执行的。这是为什么？