java中的向量只包含对象？_Java_Oop_Vector

java中的向量只包含对象？

java oop vector

java中的向量只包含对象？,java,oop,vector,Java,Oop,Vector,我有这个问题, java中的向量只接受对象，对吗？但这段代码编译得很好 Vector myv=new Vector(); myv.addElement(1); myv.addElement(1); 它是否将其封装为整数对象？如果是这样，为什么这句话 System.out.println(myv.elementAt(0)==myv.elementAt(1)); 真的吗？！！！它们应该是两个不同的物体同时，该语句抛出一个错误，确保元素是一个对象 int x=myv.elementAt(0);

我有这个问题,

java中的向量只接受对象，对吗？但这段代码编译得很好

Vector myv=new Vector();
myv.addElement(1);
myv.addElement(1);

它是否将其封装为整数对象？如果是这样，为什么这句话

System.out.println(myv.elementAt(0)==myv.elementAt(1));

真的吗？！！！它们应该是两个不同的物体

同时，该语句抛出一个错误，确保元素是一个对象

int x=myv.elementAt(0);

有人能给我解释一下吗？谢谢。

这叫做自动装箱。当Java编译器在预期对象的位置遇到整数、浮点或双精度值时，它会自动创建一个包装器对象

编译器为您的代码生成的代码与

Vector myv=new Vector();
myv.addElement(Integer.valueOf(1));
myv.addElement(Integer.valueOf(1));

valueOf方法缓存从-128到127 IIRC的值的整数实例，结果是两个值都将被同一个对象替换

尝试使用更大的值，如1000。然后对象将不同。

这称为自动装箱。当Java编译器在预期对象的位置遇到整数、浮点或双精度值时，它会自动创建一个包装器对象

编译器为您的代码生成的代码与

Vector myv=new Vector();
myv.addElement(Integer.valueOf(1));
myv.addElement(Integer.valueOf(1));

valueOf方法缓存从-128到127 IIRC的值的整数实例，结果是两个值都将被同一个对象替换

尝试使用更大的值，如1000。然后对象将不同。

1将自动装箱为整数。要了解有关自动装箱和取消装箱的更多信息，请参阅Oracle的文档：

关于它们相同的原因：将整数自动装箱到整数使用缓存。对于小于128的数字，我认为每次都会返回相同的整数对象，而不是创建一个新的整数对象。因此，您的代码实际上将同一个对象插入到向量中两次，因此，使用==的标识比较返回true

由于在向量中不使用泛型，因此myv.elementAt0将返回一个无法转换为int的对象。如果使用泛型，即Vector myv=new Vector，则elementAt将返回一个将自动取消装箱为int的整数。

1将自动装箱为整数。要了解有关自动装箱和取消装箱的更多信息，请参阅Oracle的文档：

由于在向量中不使用泛型，因此myv.elementAt0将返回一个无法转换为int的对象。如果使用泛型，即Vector myv=new Vector，则elementAt将返回一个整数，该整数将自动取消绑定为int。

这是有效的，因为java会自动为您设置并自动取消绑定这些类型

但请注意，这并不是在每种情况下都能肯定有效

让我们举一个例子：

Integer i = 1234;
Integer z = 1234;

System.out.println("i: "+i);
System.out.println("z: "+z);
System.out.println("== : "+(i == z));
System.out.println("equals: "+i.equals(z));

它将产生以下输出：

i: 1234
z: 1234
== : false
equals: true

事实上，从中可以看出，它只适用于-128和+127之间的整数

事实上，这与预期一样：

Integer i = 123;
Integer z = 123;

System.out.println("i: "+i);
System.out.println("z: "+z);
System.out.println("== : "+(i == z));
System.out.println("equals: "+i.equals(z));

并生产：

i: 123
z: 123
== : true
equals: true

这是因为java自动装箱和自动取消装箱为您提供了这些类型

但请注意，这并不是在每种情况下都能肯定有效

让我们举一个例子：

Integer i = 1234;
Integer z = 1234;

System.out.println("i: "+i);
System.out.println("z: "+z);
System.out.println("== : "+(i == z));
System.out.println("equals: "+i.equals(z));

它将产生以下输出：

i: 1234
z: 1234
== : false
equals: true

事实上，从中可以看出，它只适用于-128和+127之间的整数

事实上，这与预期一样：

Integer i = 123;
Integer z = 123;

System.out.println("i: "+i);
System.out.println("z: "+z);
System.out.println("== : "+(i == z));
System.out.println("equals: "+i.equals(z));

并生产：

i: 123
z: 123
== : true
equals: true

Java的向量是一个泛型，它意味着它可以接受任何类型的数据来存储。必须使用类似矢量的语法指定要保存的数据类型。替换要向量保持的对象类型的字符串

它之所以为true，是因为它自动装箱到Integer类中；当比较两个整数时，其方式与内置类型int相同

编辑：自动装箱比较适用于[-128；+127]范围内的int值。

Java的向量是泛型，这意味着它可以接受任何类型的数据进行存储。必须使用类似矢量的语法指定要保存的数据类型。替换要向量保持的对象类型的字符串

