JAVAJava中的lang.Number类-yiteyi-C++库

大多数时候，在java中处理数字时，我们使用基本数据类型 .但是，Java也提供了各种数字包装纸抽象类编号下的子类出现在 JAVA朗 包裹主要有六数字类下的子类。这些子类定义了一些在处理数字时经常使用的有用方法。

null

objects-numberHierarchy

这些类将基本数据类型“包装”到相应的对象中。通常，包装是由编译器完成的。如果在需要对象的地方使用原语，编译器会在其包装类中为您装箱原语。类似地，如果在需要原语时使用数字对象，编译器会为您解除绑定该对象。这也称为自动装箱和拆箱。 为什么在原始数据上使用数字类对象？

由number类定义的常量（如MIN_VALUE和MAX_VALUE）提供数据类型的上限和下限非常有用。
Number类对象可以用作期望对象的方法的参数（通常在操作数字集合时使用）。
类方法可用于将值转换为其他基元类型或从其他基元类型转换值，转换为字符串或从字符串转换值，以及在数字系统（十进制、八进制、十六进制、二进制）之间进行转换。

所有数字子类通用的方法：

xxx xxxValue（） ：此处xxx表示基本数字数据类型（字节、短、整数、长、浮点、双精度）。此方法用于转换这将对象编号为指定的基元数据类型。

Syntax : byte byteValue()short shortValue()int intValue()long longValue()float floatValue()double doubleValue()Parameters : ----Returns :the numeric value represented by this objectafter conversion to specified type

JAVA

                         //Java program to demonstrate xxxValue() method                       
                         public                                     class                                     Test                       
                         {                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 // Creating a Double Class object with value "6.9685"                       
                                                 Double d =                                     new                                     Double(                                     "6.9685"                                     );                       
                                   
                                                 // Converting this Double(Number) object to                       
                                                 // different primitive data types                       
                                                 byte                                     b = d.byteValue();                       
                                                 short                                     s = d.shortValue();                       
                                                 int                                     i = d.intValue();                       
                                                 long                                     l = d.longValue();                       
                                                 float                                     f = d.floatValue();                       
                                                 double                                     d1 = d.doubleValue();                       
                                   
                                                 System.out.println(                                     "value of d after converting it to byte : "                                     + b);                       
                                                 System.out.println(                                     "value of d after converting it to short : "                                     + s);                       
                                                 System.out.println(                                     "value of d after converting it to int : "                                     + i);                       
                                                 System.out.println(                                     "value of d after converting it to long : "                                     + l);                       
                                                 System.out.println(                                     "value of d after converting it to float : "                                     + f);                       
                                                 System.out.println(                                     "value of d after converting it to double : "                                     + d1);                       
                                                 }                       
                         }                       

输出：

value of d after converting it to byte : 6value of d after converting it to short : 6value of d after converting it to int : 6value of d after converting it to long : 6value of d after converting it to float : 6.9685value of d after converting it to double : 6.9685

笔记：转换时，可能会发生精度损失。例如，我们可以看到，在从双对象转换为int数据类型时，分数部分（“.9685”）被省略了。

int compareTo（NumberSubClass referenceName） ：此方法用于比较这指定参数的数字对象。但是，无法比较两种不同的类型，因此调用该方法的参数和数字对象都应该是同一类型。referenceName可以是字节、双精度、整数、浮点、长或短。

Syntax : public int compareTo( NumberSubClass referenceName )Parameters : referenceName - any NumberSubClass type valueReturns :the value 0 if the Number is equal to the argument.the value 1 if the Number is less than the argument.the value -1 if the Number is greater than the argument.

JAVA

                         //Java program to demonstrate compareTo() method                       
                         public                                     class                                     Test                       
                         {                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 // creating an Integer Class object with value "10"                       
                                                 Integer i =                                     new                                     Integer(                                     "10"                                     );                       
                                   
                                                 // comparing value of i                       
                                                 System.out.println(i.compareTo(                                     7                                     ));                       
                                                 System.out.println(i.compareTo(                                     11                                     ));                       
                                                 System.out.println(i.compareTo(                                     10                                     ));                       
                                                 }                       
                         }                       

输出：

1-10

布尔等于（对象obj） ：此方法确定这 Number对象等于参数。

Syntax : public boolean equals(Object obj)Parameters : obj - any objectReturns :The method returns true if the argument is not null and is an object of the same type and with the same numeric value,otherwise false.

