tl;博士

将对象投射到对象。然后让自动装箱隐式地将对象更改为原始对象。ObjectIntegerIntegerint

int d = ( Integer ) vector.get(i);  // Cast `Object` to `Integer`, then implicit auto-boxing to `int`. 

更好的是，修改你的代码：

SequencedCollection < Integer > inputs = List.of ( 1 , 2 , 5 , 6 );
for ( Integer input : inputs )
{
    if ( input % 2 != 0 )
    {
        System.out.println ( input );  // Print odd numbers.
    }
}

自动装箱

你说：

我尝试使用强制转换 e.i. （int）

集合，例如保存对象，而不是基元。当您将原始文字（例如 或）添加到此类集合时，Java 会自动将这些值转换为包装类的对象。这种转换称为自动装箱。Vector15intInteger

换言之，您的代码：

vector.add(2);

...等效于调用 Integer.valueOf，返回一个对象：Integer

vector.add( Integer.valueOf( 1 ) );  // Making an `Integer` object from a primitive `int`. 

调用返回一个对象，而不是基元。所以你的演员阵容毫无意义。强制转换不能跨越基元和对象之间的鸿沟。跨越这个鸿沟是拳击的工作。vector.get(i)(int)

投

如上所述，您实际上将对象放入 .但是你声明了 as 持有超类 Object 的对象。检索时，您得到的是对象而不是对象。IntegerVectorVectorObjectInteger

您必须从 转换为具体类。ObjectInteger

Integer d = (Integer) vector.get(i) ;

如上所述，此投射与您的投射尝试不同。(Integer)(int)

声明特定类型

但这是对你不太理想的代码的修复。如果您的收藏品包含物品，请说出来。Integer

您无需重复作业右侧的类型;编译器可以从左侧推断出这一事实。Integer

Vector < Integer > vector = new Vector <> ( );

在指定了更具体的类型后，我们不再需要该强制转换。

Integer d = inputs.get ( i );  // Retrieving an `Integer` object from a known list of `Integer` objects. So no cast needed.

避免上课Vector

另一个问题：Vector 是 Java 最早版本的旧类，在 Java 集合框架构建之前。该类现在是遗留的，正如其 Javadoc 中所述。

SequencedCollection & ArrayList

请改用 SequencedCollection 实现，例如 ArrayList。

顺便说一句，为变量使用更具描述性的名称。好的名字使你的代码更易于阅读，也更易于自记录。所以像而不是.inputsvector

SequencedCollection < Integer > inputs = new ArrayList<>() ;

List.of

不要多次调用，而应使用 List.of 功能来获取更紧凑的代码。add

SequencedCollection < Integer > inputs = List.of ( 1 , 2 , 5 , 6 );

返回的对象是不可修改的，不允许添加或删除。这适用于您的情况。ListList.of

增强循环for

若要简单地遍历集合，可以使用增强循环。for

for ( Integer input : inputs )

所以现在我们的代码看起来像这样：

package work.basil.example;

import java.util.List;
import java.util.SequencedCollection;

public class Nums
{
    public static void main ( String[] args )
    {
        SequencedCollection < Integer > inputs = List.of ( 1 , 2 , 5 , 6 );
        System.out.println ( "Inputs: " + inputs );
        for ( Integer input : inputs )
        {
            if ( input % 2 == 0 )
            {
                System.out.println ( input );
            }
        }
    }
}

结果：

输入：[1， 2， 5， 6]

2

6

!表示不是

你说：

我想要的是只打印出奇数

通过应用 来翻转测试的逻辑。if!

if ( ! ( input % 2 == 0 ) ) { … odd number … }

或者，更简单地说，用于“不等于”：!=

if ( input % 2 != 0 )

---

您似乎正在使用一个非常古老的教程。我强烈建议使用最新的学习材料。

您可以从 Oracle.com 的免费 Java 教程开始。这些是来自 Java 8 时代的，所以有点过时，但总体上仍然有效。

另外，我强烈推荐 Kathy Sierra、Bert Bates、Trisha Gee 合著的 Head First Java， 3rd Edition。

---

流

最终，您可能会学会使用流。

喜欢这个：

List
        .of ( 1 , 2 , 5 , 6 )
        .stream ( )
        .filter ( input -> input % 2 == 0 )
        .forEach ( System.out :: println );

或者，这个：

SequencedCollection < Integer > inputs =
        Stream
                .of ( 1 , 2 , 5 , 6 )
                .filter (
                        ( Integer integer ) -> integer % 2 == 0
                )
                .toList ( );

在 Java 中，您尝试将元素直接转换为 ，这将导致编译错误。要实现仅打印矢量中的奇数的目标，您需要执行以下步骤：Objectint

1. 遍历 .Vector<Object>
2. 检查每个元素是否是 的实例。Integer
3. 如果是 ，则将其投射到，然后检查它是否奇怪。Integerint

下面是实现此目的的代码的修改版本：Here's a modified version of your code that accomplishes this：

import java.util.Vector;

public class Main {
    public static void main(String[] args) {
        Vector<Object> vector = new Vector<Object>();
        vector.add(1);
        vector.add(2);
        vector.add(5);
        vector.add(6);
        
        System.out.println("\nThe Vector is: " + vector);
        
        for (int i = 0; i < vector.size(); i++) {
            Object obj = vector.get(i);
            if (obj instanceof Integer) {
                int d = (int) obj;
                if (d % 2 != 0) {
                    System.out.println(d);
                }
            }
        }
    }
}

在此代码中，我们使用运算符来检查元素是否是 的实例。如果是，我们将其转换为，然后在打印之前检查它是否为奇数。这样，您只会打印矢量中的奇数。instanceofIntegerint