Java学习29--常用类包装类wrapper & 数学类Math

最新推荐文章于 2024-07-19 17:37:28 发布

Dear_喜阳阳

最新推荐文章于 2024-07-19 17:37:28 发布

阅读量389

点赞数 5

文章标签： java 学习 python

本文链接：https://blog.csdn.net/weixin_42892630/article/details/136432797

版权

包装类wrapper

使用原因：
JAVA中有两个类型系统，基本数据类型和引用数据类型。基本类型使用快速便捷，但是有些方法或API在设计时候，输入预设为object，除了喂进去object之外，没法使用。
如果还想使用这类方法或者API，就急需能将基本数据类型转换成对应的object的思路，这就是包装类wrapper，其实就是定义了一个基本数据类型对应的object，其中的属性定义源自那个基本数据类型。

复习：什么是基本数据类型和引用数据类型？

基本数据类型是Java中内置的、简单的数据类型，它们直接存储具体的值。基本数据类型包括：

    byte：字节型，占用1个字节，取值范围是-128到127。
    short：短整型，占用2个字节，取值范围是-32768到32767。
    int：整型，占用4个字节，取值范围是-2147483648到2147483647。
    long：长整型，占用8个字节，取值范围是-9223372036854775808到9223372036854775807。
    float：单精度浮点型，占用4个字节，可以表示大约7位有效数字。
    double：双精度浮点型，占用8个字节，可以表示大约16位有效数字。
    char：字符型，占用2个字节，可以表示一个16位Unicode字符。
    boolean：布尔型，可以表示true或false。
	
引用数据类型（Reference Types）
引用数据类型用于存储对象的引用，也就是指向对象在堆内存中的地址。引用数据类型包括：

    类（Class）：用户自定义的类。
    接口（Interface）：用户自定义的接口。
    数组（Array）：用于存储相同类型数据的有序集合。

基本数据类型以及对应的包装类：

byte -> Byte
short -> Short
int -> Integer
long -> Long
float -> Float
double -> Double
char -> Character
boolean -> Boolean
这些类都在java.lang包

包装类常用方法

String-> Wrapper
//有String数据想要其他类型object，使用parseXXX(括号这里只能写String数据)

首字母大写类型.parse首字母大写类型(String数据)
Integer.parseInt("mystringABC")
Long.parseLong("mystringABC")
Double.parseDouble("mystringABC")
Boolean.parseBoolean("mystringABC")

基本数据类型(们) -> Wrapper
//基本数据类转化成包装类型

首字母大写类型.valueOf(基本数据类型)
Integer.valueOf(int123);
Long.valueOf(long123);
Double.valueOf(double123);
Boolean.valueOf(tRUe/fAlSe大小写随意true或者false);

Wrapper ->基本数据类型(们)
//包装类型转换成基本数据类型

my_wrapper_Byte_object.byteValue()
my_wrapper_Boolean_object.booleanValue()
my_wrapper_Double_object.doubleValue()
my_wrapper_Float_object.floatValue()
my_wrapper_Char_object.charValue()

注意：一旦转换成对象，以前的“+ - * / ”运算就不再简单适用了。+容易变成字符拼接符。

使用举例

package Wrapper;