JAVA

                         //Java program to demonstrate equals() method                       
                         public                                     class                                     Test                       
                         {                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 // creating a Short Class object with value "15"                       
                                                 Short s =                                     new                                     Short(                                     "15"                                     );                       
                                   
                                                 // creating a Short Class object with value "10"                       
                                                 Short x =                                     10                                     ;                       
                                   
                                                 // creating an Integer Class object with value "15"                       
                                                 Integer y =                                     15                                     ;                       
                                   
                                                 // creating another Short Class object with value "15"                       
                                                 Short z =                                     15                                     ;                       
                                   
                                                 //comparing s with other objects                       
                                                 System.out.println(s.equals(x));                       
                                                 System.out.println(s.equals(y));                       
                                                 System.out.println(s.equals(z));                       
                                                 }                       
                         }                       

输出：

falsefalsetrue

int parseInt（字符串s，int基数） ：此方法用于获取一串 .基数用于返回十进制（10）、八进制（8）或十六进制（16）等表示形式作为输出。

Syntax : static int parseInt(String s, int radix)Parameters : s - any String representation of decimalradix - any radix valueReturns :the integer value represented by the argument in decimal.Throws :NumberFormatException : if the string does not contain a parsable integer.

JAVA

                         //Java program to demonstrate Integer.parseInt() method                       
                         public                                     class                                     Test                       
                         {                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 // parsing different strings                       
                                                 int                                     z = Integer.parseInt(                                     "654"                                     ,                                     8                                     );                       
                                                 int                                     a = Integer.parseInt(                                     "-FF"                                     ,                                     16                                     );                       
                                                 long                                     l = Long.parseLong(                                     "2158611234"                                     ,                                     10                                     );                       
                                   
                                                 System.out.println(z);                       
                                                 System.out.println(a);                       
                                                 System.out.println(l);                       
                                   
                                                 // run-time NumberFormatException will occur here                       
                                                 // "Geeks" is not a parsable string                       
                                                 int                                     x = Integer.parseInt(                                     "Geeks"                                     ,                                     8                                     );                       
                                   
                                                 // run-time NumberFormatException will occur here                       
                                                 // (for octal(8),allowed digits are [0-7])                       
                                                 int                                     y = Integer.parseInt(                                     "99"                                     ,                                     8                                     );                       
                                   
                                                 }                       
                         }                       

输出：

428-2552158611234Exception in thread "main" java.lang.NumberFormatException: For input string: "Geeks"    at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)    at java.lang.Integer.parseInt(Integer.java:580)    at Test.main(Test.java:17)

int parseInt（字符串s） ：此方法是上述方法的另一种变体，默认情况下，基数为10（十进制）。

Syntax : static int parseInt(String s)Parameters : s - any String representation of decimalReturns :the integer value represented by the argument in decimal.Throws :NumberFormatException : if the string does not contain a parsable integer.

JAVA

                         //Java program to demonstrate Integer.parseInt() method                       
                         public                                     class                                     Test                       
                         {                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 // parsing different strings                       
                                                 int                                     z = Integer.parseInt(                                     "654"                                     );                       
                                                 long                                     l = Long.parseLong(                                     "2158611234"                                     );                       
                                   
                                                 System.out.println(z);                       
                                                 System.out.println(l);                       
                                   
                                                 // run-time NumberFormatException will occur here                       
                                                 // "Geeks" is not a parsable string                       
                                                 int                                     x = Integer.parseInt(                                     "Geeks"                                     );                       
                                   
                                                 // run-time NumberFormatException will occur here                       
                                                 // (for decimal(10),allowed digits are [0-9])                       
                                                 int                                     a = Integer.parseInt(                                     "-FF"                                     );                       
                                   
                                                 }                       
                         }                       

输出：

6542158611234Exception in thread "main" java.lang.NumberFormatException: For input string: "Geeks"    at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)    at java.lang.Integer.parseInt(Integer.java:580)    at java.lang.Integer.parseInt(Integer.java:615)    at Test.main(Test.java:15)

String to字符串（） ：toString（）方法有两种变体。它们用于获取数字的字符串表示形式。这些方法的其他变体包括 整数toBinaryString（国际一级） , 整数tohextstring（inti） , 整数toOctalString（int i） 它将分别返回指定整数（i）的二进制、十六进制和八进制字符串表示形式。

Syntax : String toString()String toString(int i)Parameters : String toString() - no parameterString toString(int i) - i: any integer valueReturns :String toString() -returns a String object representing the value of the Number object on which it is invoked.String toString(int i) -returns a decimal String object representing the specified integer(i)

