我想我会把这个垒球提供给任何想把它打出公园的人。什么是泛型，泛型的优点是什么，为什么，在哪里，如何使用它们？请保持相当基本。谢谢。
【问题讨论】：
write code which is applicable to many types with the same underlying behavior
【讨论】：
我真的很讨厌重复自己。我讨厌比我必须更频繁地输入相同的东西。我不喜欢多次重复有细微差别的事情。
而不是创建：
class MyObjectList {
MyObject get(int index) {...}
}
class MyOtherObjectList {
MyOtherObject get(int index) {...}
}
class AnotherObjectList {
AnotherObject get(int index) {...}
}
我可以构建一个可重用的类...（在您出于某种原因不想使用原始集合的情况下）
class MyList<T> {
T get(int index) { ... }
}
我现在的效率提高了 3 倍，而且我只需要维护一份副本。为什么不想维护更少的代码？
这也适用于非集合类，例如必须与其他类交互的Callable<T> 或Reference<T>。您真的要扩展 Callable<T> 和 Future<T> 以及所有其他关联的类来创建类型安全的版本吗？
我没有。
【讨论】：
不需要类型转换是 Java 泛型的最大优势之一，因为它会在编译时执行类型检查。这将减少ClassCastExceptions 在运行时被抛出的可能性，并且可以产生更健壮的代码。
但我怀疑你完全知道这一点。
每次我查看泛型时，它都会给出 我头疼。我发现最好的部分 Java 是它的简单性和最小化 语法和泛型并不简单 添加大量新的 句法。
起初，我也没有看到泛型的好处。我从 1.4 的语法开始学习 Java（虽然当时 Java 5 已经出来了），当我遇到泛型时，我觉得要写更多的代码，我真的不明白它的好处。
现代 IDE 让使用泛型编写代码变得更加容易。
大多数现代、体面的 IDE 都足够智能，可以帮助编写带有泛型的代码，尤其是代码完成。
这是一个使用HashMap 制作Map<String, Integer> 的示例。我必须输入的代码是：
Map<String, Integer> m = new HashMap<String, Integer>();
确实，为了创建一个新的HashMap，需要输入很多内容。然而，实际上，在 Eclipse 知道我需要什么之前，我只需要输入这么多：
Map<String, Integer> m = new Ha Ctrl+空格
没错，我确实需要从候选列表中选择 HashMap，但基本上 IDE 知道要添加什么，包括泛型类型。使用正确的工具，使用泛型并不算太糟糕。
此外，由于类型是已知的，当从泛型集合中检索元素时，IDE 将表现得好像该对象已经是其声明类型的对象——不需要强制转换让 IDE 知道什么对象的类型是。
泛型的一个关键优势在于它与 Java 5 的新特性配合得很好。下面是一个将整数放入 Set 并计算其总数的示例：
Set<Integer> set = new HashSet<Integer>();
set.add(10);
set.add(42);
int total = 0;
for (int i : set) {
total += i;
}
在那段代码中，存在三个新的 Java 5 特性：
首先，泛型和基元的自动装箱允许以下行：
set.add(10);
set.add(42);
整数10 被自动装箱成一个Integer，其值为10。 （42 也一样）。然后Integer 被扔进已知持有Integers 的Set。尝试抛出 String 会导致编译错误。
接下来，for-each 循环采用所有这三个：
for (int i : set) {
total += i;
}
首先，包含Integers 的Set 用于for-each 循环。每个元素都被声明为int，这是允许的，因为Integer 被拆箱回原语int。并且这种拆箱发生的事实是众所周知的，因为泛型用于指定 Integers 保存在 Set 中。
泛型可以成为将 Java 5 中引入的新功能结合在一起的粘合剂，它只是让编码更简单、更安全。而且大多数时候 IDE 足够聪明，可以帮助您提出好的建议，所以一般情况下，它不会多输入很多内容。
坦率地说，从Set 示例中可以看出，我觉得利用 Java 5 的特性可以使代码更加简洁和健壮。
编辑 - 没有泛型的示例
下面是上面Set 例子的说明，没有使用泛型。这是可能的，但并不完全令人愉快：
Set set = new HashSet();
set.add(10);
set.add(42);
int total = 0;
for (Object o : set) {
total += (Integer)o;
}
（注意：以上代码会在编译时产生未经检查的转换警告。）
使用非泛型集合时，输入到集合中的类型是Object 类型的对象。因此，在本例中，Object 就是 add 编入集合中的内容。
set.add(10);
set.add(42);
在上面几行中，自动装箱正在发挥作用——原始 int 值 10 和 42 被自动装箱到 Integer 对象中，这些对象被添加到 Set 中。但是，请记住，Integer 对象被作为Objects 处理，因为没有类型信息可以帮助编译器知道Set 应该期望什么类型。
for (Object o : set) {
这是至关重要的部分。 for-each 循环起作用的原因是Set 实现了Iterable 接口，该接口返回带有类型信息的Iterator（如果存在）。 （即Iterator<T>。）
但是，由于没有类型信息，Set 将返回一个Iterator，它将Set 中的值返回为Objects，这就是为什么在 for-每个循环必须为Object类型。
现在Object 是从Set 中检索到的，需要手动将其转换为Integer 以执行添加：
total += (Integer)o;
在这里，从Object 到Integer 执行类型转换。在这种情况下，我们知道这将始终有效，但是手动类型转换总是让我觉得它是脆弱的代码，如果在其他地方进行微小的更改可能会损坏。 （我觉得每个类型转换都是一个等待发生的ClassCastException，但我离题了......）
Integer 现在被拆箱成int 并允许执行添加到int 变量total。
我希望我可以说明 Java 5 的新特性可以与非泛型代码一起使用，但它不像使用泛型编写代码那样干净和直接。而且，在我看来，要充分利用 Java 5 中的新特性，应该研究泛型，至少允许编译时检查以防止无效类型转换在运行时引发异常。
【讨论】：
如果您在 1.5 发布之前搜索 Java 错误数据库，您会发现 NullPointerException 的错误是 ClassCastException 的七倍。因此，查找错误，或者至少在经过少量冒烟测试后仍然存在的错误似乎并不是一个很棒的功能。
对我来说，泛型的巨大优势在于它们在代码中记录了重要的类型信息。如果我不想在代码中记录类型信息，那么我会使用动态类型语言，或者至少是一种具有更隐式类型推断的语言。
将对象的集合保留给自己并不是一种糟糕的风格（但常见的风格是有效地忽略封装）。这取决于你在做什么。将集合传递给“算法”使用泛型更容易检查（在编译时或之前）。
【讨论】：
Java 中的泛型有助于parametric polymorphism。通过类型参数，您可以将参数传递给类型。就像String foo(String s) 这样的方法模拟一些行为，不仅针对特定字符串，而且针对任何字符串s，所以像List<T> 这样的类型模拟一些行为，不仅针对特定类型，而是为任何类型。 List<T> 表示对于任何类型T，都有一个类型为List，其元素是Ts。所以List 实际上是一个类型构造函数。它将一个类型作为参数并构造另一个类型作为结果。
这里有几个我每天使用的泛型类型的例子。首先，一个非常有用的通用接口：
public interface F<A, B> {
public B f(A a);
}
这个接口表示对于某些两种类型，A 和B，有一个函数（称为f）接受一个A 并返回一个B。 当你实现这个接口，A 和B 可以是你想要的任何类型，只要你提供一个函数f 接受前者并返回后者。这是接口的示例实现：
F<Integer, String> intToString = new F<Integer, String>() {
public String f(int i) {
return String.valueOf(i);
}
}
在泛型之前，多态性是通过子类化使用extends 关键字来实现的。使用泛型，我们实际上可以取消子类化并使用参数多态性。例如，考虑一个用于计算任何类型的哈希码的参数化（通用）类。我们将使用这样的通用类，而不是覆盖 Object.hashCode()：
public final class Hash<A> {
private final F<A, Integer> hashFunction;
public Hash(final F<A, Integer> f) {
this.hashFunction = f;
}
public int hash(A a) {
return hashFunction.f(a);
}
}
这比使用继承灵活得多，因为我们可以保持使用组合和参数多态的主题，而无需锁定脆弱的层次结构。
尽管如此，Java 的泛型并不完美。例如，您可以抽象类型，但不能抽象类型构造函数。也就是说，你可以说“对于任何类型 T”，但不能说“对于任何带有类型参数 A 的类型 T”。
I wrote an article about these limits of Java generics, here.
泛型的一个巨大优势是它们可以让您避免子类化。子类化往往会导致难以扩展的脆弱类层次结构，以及不查看整个层次结构就难以单独理解的类。
在泛型之前，您可能有 FooWidget、BarWidget 和 BazWidget 扩展的类，如 Widget，使用泛型，您可以有一个泛型类 Widget<A>，它采用 Foo、@987654349 @ 或 Baz 在其构造函数中为您提供 Widget<Foo>、Widget<Bar> 和 Widget<Baz>。
【讨论】：
泛型避免了装箱和拆箱对性能的影响。基本上，看看 ArrayList 与 List
【讨论】：
泛型的最大好处是代码重用。假设您有很多业务对象，并且您将为每个实体编写非常相似的代码来执行相同的操作。 （I.E Linq to SQL 操作）。
使用泛型，您可以创建一个类，该类将能够操作给定从给定基类继承的任何类型或实现给定接口，如下所示：
public interface IEntity
{
}
public class Employee : IEntity
{
public string FirstName { get; set; }
public string LastName { get; set; }
public int EmployeeID { get; set; }
}
public class Company : IEntity
{
public string Name { get; set; }
public string TaxID { get; set }
}
public class DataService<ENTITY, DATACONTEXT>
where ENTITY : class, IEntity, new()
where DATACONTEXT : DataContext, new()
{
public void Create(List<ENTITY> entities)
{
using (DATACONTEXT db = new DATACONTEXT())
{
Table<ENTITY> table = db.GetTable<ENTITY>();
foreach (ENTITY entity in entities)
table.InsertOnSubmit (entity);
db.SubmitChanges();
}
}
}
public class MyTest
{
public void DoSomething()
{
var dataService = new DataService<Employee, MyDataContext>();
dataService.Create(new Employee { FirstName = "Bob", LastName = "Smith", EmployeeID = 5 });
var otherDataService = new DataService<Company, MyDataContext>();
otherDataService.Create(new Company { Name = "ACME", TaxID = "123-111-2233" });
}
}
请注意在上述 DoSomething 方法中给定不同类型的相同服务的重用。真优雅！
在你的工作中使用泛型还有很多其他重要的理由，这是我最喜欢的。
【讨论】：
我只是喜欢它们，因为它们为您提供了一种快速定义自定义类型的方法（因为我仍然使用它们）。
因此，例如，您不必定义由字符串和整数组成的结构，然后必须实现一整套对象和方法，以了解如何访问这些结构的数组等等，您可以只创建一个 Dictionary
Dictionary<int, string> dictionary = new Dictionary<int, string>();
编译器/IDE 会完成其余的繁重工作。尤其是 Dictionary 允许您使用第一种类型作为键（无重复值）。
【讨论】：
类型化集合 - 即使您不想使用它们，您也可能不得不从其他库、其他来源处理它们。
类创建中的通用类型：
公共类 Foo
避免选角——我一直不喜欢像
这样的东西新的比较器{ 公共 int compareTo（对象 o）{ if (o instanceof classIcareAbout)...
您实际上是在检查一个只应该存在的条件，因为接口是用对象表示的。
我对泛型的最初反应与你的相似——“太混乱、太复杂”。我的经验是，在使用它们一段时间后，你会习惯它们，没有它们的代码感觉不太明确，而且不太舒服。除此之外，java 世界的其他地方都在使用它们，所以你最终将不得不使用这个程序，对吧？
【讨论】：
举一个很好的例子。想象一下，你有一个名为 Foo 的类
public class Foo
{
public string Bar() { return "Bar"; }
}
示例 1 现在你想要一个 Foo 对象的集合。您有两个选项，LIst 或 ArrayList，它们的工作方式相似。
Arraylist al = new ArrayList();
List<Foo> fl = new List<Foo>();
//code to add Foos
al.Add(new Foo());
f1.Add(new Foo());
在上面的代码中，如果我尝试添加一个 FireTruck 类而不是 Foo，ArrayList 会添加它，但 Foo 的 Generic List 会导致抛出异常。
示例二。
现在您有了两个数组列表，并且您想在每个列表上调用 Bar() 函数。由于 hte ArrayList 中充满了对象，因此您必须先转换它们，然后才能调用 bar。但是由于 Foo 的 Generic List 只能包含 Foos，因此您可以直接在它们上调用 Bar()。
foreach(object o in al)
{
Foo f = (Foo)o;
f.Bar();
}
foreach(Foo f in fl)
{
f.Bar();
}
【讨论】：
您是否曾经编写过一个方法（或一个类），其中方法/类的关键概念没有与参数/实例变量的特定数据类型紧密绑定（想想链表、最大/最小函数、二分查找等）。
你有没有希望你可以重用算法/代码而不诉诸剪切-粘贴重用或损害强类型（例如，我想要 List 的字符串，而不是 List 的东西我 hope 是字符串！）？
这就是为什么您应该想要使用泛型（或更好的东西）。
【讨论】：
不要忘记泛型不仅仅被类使用，它们也可以被方法使用。比如下面的sn-p：
private <T extends Throwable> T logAndReturn(T t) {
logThrowable(t); // some logging method that takes a Throwable
return t;
}
它很简单，但可以非常优雅地使用。好消息是该方法返回它给出的任何内容。这有助于您处理需要重新抛出给调用者的异常：
...
} catch (MyException e) {
throw logAndReturn(e);
}
关键是通过方法传递类型不会丢失类型。您可以抛出正确类型的异常，而不仅仅是 Throwable，这将是您在没有泛型的情况下所能做的一切。
这只是泛型方法的一种用途的简单示例。使用泛型方法可以做很多其他巧妙的事情。在我看来，最酷的是使用泛型进行类型推断。举个例子（摘自 Josh Bloch 的 Effective Java 2nd Edition）：
...
Map<String, Integer> myMap = createHashMap();
...
public <K, V> Map<K, V> createHashMap() {
return new HashMap<K, V>();
}
这并没有多大作用，但是当泛型类型很长（或嵌套；即Map<String, List<String>>）时，它确实减少了一些混乱。
【讨论】：
Throwable。另一种方法是编写单独的方法来返回每种异常类型，或者使用返回Throwable 的非泛型方法自己进行转换。前者过于冗长且毫无用处，后者不会从编译器中获得任何帮助。通过使用泛型，编译器会自动为您插入正确的转换。所以，问题是：这值得复杂吗？
正如 Mitchel 指出的那样，主要优势是无需定义多个类的强类型化。
通过这种方式，您可以执行以下操作：
List<SomeCustomClass> blah = new List<SomeCustomClass>();
blah[0].SomeCustomFunction();
如果没有泛型，您必须将 blah[0] 转换为正确的类型才能访问其功能。
【讨论】：
无论如何，jvm 都会强制转换...它隐式创建将泛型类型视为“对象”的代码，并创建对所需实例的强制转换。 Java 泛型只是语法糖。
【讨论】：
我知道这是一个 C# 问题，但 generics 也用于其他语言，它们的用途/目标非常相似。
Java 集合从 Java 1.5 开始使用 generics。因此，使用它们的好地方是当您创建自己的类似集合的对象时。
我几乎在任何地方都能看到的一个例子是 Pair 类，它包含两个对象，但需要以通用方式处理这些对象。
class Pair<F, S> {
public final F first;
public final S second;
public Pair(F f, S s)
{
first = f;
second = s;
}
}
每当您使用这个 Pair 类时，您都可以指定您希望它处理哪种类型的对象，并且任何类型转换问题都会在编译时而不是运行时出现。
泛型也可以使用关键字“super”和“extends”定义其边界。例如，如果你想处理一个泛型类型，但你想确保它扩展了一个名为 Foo 的类（它有一个 setTitle 方法）：
public class FooManager <F extends Foo>{
public void setTitle(F foo, String title) {
foo.setTitle(title);
}
}
虽然它本身不是很有趣，但知道当您处理 FooManager 时，您知道它将处理 MyClass 类型，并且 MyClass 扩展了 Foo，这很有用。
【讨论】：
来自 Sun Java 文档，以回应“我为什么要使用泛型？”：
"泛型为您提供了一种将集合的类型传达给编译器的方法，以便对其进行检查。一旦编译器知道集合的元素类型，编译器就可以检查您是否一致地使用了该集合并且可以在从集合中取出的值上插入正确的强制转换...使用泛型的代码更清晰、更安全....编译器可以在编译时验证在运行时没有违反类型约束 [强调我的]。因为程序编译时没有警告，我们可以肯定地说它不会在运行时抛出 ClassCastException。使用泛型的净效果，特别是在大型程序中，提高了可读性和稳健性。[强调我的]"
【讨论】：
泛型允许您创建强类型的对象，但您不必定义特定类型。我认为最有用的例子是 List 和类似的类。
使用通用列表，您可以拥有任何您想要的列表列表，并且您始终可以引用强类型，您不必转换或像使用数组或标准列表那样做任何事情。
【讨论】：
泛型允许您对应该能够容纳任何对象的对象和数据结构使用强类型。在从通用结构（装箱/拆箱）中检索对象时，它还消除了繁琐且昂贵的类型转换。
使用这两种方法的一个例子是链表。如果链表类只能使用对象 Foo，它会有什么好处？要实现可以处理任何类型对象的链表，如果您希望列表仅包含一种类型的对象，则链表和假设节点内部类中的节点必须是通用的。
【讨论】：
如果您的集合包含值类型，则它们在插入集合时不需要对对象进行装箱/取消装箱，因此您的性能会显着提高。 resharper 等很酷的插件可以为您生成更多代码，例如 foreach 循环。
【讨论】：
使用泛型（尤其是集合/列表）的另一个优点是您可以获得编译时类型检查。这在使用通用列表而不是对象列表时非常有用。
【讨论】：
最重要的一个原因是它们提供了类型安全
List<Customer> custCollection = new List<Customer>;
相反，
object[] custCollection = new object[] { cust1, cust2 };
作为一个简单的例子。
【讨论】：
总之，泛型允许您更精确地指定您打算做什么（更强的类型化）。
这对您有几个好处：
因为编译器更了解你想要做什么，它允许你省略很多类型转换，因为它已经知道类型是兼容的。
这还可以让您更早地获得有关程序正确性的反馈。以前在运行时会失败的事情（例如，因为无法将对象转换为所需的类型），现在在编译时会失败，您可以在测试部门提交神秘的错误报告之前修复错误。
编译器可以做更多的优化，比如避免装箱等
【讨论】：
需要添加/扩展的几件事（从 .NET 的角度来看）：
泛型类型允许您创建基于角色的类和接口。这已经在更基本的术语中说过，但我发现您开始使用以与类型无关的方式实现的类来设计代码 - 这会产生高度可重用的代码。
方法上的通用参数可以做同样的事情，但它们也有助于将“告诉不要问”原则应用于强制转换，即“给我我想要的，如果你不能，你告诉我为什么” .
【讨论】：
我在一个用 SpringORM 和 Hibernate 实现的 GenericDao 中使用它们，看起来像这样
public abstract class GenericDaoHibernateImpl<T>
extends HibernateDaoSupport {
private Class<T> type;
public GenericDaoHibernateImpl(Class<T> clazz) {
type = clazz;
}
public void update(T object) {
getHibernateTemplate().update(object);
}
@SuppressWarnings("unchecked")
public Integer count() {
return ((Integer) getHibernateTemplate().execute(
new HibernateCallback() {
public Object doInHibernate(Session session) {
// Code in Hibernate for getting the count
}
}));
}
.
.
.
}
通过使用泛型，我对这个 DAO 的实现迫使开发人员仅通过子类化 GenericDao 将它们设计的实体传递给它们
public class UserDaoHibernateImpl extends GenericDaoHibernateImpl<User> {
public UserDaoHibernateImpl() {
super(User.class); // This is for giving Hibernate a .class
// work with, as generics disappear at runtime
}
// Entity specific methods here
}
我的小框架更健壮（有过滤、延迟加载、搜索等功能）。我这里只是简化了给大家举个例子
我和史蒂夫和你一样，一开始就说“太杂乱了”，但现在我看到了它的优点
【讨论】：
已经提到了诸如“类型安全”和“无强制转换”之类的明显好处，所以也许我可以谈谈其他一些“好处”，希望对您有所帮助。
首先，泛型是一个独立于语言的概念，而且，IMO，如果您同时考虑常规（运行时）多态性，它可能更有意义。
例如，我们从面向对象设计中知道的多态性有一个运行时概念，其中调用者对象在运行时随着程序执行的进行而被计算出来，并根据运行时类型相应地调用相关方法。在泛型中，这个想法有点相似，但一切都发生在编译时。这是什么意思以及你如何使用它？
（让我们坚持使用泛型方法以保持其紧凑性）这意味着您仍然可以在不同的类上使用相同的方法（就像您之前在多态类中所做的那样）但是这次它们是由编译器自动生成的，取决于在编译时设置的类型。你在编译时给你的类型参数化你的方法。因此，不像在运行时多态性（方法覆盖）中所做的那样，为每个单一类型从头开始编写方法，而是让编译器在编译期间完成工作。这有一个明显的优势，因为您不需要推断系统中可能使用的所有可能类型，这使得它在不更改代码的情况下更具可扩展性。
类的工作方式几乎相同。您将类型参数化，代码由编译器生成。
一旦您有了“编译时间”的概念，您就可以使用“有界”类型，并限制可以通过类/方法作为参数化类型传递的内容。因此，您可以控制要传递的内容，这是一个强大的东西，尤其是您有一个被其他人使用的框架。
public interface Foo<T extends MyObject> extends Hoo<T>{
...
}
现在除了MyObject之外没有人可以设置。
此外，您可以对方法参数“强制”类型约束，这意味着您可以确保两个方法参数都依赖于相同的类型。
public <T extends MyObject> foo(T t1, T t2){
...
}
希望所有这些都有意义。
【讨论】：
我曾经就这个话题发表过演讲。你可以在http://www.adventuresinsoftware.com/generics/找到我的幻灯片、代码和录音。
【讨论】：
对集合使用泛型非常简单明了。即使您在其他任何地方都使用它，从收藏中获得的收益对我来说也是一种胜利。
List<Stuff> stuffList = getStuff();
for(Stuff stuff : stuffList) {
stuff.do();
}
对比
List stuffList = getStuff();
Iterator i = stuffList.iterator();
while(i.hasNext()) {
Stuff stuff = (Stuff)i.next();
stuff.do();
}
或
List stuffList = getStuff();
for(int i = 0; i < stuffList.size(); i++) {
Stuff stuff = (Stuff)stuffList.get(i);
stuff.do();
}
仅此一项就值得仿制药的边际“成本”，而且您不必成为仿制药大师即可使用它并获得价值。
【讨论】：
泛型还使您能够创建更多可重用的对象/方法，同时仍提供特定于类型的支持。在某些情况下，您还会获得很多性能。我不知道 Java 泛型的完整规范，但在 .NET 中，我可以对 Type 参数指定约束，例如实现接口、构造函数和派生。
【讨论】：
使程序员能够实现泛型算法 - 通过使用泛型，程序员可以实现适用于不同类型集合、可以自定义、类型安全且更易于阅读的泛型算法。
编译时更强的类型检查 - Java 编译器对泛型代码应用强类型检查并在代码违反类型安全时发出错误。修复编译时错误比修复运行时错误更容易，后者很难找到。
消除演员表。
【讨论】：