这两种说法有什么区别吗?

发布于 2024-07-24 14:20:15 字数 241 浏览 7 评论 0原文

  1. float ff = 1.2f;
  2. Float fo = new Float(1.2f);
  3. double fg = 3.2d;
  4. Double fh = new Double(2.1d);

我可以在 (1) 和 (3) 之间或 (2) 和 (4) 之间使用“=”吗?

  1. float ff = 1.2f;
  2. Float fo = new Float(1.2f);
  3. double fg = 3.2d;
  4. Double fh = new Double(2.1d);

Can I use '=' between the (1) and (3) or between the (2) and (4)??

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(8

木格 2024-07-31 14:20:16

new Float(1.2f) 每次都会创建一个new Float 对象,消耗内存。

如果您使用工厂方法 Float。 valueOf(1.2f) JVM 可以重用现有的 Float 对象实例以获得相同的值。 仅当尚不存在具有相同值的 Float 实例时,它才能创建新的对象实例。

通常您需要使用 Float.valueOf(1.2f) 而不是 new Float(1.2f)。

另请注意,基元和对象对于等于运算符 == 的工作方式不同。

float x1 = 1.2f;
float x2 = 1.2f;

x1 == x2  // true

Float f1 = new Float(1.2f);
Float f2 = new Float(1.2f);

f1 == f2 // false

new Float(1.2f) creates a new Float object every time, consuming memory.

If you use factory method Float.valueOf(1.2f) JVM may reuse existing Float object instances for the same value. It could create a new object instance only if there isn't already a Float instance with the same value.

Usually you'll want to use Float.valueOf(1.2f) instead of new Float(1.2f).

Also note that primitives and objects work differently with equals operator ==.

float x1 = 1.2f;
float x2 = 1.2f;

x1 == x2  // true

Float f1 = new Float(1.2f);
Float f2 = new Float(1.2f);

f1 == f2 // false
不交电费瞎发啥光 2024-07-31 14:20:16

是的,原始类型不能为 NULL,但对象可以。 此外,Float 对象还附加了许多有用的实用函数。

Yeah primitive types can't be NULL, Objects can. Also the Float object has a bunch of useful utility functions attached to it.

不乱于心 2024-07-31 14:20:16
  1. 通过此声明,您将获得一个原始类型 float 并为其分配一个值。 原始类型是不由其他数据类型组成的数据类型,并且不能进一步拆分(简单解释一下)。 原始类型通常是内置类型。

  2. 在本例中,您创建了一个对象,它的内部由较小的数据类型组成,并且还包含方法。

基元类型 float 和对象类型之间的主要区别在于基元只是数据的一种格式,没有属性或方法。

3=1 可以正常工作,其余则不行。

  1. With this declaration you have a primitive type float and assigned it a value. Primitive type is a datatype that is composed of no other datatype and it cannot be split furthur(to explain it simply). primitive is generally a builtin type.

  2. In this case you have created an object and internally it consists of smaller data types and also contains methods.

Main difference between primitive type float and object type is the primitive is simply a format for data and has no properties or methods.

3=1 will work fine, rest will not.

悲欢浪云 2024-07-31 14:20:16

在实际应用中,我建议您不要使用 float 或 Float,它不是很准确,而且几乎不是正确的解决方案,而是使用 double 或 Double 。

In real applications I suggest you not use float or Float, its not very accurate and almost never the right solution, use double or Double instead.

擦肩而过的背影 2024-07-31 14:20:15

是的。

  1. 创建一个称为“float”的普通旧数据类型(也称为原始类型)。
  2. 创建一个名为 Float 的 Java 对象,它保存的值恰好与 (1) 相同。

回答编辑问题:

如果您尝试 ff = fg,您将看到

  1. “可能丢失精度”消息。
  2. 如果您尝试 fo = fh,则会出现“不兼容的类型”。
  3. fg = ff 可以正常工作(浮点适合双精度)。
  4. fh = fo 仍然会给你一个“不兼容的类型”。

Yes.

  1. Makes a plain old data type (AKA a primitive type) called "float."
  2. Makes a Java Object called Float that holds that value that happens to be identical to (1)

Responding to the edit questions:

You will see

  1. "possible loss of precision" message if you try ff = fg.
  2. "incompatible types" if you try fo = fh.
  3. fg = ff will work fine (the float fits in a double).
  4. fh = fo will still give you an "incompatible types".
×眷恋的温暖 2024-07-31 14:20:15

是的,2 创建了一个对象。

Yes, 2 creates an Object.

网名女生简单气质 2024-07-31 14:20:15

是的,第一个是原始类型,第二个是包装原始浮点类型功能的装箱类,例如我们需要第二个才能在集合中使用。 在您必须处理大量类型转换之前(我认为直到 Java 1.5),现在包装类的存在就具备了这些功能。 更多信息。 此处

Yes, first one is a primitive type and second is a boxing class which wraps capabilities of primitive float type, we need second for example for use in the collections. Before you have had to deal a lot with type conversion (I think until Java 1.5) now the existence of wrappers classes takes those capabilities. More information. here

愿与i 2024-07-31 14:20:15

是的。 第一个声明了一个基本类型 float 的变量并将其初始化为 1.2。

第二个声明了引用类型 Float 的变量,创建了一个 Float 类型的对象,然后为该变量分配了引用。

Yes. The first declares a variable of the primitive type float and initializes it to 1.2.

While the second declares a variable of the reference type Float, creates an object of type Float and then assigns a reference to the variable.

~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文