JAVA

                         //Java program to demonstrate Integer.toString()                       
                         //and Integer.toString(int i) method                       
                         public                                     class                                     Test                       
                         {                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 // demonstrating toString() method                       
                                                 Integer x =                                     12                                     ;                       
                                   
                                                 System.out.println(x.toString());                       
                                   
                                                 // demonstrating toString(int i) method                       
                                                 System.out.println(Integer.toString(                                     12                                     ));                       
                                   
                                                 System.out.println(Integer.toBinaryString(                                     152                                     ));                       
                                                 System.out.println(Integer.toHexString(                                     152                                     ));                       
                                                 System.out.println(Integer.toOctalString(                                     152                                     ));                       
                                                 }                       
                         }                       

输出：

12121001100098230

整数值（） ：valueOf（）方法有三种变体。这三种方法都返回一个整数对象，该对象包含一个基本整数的值。

Syntax : Integer valueOf(int i)Integer valueOf(String s)Integer valueOf(String s, int radix)Parameters : i - any integer values - any String representation of decimalradix - any radix valueReturns :valueOf(int i) : an Integer object holding the valuerepresented by the int argument.valueOf(String s) : an Integer object holding value represented by the string argument.valueOf(String s, int radix) : an Integer object holding the value represented by the string argument with base radix.Throws :valueOf(String s) -NumberFormatException : if the string does not contain a parsable integer.valueOf(String s, int radix) -NumberFormatException : if the string does not contain a parsable integer.

JAVA

                         // Java program to demonstrate valueOf() method                       
                         public                                     class                                     Test                       
                         {                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 // demonstrating valueOf(int i) method                       
                                                 System.out.println(                                     "Demonstrating valueOf(int i) method"                                     );                       
                                                 Integer i =Integer.valueOf(                                     50                                     );                       
                                                 Double d = Double.valueOf(                                     9.36                                     );                       
                                                 System.out.println(i);                       
                                                 System.out.println(d);                       
                                   
                                                 // demonstrating valueOf(String s) method                       
                                                 System.out.println(                                     "Demonstrating valueOf(String s) method"                                     );                       
                                                 Integer n = Integer.valueOf(                                     "333"                                     );                       
                                                 Integer m = Integer.valueOf(                                     "-255"                                     );                       
                                                 System.out.println(n);                       
                                                 System.out.println(m);                       
                                   
                                                 // demonstrating valueOf(String s,int radix) method                       
                                                 System.out.println(                                     "Demonstrating (String s,int radix) method"                                     );                       
                                                 Integer y = Integer.valueOf(                                     "333"                                     ,                                     8                                     );                       
                                                 Integer x = Integer.valueOf(                                     "-255"                                     ,                                     16                                     );                       
                                                 Long l = Long.valueOf(                                     "51688245"                                     ,                                     16                                     );                       
                                                 System.out.println(y);                       
                                                 System.out.println(x);                       
                                                 System.out.println(l);                       
                                   
                                                 // run-time NumberFormatException will occur in below cases                       
                                                 Integer a = Integer.valueOf(                                     "Geeks"                                     );                       
                                                 Integer b = Integer.valueOf(                                     "Geeks"                                     ,                                     16                                     );                       
                                                 }                       
                         }                       

输出：

Demonstrating valueOf(int i) method509.36Demonstrating valueOf(String s) method333-255Demonstrating (String s,int radix) method219-5971365803589Exception in thread "main" java.lang.NumberFormatException: For input string: "Geeks"    at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)    at java.lang.Integer.parseInt(Integer.java:580)    at java.lang.Integer.valueOf(Integer.java:766)    at Test.main(Test.java:28)

练习问题： 给定java代码的输出是什么？

JAVA

                         public                                     class                                     Test                       
                         {                       
                                                 public                                     static                                     void                                     main(String[] args)                       
                                                 {                       
                                                 Integer i = Integer.parseInt(                                     "Kona"                                     ,                                     27                                     );                       
                                                 System.out.println(i);                       
                                                 }                       
                         }                       

选项：

A) NumberFormatException at run-timeB) NumberFormatException at compile-timeC) 411787

答复:

C) 411787

说明： 因为基数是27，所以字符串文字中允许的字符是[0-9]，[a-Q]（用于10到26）。因此，其值的计算如下： =>a*（27^0）+n*（27^1）+o*（27^2）+k*（27^3） => 10*1 + 23*27 + 24*27*27 + 20*27*27*27 => 10 + 621 + 17496 + 393660 => 411787 本文由 高拉夫·米格拉尼 .如果你喜欢GeekSforgek，并想贡献自己的力量，你也可以使用写极客。组织或者把你的文章寄去评论-team@geeksforgeeks.org.看到你的文章出现在Geeksforgeks主页上，并帮助其他极客。如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写下评论。

文章版权归作者所有，未经允许请勿转载。

THE END

Java