blocks|key|4488033|text|这里的不同之处在于，在第二个版本中，您有一个类型变量T，它引用List包含的Set的特定子类型。在需要确保其他类型与列表中包含的类型相同的情况下，需要使用它。下面是几个简单的例子：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4488034|//+want+to+ensure+that+the+method+returns+the+same+type+contained+in+the+list
public+<T+extends+Set>+T+something(List<T>+list)+{
++...
}

//+want+to+ensure+both+lists+contain+the+exact+same+type
public+<T+extends+Set>+List<T>+somethingElse(List<T>+first,+List<T>+second)+{
++...
}|code-block|syntax|javascript|4488035|简单规则：如果在两个地方需要相同的类型，则在方法签名中使用类型变量T+extends+Foo。方法参数是一个地方，方法返回类型是另一个地方。如果您只需要确保在一个地方处理“某个东西是一个Foo”，请使用通配符?+extends+Foo。|BOLD|4488036|旁白:不要使用原始类型Set。|4488037|entityMap^0|Q|1|V|4|12|3|0|0|0|5|X|D|2L|3|2W|D|0|B|3|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Z|8|@$9|10|A|11|B|M]|$9|12|A|13|B|C]|$9|14|A|15|B|C]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|N|3|O|5|6|7|18|8|@$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|P|3|-4|5|6|7|1B|8|@]|D|@]|E|$]]]|Q|$]]

The difference here is that in the second version, you have a type variable <code>T</code> that refers to the specific subtype of <code>Set</code> that the <code>List</code> contains. You need this in cases where you need to ensure that something else is the same type as the type contained in the list. A couple simple examples:

<pre><code>// want to ensure that the method returns the same type contained in the list
public &lt;T extends Set&gt; T something(List&lt;T&gt; list) {
 ...
}

// want to ensure both lists contain the exact same type
public &lt;T extends Set&gt; List&lt;T&gt; somethingElse(List&lt;T&gt; first, List&lt;T&gt; second) {
 ...
}
</code></pre>

Simple rule: Use a type variable <code>T extends Foo</code> in your method signature if the same type is necessary in two places. Method parameters are each one place and the method return type is another place. Use the wildcard <code>? extends Foo</code> if you just need to ensure you're dealing with "something that is a <code>Foo</code>" in one place.

Aside: don't use the raw type <code>Set</code>.

blocks|key|947204|text|在声明varlable时使用List<?+extends+Set>。例如：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|947205|List<?+extends+Number>+l+=+new+ArrayList<Integer>();|code-block|syntax|javascript|947206|List<T+extends+Number>可以在类或方法声明中使用。这将允许您稍后在函数中编写T而不是<?+extends+Number>。|947207|public+<T+extends+Number>+int+addAll(List<T>+list)+{
++++int+result+=+0;
++++for+(T+t+:+list)+{
++++++++result+%2B=+t.intValue();
++++}
++++return+result;
}|947208|entityMap^0|E|J|0|0|0|M|1G|I|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|P|$]]

You use <code>List&lt;? extends Set&gt;</code> when you declare a varlable. For example:

<pre><code>List&lt;? extends Number&gt; l = new ArrayList&lt;Integer&gt;();
</code></pre>

<code>List&lt;T extends Number&gt;</code> can be used in class or methode declaration. This will allow you to write T instead of <code>&lt;? extends Number&gt;</code> later on in the function.

<pre><code>public &lt;T extends Number&gt; int addAll(List&lt;T&gt; list) {
 int result = 0;
 for (T t : list) {
 result += t.intValue();
 }
 return result;
}
</code></pre>

