tl;dr

将Object对象转换为Integer对象。然后让自动装箱隐式地将Integer对象更改为int原语。

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.
    }
}

自动装箱

你说：
我试着用了cast e.i.（int）
像Vector这样的集合保存的是对象，而不是原语。当您向这样的集合添加一个原始文字（如1或5）时，Java会自动将这些int值转换为 Package 器类Integer的对象。这种转换称为自动装箱。
换句话说，你的代码：

vector.add(2);

...相当于调用Integer.valueOf，返回一个Integer对象：

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

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

Cast

如上所述，您实际上将Integer对象放入Vector中。但是您将Vector声明为保存超类Object的对象。检索时，您将得到Object对象，而不是Integer对象。
必须从Object转换为具体类Integer。

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

如上所述，这个强制转换(Integer)与您的强制转换尝试(int) * 不 * 相同。

December特定类型

但这是对不太理想的代码的修复。如果您的集合中包含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 Collections Framework构建之前。这个类现在是遗留的，正如它的Javadoc中所指出的。

SequencedCollection & ArrayList

相反，使用SequencedCollection实现，如ArrayList。
顺便说一句，为变量使用更具描述性的名称。好的名字会让你的代码更容易阅读，更self-documenting。所以类似于inputs而不是vector。

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

List.of

与其多次调用add，不如使用List.of特性来获得更紧凑的代码。

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

List.of返回的List对象是不可修改的，不允许添加或删除。在你的情况下很管用。

增强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 Tutorials开始。这些是Java 8时代的，所以有点过时，但总体上仍然有效。
另外，我强烈推荐凯西·塞拉、伯特·贝茨、特丽莎·吉的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中，您试图将Object元素直接转换为int，这将导致编译错误。要实现仅打印向量中的奇数的目标，您需要执行以下步骤：
1.遍历Vector<Object>。
1.检查每个元素是否是Integer的示例。
1.如果是Integer，则将其转换为int，然后检查它是否为奇数。
下面是一个修改过的代码版本，它可以实现这一点：

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);
                }
            }
        }
    }
}

在这段代码中，我们使用instanceof操作符来检查一个元素是否是Integer的示例。如果是，我们将其转换为int，然后在打印之前检查它是否是奇数。这样，您将只打印向量中的奇数。