Java-007-Number&Math类和Character类

p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; line-height: 14.0px; font: 14.0px "Yuanti SC"; color: #000000 }
span.s1 { }

一、 Number 类

p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; line-height: 14.0px; font: 14.0px "Yuanti SC"; color: #000000 }
span.s1 { }

一般地，当需要使用数字的时候，我们通常使用内置数据类型，如：byte、int、long、double 等。

int a = 5000; float b = 13.65f; byte c = 0x4a;

然而，在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情形。为了解决这个问题，Java 语言为每一个内置数据类.型提供了对应的包装类

所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类.

p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; line-height: 14.0px; font: 14.0px "Yuanti SC"; color: #000000 }
span.s1 { }

这种由编译器特别支持的包装称为装箱，所以当内置数据类型被当作对象使用的时候，编译器会把内置类型装箱为包装类。相似的，编译器也

可以把一个对象拆箱为内置类型。Number 类属于 java.lang 包.

下面是一个使用 Integer 对象的实例：

Integer x = 5;
x =  x + 10;
System.out.println(x);

p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 14.0px "Yuanti SC"; color: #000000 }
span.s1 { color: #000000 }
span.s2 { }

//当 x 被赋为整型值时，由于x是一个对象，所以编译器要对x进行装箱。然后，为了使x能进行加运算，所以要对x进行拆箱

p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; line-height: 14.0px; font: 14.0px "Yuanti SC"; color: #000000 }
span.s1 { }

二、 Math 类

Java 的 Math 包含了用于执行基本数学运算的属性和方法，如初等指数、对数、平方根和三角函数.

Math 的方法都被定义为 static 形式，通过 Math 类可以在主函数中直接调用。

System.out.println("90 度的正弦值：" + Math.sin(Math.PI/2));
System.out.println("0度的余弦值：" + Math.cos(0));
System.out.println("60度的正切值：" + Math.tan(Math.PI/3));
System.out.println("1的反正切值： " + Math.atan(1));
System.out.println("π/2的角度值：" + Math.toDegrees(Math.PI/2));
System.out.println(Math.PI);
/*
    90 度的正弦值：1.0
    0度的余弦值：1.0
    60度的正切值：1.7320508075688767
    1的反正切值： 0.7853981633974483
    π/2的角度值：90.0
    3.141592653589793
 */

p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 14.0px "Yuanti SC"; color: #000000 }
p.p2 { margin: 0.0px 0.0px 0.0px 0.0px; font: 14.0px "Yuanti SC"; color: #000000; min-height: 20.0px }

Number & Math 类方法

下面的表中列出的是 Number & Math 类常用的一些方法：

p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 14.0px "Yuanti SC"; color: #000000 }

//①xxxValue() 方法

Integer x = 5;
// 返回 byte 原生数据类型
System.out.println( x.byteValue() );

// 返回 double 原生数据类型
System.out.println(x.doubleValue());

// 返回 long 原生数据类型
System.out.println( x.longValue() );

p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 14.0px "Yuanti SC"; color: #000000 }

//②compareTo() 方法

/*
将 Number 对象与方法的参数进行比较
语法：public int compareTo( NumberSubClass referenceName )

//如果指定的数与参数相等返回0。

//如果指定的数小于参数返回 -1。

//如果指定的数大于参数返回 1。

 */
System.out.println(x.compareTo(3));//1
System.out.println(x.compareTo(5));//0
System.out.println(x.compareTo(8));//-1

p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 14.0px "Yuanti SC"; color: #000000 }

//③equals() 方法

//判断 Number 对象与方法的参数进是否相等
//如 Number 对象不为 Null，且与方法的参数类型与数值都相等返回 True，否则返回 False。
Integer y = 10;
Integer z =5;
Short a = 5;
System.out.println(x.equals(y));//false
System.out.println(x.equals(z));//true
System.out.println(x.equals(a));//false

p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 14.0px "Yuanti SC"; color: #000000 }

//④valueOf() 方法

//返回给定参数的原生 Number 对象值，参数可以是原生数据类型, String等
//该方法是静态方法。该方法可以接收两个参数一个是字符串，一个是基数。
/*
语法：
static Integer valueOf(int i)
static Integer valueOf(String s)
static Integer valueOf(String s, int radix)
i -- Integer 对象的整数。
s -- Integer 对象的字符串。
radix --在解析字符串 s 时使用的基数，用于指定使用的进制数

Integer valueOf(int i)：返回一个表示指定的 int 值的 Integer 实例。
Integer valueOf(String s):返回保存指定的 String 的值的 Integer 对象。
Integer valueOf(String s, int radix): 返回一个 Integer 对象，该对象中保存了用第二个参数提供的基数进行解析时从指定的 String 中提取的值。
 */

Double c = Double.valueOf(5);
Integer b = Integer.valueOf("444",16);   // 使用 16 进制
System.out.println(c);//5.0
System.out.println(b);//1092

p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 14.0px "Yuanti SC"; color: #000000 }

//⑤toString()

//以字符串形式返回值。
// 返回 string 原生字符串类型
System.out.println( x.toString() );

p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 14.0px "Yuanti SC"; color: #000000 }

//⑥parseInt() 方法

//将字符串参数作为有符号的十进制整数进行解析
int e =Integer.parseInt("9");
double f = Double.parseDouble("5");
int g = Integer.parseInt("444",16);

System.out.println(e);//9
System.out.println(f);//5.0
System.out.println(g);//1092

p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 14.0px "Yuanti SC"; color: #000000 }

//⑦abs() 方法

//返回参数的绝对值。参数可以是 int, float, long, double, short, byte类型
double d = -100;
System.out.println(Math.abs(d));//100.0

p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 14.0px "Yuanti SC"; color: #000000 }

//⑧ceil() 方法

//可对一个数进行上舍入，返回值大于或等于给定的参数
double h = 100.675;
float i = -90;
System.out.println("h=="+Math.ceil(h));//101.0
System.out.println("i == " + Math.ceil(i));//-90.0

p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 14.0px "Yuanti SC"; color: #000000 }

//floor() 方法

//对一个数进行下舍入，返回给定参数最大的整数，该整数小于或等给定的参数
System.out.println("h=="+Math.floor(h));//100.0
System.out.println("i == " + Math.floor(i));//-90.0

p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 14.0px "Yuanti SC"; color: #000000 }

//rint() 方法

//返回最接近参数的整数值。
System.out.println(Math.rint(h));//101.0

p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 14.0px "Yuanti SC"; color: #000000 }

//round() 方法

//返回一个最接近的int、long型值
System.out.println(Math.round(h));//101

p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 14.0px "Yuanti SC"; color: #000000 }

//min() 方法

//返回两个参数中的最小值。
System.out.println(Math.min(h, i));//-90.0

p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 14.0px "Yuanti SC"; color: #000000 }

//max() 方法

//返回两个参数中的最大值。
System.out.println(Math.max(h, i));//100.675

p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 14.0px "Yuanti SC"; color: #000000 }

//exp() 方法

//返回自然数底数e的参数次方。
double j = 11.635;
System.out.printf("j 的值为 %.4f%n", Math.E);//j 的值为 2.7183
System.out.printf("exp(%.3f) 为 %.3f%n", j, Math.exp(j));//exp(11.635) 为 112983.831

//sin()
//求指定double类型参数的正弦值。
//     cos()
//求指定double类型参数的余弦值。
//     tan()
//求指定double类型参数的正切值。
//     asin()
//求指定double类型参数的反正弦值。
//     acos()
//求指定double类型参数的反余弦值。
//     atan()
//求指定double类型参数的反正切值。
//     atan2()
//将笛卡尔坐标转换为极坐标，并返回极坐标的角度值

p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 14.0px "Yuanti SC"; color: #000000 }

//⑨toDegrees()

//将参数转化为角度。
double k = 45.0;
System.out.println( Math.toDegrees(k) );//2578.3100780887044

//toRadians() 方法
//将角度转换为弧度。
System.out.println( Math.toRadians(k) );//0.7853981633974483

//random() 方法
//返回一个随机数，随机数范围为 0.0 =< Math.random < 1.0。
System.out.println( Math.random() );

p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 14.0px "Yuanti SC"; color: #000000 }

//生成一个0~100的随机数

Random rand=new Random();
int n=(int)(Math.random()*100);       //  生成0-100的随机数
int m=rand.nextInt(100);              // 这里是一个方法的重载，参数的内容是指定范围
System.out.println("n:"+i+"\nm:"+m); // 分别输出两个随机数

p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; line-height: 14.0px; font: 14.0px "Yuanti SC"; color: #000000 }
span.s1 { }

三、 Character 类

//Character 类用于对单个字符进行操作。
//Character 类在对象中包装一个基本类型 char 的值
public class JavaCharacter {
    public static void main(String[] args){

    char ch = ‘a‘;
    // Unicode 字符表示形式
    char uniChar = ‘\u039A‘;
    // 字符数组
    char[] charArray ={ ‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘ };

    System.out.println("charArray = " + charArray[0]);//a

    //然而，在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情况。
    //为了解决这个问题，Java语言为内置数据类型char提供了包装类Character类。
    //Character类提供了一系列方法来操纵字符。你可以使用Character的构造方法创建一个Character类对象

        Character b = new Character(‘a‘);
        System.out.println("b == " + b);//b == a
    /*
     在某些情况下，Java编译器会自动创建一个Character对象。
      例如，将一个char类型的参数传递给需要一个Character类型参数的方法时，那么
      编译器会自动地将char类型参数转换为Character对象。 这种特征称为装箱，反过来称为拆箱。
     */

        // 原始字符 ‘a‘ 装箱到 Character 对象 ch 中
        Character a = ‘a‘;

        // 原始字符 ‘x‘ 用 test 方法装箱
        // 返回拆箱的值到 ‘c‘
        //char c = test(‘x‘);

        //转义序列
        //前面有反斜杠（\）的字符代表转义字符，它对编译器来说是有特殊含义的。
        /*
            \t     在文中该处插入一个tab键
            \b     在文中该处插入一个后退键
            \n     在文中该处换行
            \r     在文中该处插入回车
            \f     在文中该处插入换页符
            \‘     在文中该处插入单引号
            \"     在文中该处插入双引号
            \\     在文中该处插入反斜杠
         */
        //当打印语句遇到一个转义序列时，编译器可以正确地对其进行解释。

        //以下实例转义双引号并输出：
        System.out.println("访问\"Java教程!\"");//访问"Java教程!"

        //Character 方法
        //①isLetter() 方法 判断指定字符是否为字母。
        System.out.println(Character.isLetter(‘c‘));//true

        //②isDigit() 方法  判断指定字符是否为数字。
        System.out.println(Character.isDigit(‘5‘));//true

        //③isWhitespace() 方法 断指定字符是否为空白字符，空白符包含：空格、tab键、换行符
        System.out.println(Character.isWhitespace(‘ ‘));//true
        System.out.println(Character.isWhitespace(‘\n‘));//true
        System.out.println(Character.isWhitespace(‘\t‘));//true

        //④isUpperCase() 方法 判断指定字符是否为大写字母。
        System.out.println( Character.isUpperCase(‘C‘));//true

        //⑤isLowerCase() 方法 判断指定字符是否为小写字母。
        System.out.println( Character.isLowerCase(‘c‘));//true

        //⑥toUpperCase() 方法  将小写字符转换为大写。
        System.out.println(Character.toUpperCase(‘a‘));//A

        //⑦toLowerCase() 方法 将大写字符转换为小写。
        System.out.println(Character.toLowerCase(‘A‘));//a

        //⑧toString() 方法 返回一个表示指定 char 值的 String 对象。结果是长度为 1 的字符串，仅由指定的 char 组成
        System.out.println(Character.toString(‘a‘));//a
        /*
            \r： return 到当前行的最左边。

            \n： newline 向下移动一行，并不移动左右。

            Linux中\n表示：回车+换行；

            Windows中\r\n表示：回车+换行。

            Mac中\r表示：回车+换行。
         */
    }
}

p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 14.0px "Yuanti SC"; color: #000000 }

原文地址：https://www.cnblogs.com/StevenHuSir/p/Java_NumberMath.html