正在检查空集合的Java集合泛型类型

我想实现以下功能：

public boolean checkType(Vector<?> vec)
{
  // return true if its Vector<Integer> and false otherwise
}

公共布尔校验类型（向量向量）
{
//如果其向量为true，则返回true，否则返回false
}

如何检查向量元素类型？ 注意向量可能为空，因此我无法检查第一个元素是“instanceof”整数还是字符串

编辑：

嗯，我有个主意，我不知道它会不会奏效

我是否可以按以下方式实现checkType功能：

public <T> boolean checkType(Vector<T> vec)
{
  // return true if T is Integer and false otherwise
}

公共布尔校验类型（向量向量）
{
//如果T是整数，则返回true，否则返回false
}

是否可以检查T是否为整数

提前感谢

公共布尔校验类型（向量向量向量）
public boolean checkType(Vector<?> vec)
{
  if(!vec.isEmpty())
  {
    if("String".equals(vec.get(0).getClass().getSimpleName()))
             return false;
    else if("Integer".equals(vec.get(0).getClass().getSimpleName()))
             return true;               
   }
}

{
如果（！vec.isEmpty（））
{
if（“String”.equals（vec.get（0.getClass（）.getSimpleName（）））
返回false；
else if（“Integer”.equals（vec.get（0.getClass（）.getSimpleName（）））
返回true；
}
}

---

希望这有帮助

任何告诉你这是可能的人都是错误的。在运行时，无法判断空向量是

向量

还是

向量

---

这或多或少是类型擦除的定义。

泛型类型参数在运行时不可恢复（某些特殊情况除外），原因是。这意味着在运行时，

Vector

和

Vector

都只是

Vector

s，它们的元素只是

对象

引用

只有单个元素的实际运行时类（如您所指出的，可通过

instanceof

检查发现）才构成元素类型的概念，否则向量本身不知道它的元素类型是什么

所以基本上，任何类型的空向量都等于任何其他类型的空向量。甚至可以这样施展：

Vector<String> noStrings = (Vector<String>) new Vector<Integers>();

public <T> boolean checkType(Vector<T> vec) {
    return T instanceof Integer; // impossible
    return T == Integer; // impossible
    return T.class == Integer.class // impossible
    return vec instanceof (Vector<Integer>); // impossible
}

List<?> list1 = Arrays.asList(1, 2, 3);
List<?> list2 = Arrays.asList(1, 2, 3, "a");
System.out.println(checkElementType(list1, Integer.class)); // true
System.out.println(checkElementType(list2, Integer.class)); // false

Vector noStrings=（Vector）new Vector（）；

但是有一个问题，因为尽管您可以说emptyvector符合任何必需的元素类型，但只要向量保持为空，该语句就有效。因为如果你这样做：

Vector<Integer> ints = new Vector<Integer>(); // empty
Vector<String> strings = (Vector<String>) ints; // unchecked warning, but still possibly ok
ints.add(1); // here comes trouble
String s = strings.get(1); // oh oh, ClassCastException

Vector ints=new Vector（）；//空的
向量字符串=（向量）整数；//未选中警告，但仍可能正常
内加（1）；//麻烦来了
String s=strings.get（1）；//哦，哦，这是个例外

编辑： 回答你的第二个问题：不，不可能这样写：

Vector<String> noStrings = (Vector<String>) new Vector<Integers>();

public <T> boolean checkType(Vector<T> vec) {
    return T instanceof Integer; // impossible
    return T == Integer; // impossible
    return T.class == Integer.class // impossible
    return vec instanceof (Vector<Integer>); // impossible
}

List<?> list1 = Arrays.asList(1, 2, 3);
List<?> list2 = Arrays.asList(1, 2, 3, "a");
System.out.println(checkElementType(list1, Integer.class)); // true
System.out.println(checkElementType(list2, Integer.class)); // false

公共布尔校验类型（向量向量）{
返回T instanceof Integer；//不可能
返回T==整数；//不可能
返回T.class==Integer.class//不可能
返回vec instanceof（Vector）；//不可能
}

但是，您可以编写使用类标记作为输入参数的方法：

static <T> boolean checkElementType(Collection<?> collection, Class<T> elementType) {
    for (Object object : collection) {
        if (!elementType.isAssignableFrom(object.getClass())) {
            return false;
        }
    }
    return true;
}

静态布尔checkElementType（集合集合，类elementType）{
用于（对象：集合）{
如果（！elementType.isAssignableFrom（object.getClass（）））{
返回false；
}
}
返回true；
}

然后你可以这样使用它：

Vector<String> noStrings = (Vector<String>) new Vector<Integers>();

public <T> boolean checkType(Vector<T> vec) {
    return T instanceof Integer; // impossible
    return T == Integer; // impossible
    return T.class == Integer.class // impossible
    return vec instanceof (Vector<Integer>); // impossible
}

List<?> list1 = Arrays.asList(1, 2, 3);
List<?> list2 = Arrays.asList(1, 2, 3, "a");
System.out.println(checkElementType(list1, Integer.class)); // true
System.out.println(checkElementType(list2, Integer.class)); // false

List list1=Arrays.asList（1,2,3）；
list2=Arrays.asList（1,2,3，“a”）；
System.out.println（checkElementType（list1，Integer.class））；//真的
System.out.println（checkElementType（list2，Integer.class））；//假的

由于类型擦除，这是不可能的

即使向量不是空的，集合库也不能真正防止将不同类型的内容放入：

    Vector v = new Vector<Integer>();
    v.add("foo");
    System.out.println(v.get(0));

---

-1：这个问题非常明确地询问了一个空向量，并包含了一些注释，清楚地表明OP知道如何处理非空向量。如果向量可能是空的，我认为没有必要检查泛型类型，如果向量是例如

向量

，则返回什么？对，错，半对？老实说，这不是一个很好的设计。@anand，我只是想知道是否有办法在不检查向量中随机元素的类型的情况下检查泛型类型…@Natix，如果不是向量，您可以返回false。。。这不是重点，真的。。。你能首先检查泛型类型吗？那么你的意思是，除非集合中至少有一个元素，否则无法检查泛型类型？即使有元素，此检查也不可靠。感谢提供的信息性答案：）。。。我编辑了我的问题，请看一下。。。如果我错了，请通知我me@TeFa：您更新的问题的答案仍然是“不，那是不可能的。”