blocks|key|704805|text|有两个原因：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|704806|避免不必要的强制转换的：|offset|length|style|BOLD|704807|对于这样的情况，您必须使用T变体：|CODE|704808|public+<T+extends+Set>+T+firstOf(List<T>+l)+{
++++return+l.get(0);
}|code-block|syntax|javascript|704809|对于?，这将变成：|704810|public+Set+firstOf2(List<?+extends+Set>+l)+{
++++return+l.get(0);
}|704811|...which不会向firstOf方法的调用者提供相同数量的信息。第一个版本允许调用者这样做：|704812|SubSet+first+=+firstOf(listOfSubSet);|704813|而在第二个版本中，您必须使用强制转换来使其编译：|704814|SubSet+first+=+(SubSet)firstOf(listOfSubSet);|704815|704816|强制匹配参数类型的：|704817|public+<T+extends+Set>+boolean+compareSets(List<T>+a,+List<T>+b)+{
++++boolean+same+=+true;
++++for(T+at+:+a)+{
++++++++for+(T+bt:+b)+{
+++++++++++++same+&=+at.equals(bt);
++++++++}
++++}
++++return+same;
}|704818|对于这一点，使用?而不是T没有直接的等价物。请注意，由于Java的单分派，在上面的版本中，编译器将调用at的equals(T)方法，该方法很可能与at的equals(Set)或equals(Object)方法不同。|704819|entityMap^0|0|B|1|0|D|1|0|0|2|1|0|0|B|7|0|0|0|0|0|9|1|0|0|8|1|C|1|1F|2|1I|9|21|2|24|B|2G|E|0^^$0|@$1|2|3|4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1B|8|@$D|1C|E|1D|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|1E|8|@$D|1F|E|1G|F|J]]|9|@]|A|$]]|$1|K|3|L|5|M|7|1H|8|@]|9|@]|A|$N|O]]|$1|P|3|Q|5|6|7|1I|8|@$D|1J|E|1K|F|J]]|9|@]|A|$]]|$1|R|3|S|5|M|7|1L|8|@]|9|@]|A|$N|O]]|$1|T|3|U|5|6|7|1M|8|@$D|1N|E|1O|F|J]]|9|@]|A|$]]|$1|V|3|W|5|M|7|1P|8|@]|9|@]|A|$N|O]]|$1|X|3|Y|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|Z|3|10|5|M|7|1R|8|@]|9|@]|A|$N|O]]|$1|11|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]|$1|12|3|13|5|6|7|1T|8|@$D|1U|E|1V|F|G]]|9|@]|A|$]]|$1|14|3|15|5|M|7|1W|8|@]|9|@]|A|$N|O]]|$1|16|3|17|5|6|7|1X|8|@$D|1Y|E|1Z|F|J]|$D|20|E|21|F|J]|$D|22|E|23|F|J]|$D|24|E|25|F|J]|$D|26|E|27|F|J]|$D|28|E|29|F|J]|$D|2A|E|2B|F|J]]|9|@]|A|$]]|$1|18|3|-4|5|6|7|2C|8|@]|9|@]|A|$]]]|19|$]]

Two reasons:

To avoid unnecessary casts:

You have to use the <code>T</code> variant for cases like this:

<pre><code>public &lt;T extends Set&gt; T firstOf(List&lt;T&gt; l) {
 return l.get(0);
}
</code></pre>

With <code>?</code> this would become:

<pre><code>public Set firstOf2(List&lt;? extends Set&gt; l) {
 return l.get(0);
}
</code></pre>

...which doesn't give the same amount of information to the caller of the <code>firstOf</code> method. The first version allows the caller to do this:

<pre><code>SubSet first = firstOf(listOfSubSet);
</code></pre>

while with the second version, you are forced to use a cast to make it compile:

<pre><code>SubSet first = (SubSet)firstOf(listOfSubSet);
</code></pre>

<hr>

To enforce matching argument types:

<pre><code>public &lt;T extends Set&gt; boolean compareSets(List&lt;T&gt; a, List&lt;T&gt; b) {
 boolean same = true;
 for(T at : a) {
 for (T bt: b) {
 same &amp;= at.equals(bt);
 }
 }
 return same;
}
</code></pre>

There is no direct equivalent using <code>?</code> instead of <code>T</code> for this. Note that due to Java's single-dispatch, in the above version, the compiler will call <code>at</code>'s <code>equals(T)</code> method which may well differ from <code>at</code>'s <code>equals(Set)</code> or <code>equals(Object)</code> method.

blocks|key|947233|text|我们使用通配符来指定type元素匹配任何内容。?代表未知类型。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|947234|List<?+extends+Set>是有界通配符的一个例子，声明list可以接受Set的任何子类型(例如HashSet)+List<T+extends+Set>，另一方面，允许T被绑定到扩展Set的类型。|947235|当我需要一个数据集合而不考虑它的确切类型时，我使用通配符。|947236|entityMap^0|N|1|0|0|J|15|3|1H|7|1Q|J|2H|1|2O|3|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|11|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|K|$]]

We use wildcards to specify that the type element matches anything. The <code>?</code> stands for unknown type.

<code>List&lt;? extends Set&gt;</code> is an example of a bounded wildcard and that states that the list can accept any subtype of a <code>Set</code> (e.g. <code>HashSet</code>)
<code>List&lt;T extends Set&gt;</code>, on the other hand is, allows <code>T</code> to be bounded to a type that extends <code>Set</code>.

I use wildcards when I need a collection of data irrespective pf it's exact type.

blocks|key|947245|text|通配符类型G<?+extends+A>是任何G<Ai>的超类型，其中Ai是A的子类型|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|947246|换句话说，G<?+extends+A>是G<A0>,+...,+G<An>的联合类型。|947247|entityMap^0|5|E|M|5|Y|2|11|1|0|5|E|K|H|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|I|$]]

A wildcard type <code>G&lt;? extends A&gt;</code> is a super type of any <code>G&lt;Ai&gt;</code> where <code>Ai</code> is a subtype of <code>A</code>

In another word, <code>G&lt;? extends A&gt;</code> is the union type of <code>G&lt;A0&gt;, ..., G&lt;An&gt;</code>.

I have a question on the use of wildcards in Java's generic types: what is the basic difference between <code>List&lt;? extends Set&gt;</code> and <code>List&lt;T extends Set&gt;</code>? When would I use either?

java Generics Wildcard

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有一个关于在Java泛型类型中使用通配符的问题：List<? extends Set>和List<T extends Set>之间的基本区别是什么？我什么时候可以使用这两种方法？

问java泛型通配符
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问java泛型通配符EN