各位大佬，你们觉得 Java 的泛型难吗？

不难

不难，不支持协变和逆变比较可惜

<A<B<C<D<E>>>>>

不要太容易

真香

```scala
class ApplicativeOps[M[_],A](ma:M[A])(implicit a:Applicative[M]){

def ~>[B](mb: M[B]):M[B] = a(a(a.pure((_:A) => (b:B) => b), ma),mb)
def andKeep[B](mb: M[B]):M[B] = ~>(mb)

def <~[B](mb: M[B]):M[A] = a(a(a.pure((a:A) => (_:B) => a), ma),mb)
def keepAnd[B](mb: M[B]):M[A] = <~(mb)

def <~>[B,C](mb: M[B])(implicit witness: <:<[A,B => C]): M[C] = apply(mb)
def apply[B,C](mb: M[B])(implicit witness: <:<[A,B => C]): M[C] = a(a.map(ma,witness),mb)
}
```

贴段 play2 的 scala 代码感受下

@Narcissu5 你的代码为什么骂人

可以读下 Core Java 卷一

反正又不是真泛型，稍微会用就行了

不难，泛型表面很优雅，但是底层很丑陋。

泛型不难，泛型变型难上天

泛型通配还是挺难的，说容易的看一下 stream 的几个 oprator 的函数的参数吧，一眼看懂算我输

不过相比 c++的模板，还是大巫见小巫

@lhx2008 至今懵逼的。用的函数基本都是看注释里的示例代码。还有就是 宇宙第二 IDE

java 有范型？

呵呵，范型要是不难，那 Java 就没有什么难的地方了

那是你还没了解过 c++的模版

今天写的：

Map<String, Map<String, Map<String, String>>> res = list.stream()...;

能百度出的都不难,学就完事

@qiyuey #2 <? extend Base>，<? super Derived> 算啥:-P

你应该没有见过 C 的指针

@oaix 是我不严谨了，Java 只在一定程度上支持

```
export type ResolveArrayThunks<TDispatchProps extends ReadonlyArray<any>> =
TDispatchProps extends [infer A1, infer A2, infer A3, infer A4, infer A5, infer A6, infer A7, infer A8, infer A9]
? [HandleThunkActionCreator<A1>, HandleThunkActionCreator<A2>, HandleThunkActionCreator<A3>, HandleThunkActionCreator<A4>,
HandleThunkActionCreator<A5>, HandleThunkActionCreator<A6>, HandleThunkActionCreator<A7>, HandleThunkActionCreator<A8>, HandleThunkActionCreator<A9>]
: TDispatchProps extends [infer A1, infer A2, infer A3, infer A4, infer A5, infer A6, infer A7, infer A8]
? [HandleThunkActionCreator<A1>, HandleThunkActionCreator<A2>, HandleThunkActionCreator<A3>, HandleThunkActionCreator<A4>,
HandleThunkActionCreator<A5>, HandleThunkActionCreator<A6>, HandleThunkActionCreator<A7>, HandleThunkActionCreator<A8>]
: TDispatchProps extends [infer A1, infer A2, infer A3, infer A4, infer A5, infer A6, infer A7]
? [HandleThunkActionCreator<A1>, HandleThunkActionCreator<A2>, HandleThunkActionCreator<A3>, HandleThunkActionCreator<A4>,
HandleThunkActionCreator<A5>, HandleThunkActionCreator<A6>, HandleThunkActionCreator<A7>]
: TDispatchProps extends [infer A1, infer A2, infer A3, infer A4, infer A5, infer A6]
? [HandleThunkActionCreator<A1>, HandleThunkActionCreator<A2>, HandleThunkActionCreator<A3>, HandleThunkActionCreator<A4>, HandleThunkActionCreator<A5>, HandleThunkActionCreator<A6>]
: TDispatchProps extends [infer A1, infer A2, infer A3, infer A4, infer A5]
? [HandleThunkActionCreator<A1>, HandleThunkActionCreator<A2>, HandleThunkActionCreator<A3>, HandleThunkActionCreator<A4>, HandleThunkActionCreator<A5>]
: TDispatchProps extends [infer A1, infer A2, infer A3, infer A4] ? [HandleThunkActionCreator<A1>, HandleThunkActionCreator<A2>, HandleThunkActionCreator<A3>, HandleThunkActionCreator<A4>]
: TDispatchProps extends [infer A1, infer A2, infer A3] ? [HandleThunkActionCreator<A1>, HandleThunkActionCreator<A2>, HandleThunkActionCreator<A3>]
: TDispatchProps extends [infer A1, infer A2] ? [HandleThunkActionCreator<A1>, HandleThunkActionCreator<A2>]
: TDispatchProps extends [infer A1] ? [HandleThunkActionCreator<A1>]
: TDispatchProps extends Array<infer A> ? Array<HandleThunkActionCreator<A>>
: TDispatchProps extends ReadonlyArray<infer A> ? ReadonlyArray<HandleThunkActionCreator<A>>
: never
;

```

贴一段 typescript （ redux ）的，你感受下。。

难。平时用简单，但是要实现复杂点的东西就麻烦了。
譬如 Objects.equals(Function.<List>identity(),Function.<ArrayList>identity()) 结果是 true 还是 false
再譬如，java.util.stream.BaseStream<T, S extends BaseStream<T, S>>
再譬如，java.util.stream.Collectors.flatMapping(Function<? super T, ? extends Stream<? extends U>> mapper,
Collector<? super U, A, R> downstream)
再譬如，试试把 Stream.flatMap 这个方法加到 BaseStream 里面去。

相对比较艰难

总比 C++好多了

不懂先跳过 后面会好的 忽然开朗的那种

不难 对比 C++的一堆奇奇怪怪的符号看着都头晕

你肯定没用过 cpp 模板元

楼主题目问的是泛型难不难 各位咂就喜欢拿其他语言说事呢。

泛型这个东西 你就不应该代入具体类的思维去看他。或者你看的时候更应该把泛型参数看成一个具体类去理解这样就没这么难。

当你自下而上的看别人的泛型代码的时候非常难，因为那是高度抽象的东西。

你一直先了解整体的一个逻辑架构 设计目的 才能看得通透。

泛型之所以无比蛋疼，就是因为抽象的过程中给他泛型参数也不做限制。

拿一个实例来看才比较贴切

感觉没 C#的好用

cpp 的 template meta programming 了解一下

java 的泛型都是假泛型，Map<String, String> map = new Hashmap<>(); Object o = new String("ajax");map.put("ajax", "js"); 查看字节码实际上还是 Map<Object, Object>, 只是 new 的时候保留泛型元数据信息， 实际上运行时执行
Object o = new String("ajax");map.put （（ String ） o，（ String ）"js"）， 泛型在编译时会检查。

java 的泛型是参数化类型， 假泛型， 在堆中对象还是 Map<Object, Object> ， 本质上还是装箱拆箱的应用，c# 的泛型才是真的。

第一个 put 应该是 map.put(o, "js")

@lhx2008 operator 的参数已经很易懂了 。。。

@waterlaw 是为了字节码向下兼容 dot net 做不到

就是类型参数化，难个锤子

java 只是因为要向下兼容, 所以泛型是假泛型. 运行时会类型擦除, 但是用 map 接收数据库反馈的时候, 倒是会报错类型强制转换异常.

会者不难，难者不会

跟 C++ 的比起来，java 的泛型就是个小玩具，食之无味弃之可惜