它之所以为true，是因为它自动装箱到Integer类中；当比较两个整数时，其方式与内置类型int相同

编辑：自动装箱比较适用于[-128；+127]范围内的int值。

Java有一个非常有趣的地方，它缓存了-128和127之间的整数，用于自动/取消装箱，对该范围内整数的任何引用都引用同一个对象，因为==此处正在比较对象。当人们不通过==方法比较对象而不是值时，这可能会导致相当多的错误

因此，在比较-128之间的自动装箱整数时，将得到true - 127. 如果你对128做同样的事情，它会说false

请查看：

import java.util.Vector;                                                                                                                                                                                    

public class Vect {
    public static void main(String[] args) {
        Vector v = new Vector();
        v.addElement(127);
        v.addElement(127);
        v.addElement(128);
        v.addElement(128);

        System.out.println(v.elementAt(0) == v.elementAt(1));
        System.out.println(v.elementAt(2) == v.elementAt(3));
    }   
}

将为您提供：

$ java Vect 
true
false

Java有一个非常有趣的地方，它缓存了-128和127之间的整数，用于自动/取消装箱，该范围内的任何整数引用都引用同一个对象，因为这里==正在比较对象。当人们不通过==方法比较对象而不是值时，这可能会导致相当多的错误

因此，在比较-128-127之间的自动装箱整数时，将得到true。如果你对128做同样的事情，它会说false

请查看：

import java.util.Vector;                                                                                                                                                                                    

public class Vect {
    public static void main(String[] args) {
        Vector v = new Vector();
        v.addElement(127);
        v.addElement(127);
        v.addElement(128);
        v.addElement(128);

        System.out.println(v.elementAt(0) == v.elementAt(1));
        System.out.println(v.elementAt(2) == v.elementAt(3));
    }   
}

将为您提供：

$ java Vect 
true
false

这是编译代码和自动装箱的一个特性

Java中的泛型是编译时问题。javac使用它们来检查您是否正确使用了这些类型，但是生成的编译字节码对泛型类型一无所知。在Java中，泛型的实现主要是为了向后兼容。这也是Java中仍然存在原始类型的原因

这意味着一个向量在运行时看起来像一个普通的原始向量——它只是一个包含对象的普通向量。因为基本体不是对象，所以不能在这样的向量中存储基本体类型

每个基本类型都有包装类int->Integer、long->long、short->short、boolean->boolean等。因此，可以使用向量将int存储在整型对象中，整型对象可以存储在向量中。。。但是Java语言的设计者并没有决定将自动装箱做得那么远。

这是编译代码和自动装箱的一个特性

每个基本类型都有包装类int->Integer、long->long、short->short、boolean->boolean等。因此，可以使用向量将int存储在整型对象中，整型对象可以存储在向量中。。。但是Java语言的设计者们并没有决定把自动装箱做得这么远。

你不应该再使用向量了，使用ArrayList。如果您需要线程安全性，那么可以使用内置的各种选项来实现这一点。有一些很好的解释。我知道，我只是想了解这件具体的事情。不管怎样，谢谢。向量已经过时了。和这个问题一样，虽然可能不是重复的，因为上下文不同，也只接受对象-有点。。。你可以使用泛型，这样向量甚至不会接受对象，但这不是你真正的问题。你不应该再使用向量，使用ArrayList。如果您需要线程安全性，那么可以使用内置的各种选项来实现这一点。有一些很好的解释。我知道，我只是想了解这件具体的事情。不管怎样，谢谢。向量已经过时了。和这个问题一样，虽然可能不是重复的，因为上下文不同，也只接受对象-有点。。。您可以使用泛型，这样向量甚至不会接受对象对象，但这不是您真正的问题。如果编译器真的会生成两个新的整数对象，那么第二个代码示例将不起作用。实际上，自动装箱有点复杂，并且使用缓存，因此它甚至会将同一个对象放入列表两次，而不是两个不同/新的对象。你是对的，我错过了关于相等的部分。但是，整数缓存逻辑不在自动装箱中，而是在Integer.valorOfint中。如果编译器真的会生成两个新的整数对象，那么第二个代码示例将无法工作。实际上，自动装箱有点复杂，并且使用缓存，因此它甚至会将同一个对象放入列表两次，而不是两个不同/新的对象。你是对的，我错过了关于相等的部分。但是，整数缓存逻辑不在自动装箱中，而是在Integer.valorOfint中。我会修正我的例子。its-128 t 127可用于@Programmer：如果你认为答案适合你的问题，请接受正确答案。its-128 t 127可用于@Programmer：如果你认为答案适合你的问题，请接受正确答案。比较两个整数时，它与内置类型int的方式相同。这并不准确-它只是-128和127之间的值，与缓存的值相比，它们实际上是相同的对象==。感谢@nerdwaller提供的数据，现在更新了答案；当比较两个整数时，其方式与中的内置类型相同

T这并不准确——只有-128和127之间的值被缓存，与==相比实际上是同一个对象；谢谢你的详细解释！谢谢你的详细解释！