Java泛型中有联合吗？
我可以在一个集合中包含两种不同的类型吗？例如，我可以得到列表Java泛型中有联合吗？,java,generics,Java,Generics,我可以在一个集合中包含两种不同的类型吗？例如，我可以得到列表？的简短答案吗？不可以。您（当然）可以拥有对象的列表，但您可以在其中放入任何内容，而不仅仅是字符串或整数对象 您可以创建一个容器对象列表，该容器对象将包含整数或字符串（可能通过泛型）。多一点麻烦 public class Contained<T> { T getContained(); } 包含的公共类{ T getContained（）； } 并实现包含的和包含的 当然，真正的问题是你为什么要这样做？我希望集合包
对象的列表，但您可以在其中放入任何内容，而不仅仅是字符串或整数对象
您可以创建一个容器对象列表，该容器对象将包含整数
或字符串
（可能通过泛型）。多一点麻烦
public class Contained<T> {
T getContained();
}
包含的公共类{
T getContained（）；
}
并实现包含的
和包含的
当然，真正的问题是你为什么要这样做？我希望集合包含相同类型的对象，然后我可以迭代这些对象并对其执行操作，而不用担心它们是什么。也许您的对象层次结构需要进一步考虑？不需要。不过，您有两种选择：
- 你可以使用一个列表
- 您可以使用一个列表
，并将数据放入其中一个类成员中
编辑：示例
class UnionHolder {
public String stringValue;
public int intValue;
}
List < UnionHolder > myList
...
不可以。这样想：对于泛型，整个想法是提供类型安全性。如果您可以将不同类型的对象放入其中，则这是不可能的
您可以使用非泛型的java.util.List
来实现您的目的
如果要确保只有String
或Integer
对象进入列表，可以创建自己的列表实现，如下所示：
public class MySpecialList {
private List list= new LinkedList();
...
public void add(final String string) {
list.add(string);
}
public void add(final Integer integer) {
list.add(integer);
}
...
// add rest of List style methods
}
缺点：除了已经提供的好答案之外，您还失去了列表
界面清晰性…
您的算法中可能有这两种数据类型。但是您可能不必将它们放在同一个列表中…
创建两个类型化列表对于您的算法来说可能更清晰，您仍然可以保持“类型安全性”并携带所有数据。接下来是两个代码示例，第二个示例将MyData对象中的两个列表分组
public class Algorithm1 {
public void process(List<String> strings, List<Integer> integers) {
...
}
}
--------------------------------------
public class DataPair {
public List<String> strings;
public List<Integer> integers;
}
public class Algorithm2 {
public void process(DataPair dataPair) {
...
}
}
公共类算法1{
公共作废进程（列表字符串、列表整数）{
...
}
}
--------------------------------------
公共类数据对{
公共列表字符串；
公共列表整数；
}
公共类算法2{
公共作废进程（数据对数据对）{
...
}
}
如果您正在使用Java 8或更高版本进行函数式编程，您可能需要尝试：
Union2.Factory=GenericUnions.doubletFactory（）；
Union2 strElem=工厂。首先（“你好”）；
Union2 intElem=工厂。第二（3）；
List=Array.asList（strElem，intElem）；
对于（Union2要素：列表）{
继续(
strElem->System.out.println（“字符串：“+strElem”），
intElem->System.out.println（“整数：+intElem”）；
}
我还没有测试过这个，但我认为你已经有了想法。你所描述的是
- 100%静态类型检查
- 不需要Java8或更高版本
用法：
List<UnionType> unionTypes = Arrays
.asList(new StringContainer("hello"), new IntegerContainer(4));
for (UnionType unionType : unionTypes) {
unionType.when(new UnionType.Cases<Integer>() {
@Override
public Integer is(StringContainer stringContainer) {
// type-specific handling code
}
@Override
public Integer is(IntegerContainer integerContainer) {
// type-specific handling code
}
});
}
List unionTypes=数组
.asList（新的StringContainer（“hello”），新的IntegerContainer（4））；
对于（UnionType UnionType:unionTypes）{
unionType.when（新unionType.Cases（）{
@凌驾
公共整数为（StringContainer StringContainer）{
//类型特定处理代码
}
@凌驾
公共整数是（IntegerContainer IntegerContainer）{
//类型特定处理代码
}
});
}
样板代码：
接口类型{
R（c类情况）；
接口案例{
R是（StringContainer-StringContainer）；
R是（整合素容器整合素容器）；
}
}
类StringContainer实现UnionType{
私有最终字符串值；
公共StringContainer（字符串值）{this.value=value；}
公共字符串getValue（）{return value；}
@凌驾
公共R（案例）{
返回案例。是（本）；
}
}
类IntegerContainer实现UnionType{
私有最终整数值；
公共整数容器（整数值）{this.value=value；}
公共整数getValue（）{return value；}
@凌驾
公共R（案例）{
返回案例。是（本）；
}
}
您能解释一下第二个选项吗？一个相反的问题：为什么在一个集合中会有两种不同的类型？@BalusC-我遇到的这种构造的一个用例是模型对象。e、 g.在REST API中，与数据传输对象（DTO）相对应，该对象用oneOf
字段表示protobuf消息。中的一个本质上是一个联合体。它可以包含许多指定的不同类型之一。这些类型中任何一种的值都会占用相同的内存，并且一次只能存储一种类型。它似乎类似于C中的联合。
Union2.Factory<String, Integer> factory = GenericUnions.doubletFactory();
Union2<String, Integer> strElem = factory.first("hello");
Union2<String, Integer> intElem = factory.second(3);
List<Union2<String, Integer>> list = Array.asList(strElem, intElem);
for (Union2<String, Integer> elem : list) {
elem.continued(
strElem -> System.out.println("string: " + strElem),
intElem -> System.out.println("integer: " + intElem));
}
List<UnionType> unionTypes = Arrays
.asList(new StringContainer("hello"), new IntegerContainer(4));
for (UnionType unionType : unionTypes) {
unionType.when(new UnionType.Cases<Integer>() {
@Override
public Integer is(StringContainer stringContainer) {
// type-specific handling code
}
@Override
public Integer is(IntegerContainer integerContainer) {
// type-specific handling code
}
});
}