public class test2 {
    public static void main(String[] args) {
        int i_s1=12345;
        float f_s1=123.4567f;
        double d_s1=12345678;
        String s_b1="tRuE"; //Boolean内部使用时候，不记字母大小写，直接判断是否是true，如果不是则全为false
        String s_s1="1234567890";
        boolean b_s1= false;

        //对应的包装类A=Uppercase_1stName.valueOf(基本数据类型A)
        System.out.println(Integer.valueOf(i_s1));
        System.out.println(Float.valueOf(f_s1));
        System.out.println(Double.valueOf(d_s1));
        System.out.println(String.valueOf(s_s1));
        System.out.println(Boolean.valueOf(b_s1));
        System.out.println(Boolean.valueOf(s_b1));

        System.out.println("============> ");
        //有String数据想要其他类型object，使用parseXXX(括号这里只能写String数据)
        System.out.println(Integer.parseInt(s_s1));
        System.out.println( Float.parseFloat(s_s1));
        System.out.println(Double.parseDouble(s_s1));
        System.out.println(Boolean.parseBoolean(s_s1));
        System.out.println(Boolean.parseBoolean(s_b1));


        System.out.println("=========11111===========");
        int x1 =123;
        float y1=678.3456f;
        double z1=34563324;
        String m1="08765";
        String n1="TRue";

        System.out.println(Integer.valueOf(x1)+String.valueOf(y1)+Boolean.valueOf(n1));
        //注意这里是三个object在拼接，不是三个值在数学加减

        System.out.println("=========11111===========");

        Integer xx1=Integer.valueOf(456);
        Float yy1 =Float.valueOf(4567.123f);
        Double zz1 = Double.valueOf(8904567234d);
        Character cc1 = Character.valueOf('d');
        Boolean bb1=Boolean.valueOf("tRUe");//不管大小写，只要能拼出true都算真，其余都是假的
        

        //拆包
        System.out.println(zz1.byteValue());
        System.out.println(bb1.booleanValue());
        System.out.println(xx1.doubleValue());
        System.out.println(yy1.floatValue());
        System.out.println(cc1.charValue());
        System.out.println("=============666=====");
        System.out.println(z1+"");
        System.out.println(String.valueOf(z1));
        System.out.println(Boolean.parseBoolean("tRUE"));
        System.out.println(Boolean.parseBoolean("this is me"));

运行结果：

12345
123.4567
1.2345678E7
1234567890
false
true
============> 
1234567890
1.234568E9
1.23456789E9
false
true
=========11111===========
123678.3456true
=========11111===========
-1
true
456.0
4567.123
d
=============666=====
3.4563324E7
3.4563324E7
true
false

Process finished with exit code 0

练习：输入学生成绩(0-100)，输入时候以负数或者其他字符串代表输入结束。学生中最高分数定义为A级，和最高分相差10分以内定义为A级，和最高分相差20分以内定义为B级，和最高分相差30分以内定义为C级，其余定义为D级。

提示，为了练习IntegerObject和普通int之间的wrapper转换练习，这里可以用vector用来存储学生成绩
Vector v= new Vector();表示建立vector
v.addElement(Object);表示将Object放进vector
v.elementAt(数组下标);表示读取vector[i]的具体Object
v.size()表示读取vector的长度
最后要求可以从键盘输入学生成绩，系统算出班级最高分，然后给每一个分数评级显示。

package Stringtest;

import java.util.Scanner;
import java.util.Vector;


public class test6 {


    public static void main(String[] args) {
        Scanner x = new Scanner(System.in);
        int max = 0;
        int score_x = 0;



        Vector v = new Vector();
        System.out.println("pls enter the score: ");
        while (x.hasNextInt()) {
            score_x = x.nextInt();
//注意，这个 score_x 变量一定要有，有些人想在下面的if结构里
//直接每次用x.nextInt()进行判断比如写成if(x.nextInt()>=0)或者if(max <x.nextInt())
//这是不可以的，因为这种写法每一次x.nextInt()用完就会被抛弃掉，如果现在用户输入了90,80,70
//实际运行的是if(x.nextInt()【90】>=0)然后执行if(max <x.nextInt()【80】)
//这显然不是我们想要的运算逻辑，正确代码如下

            if (score_x>=0) {
                v.addElement(Integer.valueOf(score_x));
                if (max < score_x) {
                    max = score_x;
                }

            } else break;
        }


       System.out.println("max is "+max);


        for (int i = 0; i < v.size(); i++) {
            //如果不直接使用Integer<->int自动打包解包，
            //程序员一步一步用Integer wrapper-> integer转换
            //分步详解代码如下面/**/注释的两部分
            /*
            int get_int=((Integer)v.elementAt(i)).intValue();
            */
            //v.elementAt(i)是Object类，不能直接调用intValue()对其进行数据类型转换
            //(Integer)v.elementAt(i)就将Object类强制转换成了Integer类，将其括在一起，准备使用intValue()进行wrapper->int

            //coder may use XXX.getClass() to check the class of each object whenever feel confused.
            //System.out.println("getClass here: "+((Integer)v.elementAt(i)).getClass());

            if((max-(int)v.elementAt(i))<=10)
            {System.out.println(v.elementAt(i)+" is A");}
            else if((max-(int)v.elementAt(i))<=20)
            {System.out.println(v.elementAt(i)+" is B");}
            else if((max-(int)v.elementAt(i))<=30)
            {System.out.println(v.elementAt(i)+" is C");}
            else {System.out.println(v.elementAt(i)+" is D");}
 /*
            if(max-get_int<=10)
            {System.out.println(v.elementAt(i)+"is A");}
            else if(max-get_int<=20)
            {System.out.println(v.elementAt(i)+"is B");}
            else if(max-get_int<=30)
            {System.out.println(v.elementAt(i)+"is C");}
            else {System.out.println(v.elementAt(i)+"is D");}

 */

        }

    }
}

pls enter the score: 
55
78
66
90
87
80
-9
max is 90
55 is D
78 is B
66 is C
90 is A
87 is A
80 is A

Process finished with exit code 0

Math

数学类的方法都是静态方法，可以直接引用——Math.方法();
常用的数学method
abs()绝对值
max()求最大值
min()求最小值
pow()幂指数
round()四舍五入
sqrt()开根号

package Math;

import java.math.BigDecimal;

public class test {


    public static void main(String[] args) {
        int a=3;
        int b=4;
        int c=-4;
        float d=4.55f;
        double e = 6;

        System.out.println(Math.abs(c));//求绝对值，得到4
        System.out.println(Math.max(a,c));//求max值，得到3
        System.out.println(Math.min(d,c));//求min值，得到-4.0
        System.out.println(Math.pow(b,a));//求b^a，得到64
        System.out.println(Math.round(d));//求四舍五入，得到5
        System.out.println(Math.sqrt(b));//开根号，得到2
    }
}

运行结果

4
3
-4.0
64.0
5
2.0

Process finished with exit code 0

Dear_喜阳阳

关注

5
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
Java学习29--常用类包装类wrapper & 数学类Math

学生中最高分数定义为A级，和最高分相差10分以内定义为A级，和最高分相差20分以内定义为B级，和最高分相差30分以内定义为C级，其余定义为D级。如果还想使用这类方法或者API，就急需能将基本数据类型转换成对应的object的思路，这就是包装类wrapper，其实就是定义了一个基本数据类型对应的object，其中的属性定义源自那个基本数据类型。基本类型使用快速便捷，但是有些方法或API在设计时候，输入预设为object，除了喂进去object之外，没法使用。表示读取vector[i]的具体Object。
复制链接

扫一扫