精华内容
下载资源
问答
  • Java包装类——Boolean
    2018-10-09 20:00:44

    Boolean类将基本类型为boolean的值包装在一个对象中。一个Boolean类型的对象只包含一个类型为boolean的字段。

    1、构造方法

    Boolean b=new Boolean(true);

    Boolean bool=new Boolean("ok");

    2、常用方法

    booleanValue():将Boolean对象的值以相应的boolean值返回。

    toString():返回表示该boolean值的String对象。

    public static void main(String[] args) {
    		Boolean boolean1=new Boolean(true);
    		Boolean boolean2=new Boolean("ok");
    		System.out.println(boolean1);//true
    		System.out.println(boolean2);//false
    	}

    3、常量

    Boolean提供了以下3个常量:

    TRUE:对应基值true的Boolean对象。

    FALSE:对应基值false的Boolean对象。

    TYPE:基本类型boolean的Class对象。

    更多相关内容
  • Java8种基本数据类型及其包装类

    千次阅读 2021-07-15 21:06:28
    一、Java四大数据类型分类 1、整型 byte 、short 、int 、long 2、浮点型 float 、 double ...1、byte和包装类Byte 数据存储是以”字节“(Byte)为单位的,一个字节有8”位“。相当于8个盒子,但

    一、Java四大数据类型分类

    1、整型
    byteshortintlong
    
    2、浮点型
    floatdouble
    
    3、字符型
    char
    
    4、布尔型
    boolean
    

    二、八种基本数据类型

    在这里插入图片描述

    三、8种基本类型及其包装类

    Java为这8种基本数据类型,提供了对应的包装类。每个包装类都对相应的基础类型有操作方法,也有几种类型的转换。大家可以对应api文档去学习,这里就不详细说明了。

    1、byte和包装类Byte

    数据存储是以”字节“(Byte)为单位的,一个字节有8”位“。相当于8个盒子,但是这8个盒子中只能存储0或者1。每8个bit组成一个Byte。也就是byte占8位。

    byte a = 24;
    
    2、short和包装类Short

    占16位,最大数据存储量是65536,数据范围是-32768~32767之间

    short a = 9000;
    
    3、int和包装类Integer

    int整型数据占32位,也就是我们说的整数。最大数据存储容量是2的32次方减1,数据范围是负的2的31次方到正的2的31次方减1。

    int a = 6;
    
    4、double和包装类Double

    占64位,数据范围在4.9e-324~1.8e308,赋值时可以加d或D也可以不加

    double a = 20.3d;
    
    5、boolean和包装类Boolean

    boolean只有true和false两个值

    boolean isTrue = false;
    
    6、char和包装类Character

    占6位,存储Unicode码,用单引号赋值。

    char a = 'L';
    
    7、long和Long

    占64位,最大数据存储容量是2的64次方减1,数据范围为负的2的63次方到正的2的63次方减1。

    long a = 300L;
    
    8、float和Float

    占32位,数据范围在3.4e-45~1.4e38,直接赋值时必须在数字后加上f或F。

    float a = 24.3F;
    

    四、数据类型的转换

    简单的数据类型转换有两种方式:自动转换和强制转换

    1、自动转换

    当小数据转换成大数据时,系统会自动转换。

    2、强制转换

    大数据转小数据的时候,就是强制转换。转换后可以会导致溢出或者精度下降。

    展开全文
  • 1 正则表达式Regex 1.1 概述 正确的字符串格式规则。 常用来判断用户输入的内容是否符合格式的要求,注意是严格区分大小写的。 1.2 常见语法 ...创建: TestRegex.java package cn.tedu.api; impo

    1 正则表达式Regex

    1.1 概述

    正确的字符串格式规则。
    常用来判断用户输入的内容是否符合格式的要求,注意是严格区分大小写的。

    1.2 常见语法

    在这里插入图片描述

    1.3 String提供了支持正则表达式的方法

    Matches(正则) : 当前字符串能否匹配正则表达式
    replaceAll(正则,子串) : 替换子串
    split(正则) : 拆分字符串

    1.4 练习:测试输入身份证号

    创建包: cn.tedu.api
    创建类: TestRegex.java

    package cn.tedu.api;
    
    import java.util.Scanner;
    /*本类用于正则表达式入门案例*/
    //需求:接收用户输入的身份证号,并将判断的结果输出
    public class TestRegex {
        public static void main(String[] args) {
            //1.编辑正则表达式
            //身份证号的规律:一共是18位,前17位是数子,第18位有可能是数字,也有可能是X
            //String regex = "[0-9]{17}[0-9X]";
            /*单个\在Java中有特殊的含义,表示转义符号,不认为是一个斜杠
             * 所以如果想要表示斜杠,需要在它的前面加一个用来转义的\
             * 也就是\\才表示成一个单纯的斜杠
             * \t -- 制表符  \r回车符 \n换行符*/
            String regex = "\\d{17}[0-9X]";
    
            //2.定义变量用来接收用户输入的身份证号:
            String input;
    
            //3.判断用户输入的数据是否符合正则表达式,如果不正确,继续输入
            do {
                System.out.println("请输入您的身份证号:");
                input = new Scanner(System.in).nextLine();
                if (input.matches(regex)) {//如果身份证号正确
                    System.out.println("恭喜你!输入正确!");
                    return;//结束本方法
                }
            } while (!input.matches(regex));//只要不符合正则表达式,就继续输入
        }
    }
    
    

    2 包装类

    把基本类型进行包装,提供更加完善的功能。
    基本类型是没有任何功能的,只是一个变量,记录值,而包装类可以有更加丰富的功能

    2.1 与基本类型的对应关系

    在这里插入图片描述

    2.2 Number

    数字包装类的抽象父类。
    提供了各种获取值的方式。
    在这里插入图片描述
    在这里插入图片描述

    2.3 Integer

    创建对象

    方式一: new Integer(5);
    方式二: Integer.valueOf(5);
    Integer类中包含256个Integer缓存对象,范围是 -128~127
    使用valueOf()时,如果指定范围内的值,直接访问缓存对象不新建;如果指定范围外的值,直接新建对象。

    常见方法

    static int parseInt(String s) 将字符串参数作为有符号的十进制整数进行解析

    2.4 练习: Number之Integer

    创建包: cn.tedu. api
    创建类: TestNumber.java

    package cn.tedu.api;
    /*本类用于测试包装类*/
    public class TestNumber {
        //1.定义成员变量,注意要设置成静态的,因为静态只能调用静态
        static Integer i0;
        public static void main(String[] args) {
            //2.打印Integer的默认值进行测试
            System.out.println(i0);//默认值为null
    
            //3.创建int类型对应的包装类Integer类型的对象--方式一
            Integer i1 = new Integer(5);
            Integer i11 = new Integer(5);
            System.out.println( i1 == i11 );//false,==对于引用类型,比较的是地址值
    
            //4.创建int类型对应的包装类Integer类型的对象--方式二
            /*Integer有一个高效的效果,数据在:(-128~127)
            * 在此范围内,相同的数据只会存一次,后续再存都是使用之前存过的数据*/
            Integer i2 = Integer.valueOf(127);
            Integer i3 = Integer.valueOf(127);
            System.out.println(i1 == i2);//false
            System.out.println(i2 == i3);//true
            //满足高效效果的3个条件:Integer valueOf() -128~127
            Integer i4 = Integer.valueOf(300);
            Integer i5 = Integer.valueOf(300);
            System.out.println(i4 == i5);//false
    
        }
    }
    
    
    

    2.5 Double

    创建对象

    1. new Double(3.14)
    2. Double.valueOf(3.14)//和 new 没有区别

    常用方法

    Double.parseDouble();

    2.5 练习: Number之Double

    创建包: cn.tedu.api
    创建类: TestNumber.java

    package cn.tedu.api;
    /*本类用于测试基本类型的包装类*/
    public class TestNumber {
        public static void main(String[] args) {
            //1.创建int包装类Integer对象的方式1
            Integer i1 = new Integer(100);
            Integer i11 = new Integer(100);
            System.out.println(i1 == i11);//false,new了两次,是两个不同的对象,地址值不同
    
            //2.创建int包装类Integer对象的方式2
            /*Integer有一个高效的效果,但是必须满足3个条件:
            * 1.是Integer类型
            * 2.使用valueOf()的创建方式
            * 3.数据在-128~127的范围内
            * 满足以上条件,相同的数据只会存一次,后续再使用都是以前存过的数据*/
            Integer i2 = Integer.valueOf(100);
            Integer i22 = Integer.valueOf(100);
            System.out.println(i2 == i22);//true
    
            Integer i3 = Integer.valueOf(300);
            Integer i33 = Integer.valueOf(300);
            System.out.println(i3 == i33);//false 超出高效的数据范围-128~127
    
            //3.创建double包装类Double对象的方式1
            Double d1 = new Double(3.14);
            Double d11 = new Double(3.14);
            System.out.println(d1 == d11);//false,创建两个不同的对象,地址值不同
    
            //4.创建double包装类Double对象的方式2
            /*只有Integer才有高效的效果Double是没有的*/
            Double d2 = Double.valueOf(3.14);
            Double d22 = Double.valueOf(3.14);
            System.out.println(d1 == d2);//false
            System.out.println(d2 == d22);
    
            //5.测试常用方法
            //这个方法的作用就是把传入的String类型的数据转成int
            /*对象是什么类型的,就可以使用这个类的所有资源
            i1是Integer类型的对象,所以可以使用parseInt()将String类型的数据转为int类型
            d1是Double类型的对象,所以可以使用parseDouble()将String类型的数据转为double类型*/
            System.out.println(i1.parseInt("800")+8);//808->int+int
            System.out.println(d1.parseDouble("2.2")+3.1);//5.300000000000001->double+double
        }
    }
    

    3 自动装箱和自动拆箱

    3.1 概述

    自动装箱:把 基本类型 包装成对应的 包装类型 的过程
    Integer a = 5;//a是引用类型,引用了包装对象的地址。
    编译器会完成对象的自动装箱:Integer a = Integer.valueOf(5);

    自动拆箱:从包装类型的值,自动变成 基本类型的值
    int i = a;//a现在是包装类型,没法给变量赋值,需要把5取出来。
    编译器会完成自动拆箱:int i = a.intValue();

    3.2 练习: 自动装箱与自动拆箱测试

    创建包: cn.tedu.api
    创建类: TestBox.java

    package cn.tedu.api;
    /*本类用于测试自动装箱和自动拆箱*/
    public class TestBox {
        public static void main(String[] args) {
            //1.定义包装类型的数据
            //回顾:以前创建包装类型的两种方式
            Integer i1 = new Integer(127);
            Integer i2 = Integer.valueOf(127);
            //2.现在的方式:
            /*1.自动装箱:编译器会自动把基本类型int 5,包装成包装类型Integer
            * 然后交给i3来保存,自动装箱底层发生的代码Integer.valueOf(5);
            * valueOf()的方向: int --> Integer*/
            Integer i3 = 5;//不会报错,这个现象就是自动装箱
            /*2.自动拆箱:编译器会自动把包装类型的i1拆掉"箱子",变回基本类型数据127
            * 然后交给i4来保存,自动拆箱底层发生的代码:i1.intValue();
            * intValue()的方向:Integer -> int
            * */
            int i4 = i1;//不会报错,这个现象就是自动拆箱
        }
    }
    

    4 BigDecimal

    BigDecimal:常用来解决精确的浮点数运算不精确的问题

    4.1 创建对象

    方式一 :
    BigDecimal(double val)
    将double转换为BigDecimal,后者是double的二进制浮点值十进制表示形式,有坑!
    方式二 :
    BigDecimal(String val)
    将String类型字符串的形式转换为BigDecimal

    4.2 常用方法

    Add(BigDecimal bd) : 做加法运算
    Subtract(BigDecimal bd) : 做减法运算
    Multiply(BigDecimal bd) : 做乘法运算
    Divide(BigDecimal bd) : 做除法运算,除不尽时会抛异常
    Divide(BigDecimal bd,保留位数,舍入方式) : 除不尽时使用
    setScale(保留位数,舍入方式) : 同上
    pow(int n) : 求数据的几次幂

    4.3 练习:测试常用方法

    创建包: cn.tedu.bigdecimal
    创建类: TestBigDecimal.java
    需求: 接收用户输入的两个小数,做运算

    package cn.tedu.api;
    
    import java.math.BigDecimal;
    import java.util.Scanner;
    
    public class TestBigDecimal {
        public static void main(String[] args) {
            //f1();//使用普通的 +-*/ 四则运算,暴露出浮点数运算不精确的问题
            f2();//使用BigDecimal来解决浮点数运算不精确的问题
        }
    
        private static void f2() {
            //1.提示并接收用户输入的两个小数
            System.out.println("请输入您要计算的两个小数:");
            double a = new Scanner(System.in).nextDouble();
            double b = new Scanner(System.in).nextDouble();
            //2.创建工具类对象,把基本类型a和b交给工具类对象BigDecimal来保存
            /*1.最好不要用double作为构造函数的参数,不然还会有不精确的现象,有坑!!!*/
            /*2.最好使用重载的,参数类型是String的构造函数
            * double转String,直接拼个空串就可以*/
            BigDecimal bd1 = new BigDecimal(a+"");
            BigDecimal bd2 = new BigDecimal(b+"");
    
            //3.通过BigDecimal的对象来调用其方法,实现精确运算
            //3.1 定义BigDecimal类型的引用类型变量来保存结果
            BigDecimal bd3;
            //3.2 Add(BigDecimal bd) : 做加法运算
            bd3 = bd1.add(bd2);
            System.out.println(bd3);
            //3.3 Subtract(BigDecimal bd) : 做减法运算
            bd3 = bd1.subtract(bd2);
            System.out.println(bd3);
            //3.4 Multiply(BigDecimal bd) : 做乘法运算
            bd3 = bd1.multiply(bd2);
            System.out.println(bd3);
            //3.5 Divide(BigDecimal bd) : 做除法运算,除不尽时会抛异常
            /*3.除法运算,除不尽时会抛出异常ArithmeticException*/
            //方案一:(除不尽时有问题)
            //bd3 = bd1.divide(bd2);
            /*divide(m,n,o)
            m是要除以哪个对象,n指要保留几位,o指舍入方式(比如四舍五入)*/
            //方案二:
            bd3 = bd1.divide(bd2,3,BigDecimal.ROUND_HALF_UP);
            System.out.println(bd3);
    
        }
    
        private static void f1() {
            //1.提示并接收用户输入的两个小数
            System.out.println("请输入您要计算的两个小数:");
            double a = new Scanner(System.in).nextDouble();
            double b = new Scanner(System.in).nextDouble();
    
            //2.做运算
            System.out.println(a + b);//不精确
            System.out.println(a - b);//不精确
            System.out.println(a * b);//不精确
            System.out.println(a / b);//不精确
        }
    }
    

    到这里,API第一课就结束啦,恭喜你又闯过一关哦~

    5 拓展

    舍入方式解析
    ROUND_HALF_UP 四舍五入,五入 如:4.4结果是4; 4.5结果是5
    ROUND_HALF_DOWN 五舍六入,五不入 如:4.5结果是4; 4.6结果是5
    ROUND_HALF_EVEN 公平舍入(银行常用)
    比如:在5和6之间,靠近5就舍弃成5,靠近6就进位成6,如果是5.5,就找偶数,变成6
    ROUND_UP 直接进位,不算0.1还是0.9,都进位
    ROUND_DOWN 直接舍弃,不算0.1还是0.9,都舍弃
    ROUND_CEILING(天花板) 向上取整,取实际值的大值
    朝正无穷方向round 如果为正数,行为和round_up一样,如果为负数,行为和round_down一样
    ROUND_FLOOR(地板) 向下取整,取实际值的小值
    朝负无穷方向round 如果为正数,行为和round_down一样,如果为负数,行为和round_up一样

    展开全文
  • java——Byte类/包装类

    万次阅读 2018-07-04 19:49:52
    Byte类/包装类包装类是一个常量类,可实例化(意义:帮助对应的数据类型进行数据类型)java数据类型包括内置数据类型引用数据类型内置数据类型:含6中数字类型(四个整数型,两个浮点型),一种字符类型,还有布尔...
    Byte类/包装类
    包装类是一个常量类,可实例化 (意义:帮助对应的数据类型进行数据类型)
    java数据类型包括内置数据类型和引用数据类型
    内置数据类型 :含6中数字类型(四个整数型,两个浮点型),一种字符类型,还有布尔类型
    byte
    byte:数据类型占用1个字节=8bit,以二进制补码表示的整数
              取值范围:默认值为0,最小值为-128(-2^7);最大值是127(2^7-1)
    数据类型关键字内存中占用字节数取值范围默认值
    布尔型boolean1true/falseFALSE
    字节型byte1-128~1270
    短整型short2-2^15~2^15-10
    整型int4-2^31~2^31-10
    长整型long8-2^63~2^63-10
    字符型char20~2^16-1 '\u000'
    单精度浮点型float41.4013E-45~3.4028E+380.0F
    双精度浮点型double84.9E-324~1.7977E+3080.0D
             用途:byte类型用在大型数组中节约空间,主要代替整数,因byte变量占用内存的空间只有int类型的1/4;不足是这个数取值范围大,byte不能全部替代

    常用方法
    A.构造方法
    public Byte(byte value)
    public Byte(String s)
    B.普通方法+类方法(对数据类型做转换)
    piublic byte byteValue()
    public short shortValue()
    public int intVlaue()
    public long longValue()
    public float floatValue()
    public double doubleValue()
    public String toString()
    public static String toString(byte b)

    包装类和基本数据类型的对象关系

    注:常量类是否可以被实例化主要看构造方法

    package com.youceedu.test.wrapper;
    
    public class TestByte {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		byte a = 9;
    		byte b = -7;
            String result = Byte.toString(a);
    		Byte c = new Byte((byte) 9);
    		System.out.println(c.floatValue()); 
    		System.out.println(result+b);
    	}
    
    }
    

    展开全文
  • java中的包装类和异常

    千次阅读 2016-09-26 19:13:46
    基本类型不是对象------没有从类java.lang....为了能够将对象作为异常抛出,该对象必须是Throwable类型,Throwable定义在包java.lang中,位于异常层次关系 最顶部,Throwable有两个子类:ErrorException,检查异常
  • java中的POJO属性建议使用包装数据类型

    万次阅读 多人点赞 2018-03-15 14:09:16
    POJO 属性没有初值是提醒使用者在需要使用时,必须自己显式地进行赋值,任何NPE(NullPointerException,空指针异常) 问题,或者入库检查,都由使用者来保证。 2、举例说明 正例: (1)所有的sql使用的默认...
  • 值的方式调用可以和普通类一样定义属性方法valueOf方法冲用来将该类的枚举类型与字符串类型比较包装类包装类:对应每个基本数据类型,都有一个包装类型与之相对目的:可以把基本数据类型转成对象也可以把字符串转...
  • 为什么要使用包装类?? java数据类型分为 基本数据类型、引用数据类型。其中基本数据类型是不具备对象的...(java包装类都是在java . lang包中的) **包装类与 基本数据类型 之间的对应关系** public cl...
  • Java 中基本类型和包装类之间的转换 基本类型和包装类之间经常需要互相转换,以 Integer 为例(其他几个包装类的操作雷同): 在 JDK1.5 引入自动装箱拆箱的机制后,包装类和基本类型之间的...
  • 内部类、包装类、异常、日期
  • java——Byte类/包装类的使用说明

    千次阅读 2021-03-06 23:10:30
    Byte类/包装类包装类是一个常量类,可实例化 (意义:帮助对应的数据类型进行数据类型)java数据类型包括内置数据类型引用数据类型内置数据类型 :含6中数字类型(四个整数型,两个浮点型),一种字符类型,还有布尔...
  • 面向对象语言中仅仅有...这就诞生了将基本数据类型包装成类的手段,可以通过这些包装类的各种方法对他们进行各种骚操作。 1. 八种基本数据类型 数据类型 包 byte ---------> Byte short ---------> Shor...
  • Java的String类、Object类、包装类

    千次阅读 2018-04-18 14:46:32
    Java的String类、Object类、包装类
  • Java基础11:Wrapper包装类

    千次阅读 2017-09-09 19:10:49
    为了解决这个不足,在设计类时为每个基本数据类型设计了一个对应的类进行代表,这样八个基本数据类型对应的类统称为包装类(Wrapper Class),有些地方也翻译为外覆类或数据类型类。 一、Wrapper类概述 1、基本...
  • 文件,并适应普通,可运行的jar,Web容器等。 或易于获取/设置配置。 Maven依赖项: <groupId>net.sunyijun</groupId> <artifactId>resource-utils 基本实用程序 资源利用率 职能: 从classPath获取文件系统...
  • Java中的File类和IO流

    万次阅读 多人点赞 2019-08-19 20:40:38
    1.File:翻译是文件,用于表达java中的路径名。 2.路径:用于表示文件或者文件夹在当前系统中的位置 3.路径的分类: 绝对路径 相对路径 4.绝对路径:没有任何的歧义,也没有任何的前提条件 Windows,从盘符开始的...
  • Java中基本数据类型和包装类

    千次阅读 2015-03-25 14:52:35
    java内存分配这里只是在网上找的一些资料; Java 中的数据类型分为 1. 基本类型(原始数据类型) byte short int long float double char boolean 基本类型的变量持有原始值。 2. 符合数据类型(引用类型)...
  • JAVA 包装类型 及 易错陷阱

    千次阅读 2016-09-04 22:00:52
    包装类型是对基本数据类型的加强,自动装箱技术简化了其转换过程,但是整型池NULL是特别需要注意的地方
  • Java基础知识面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 12:11:27
    文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JREJDK的关系什么是跨平台性?原理是什么Java语言有哪些特点什么是字节码?采用字节码的最大好处是什么什么是Java程序的主类?应用程序小程序的...
  • Java 泛型 一、概述 Java 泛型(generics)是 JDK 1.5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制,该机制允许开发者在编译时检测到非法的类型。 1.1 什么是泛型? 泛型,即参数化类型。 一提到参数,...
  • 一,包装类 1,八种基本类型与其对应的包装类:byte(Byte),short(Short), int(Integer, -128 ~127), long(Long), char(Chacter), float(Float),double(Double), boolean(Boolean); JDK1.5之后提供额自动装箱...
  • java Wrapper基本用法详解

    千次阅读 2021-02-13 00:54:26
    在封装中有一种特殊的,能够把基本的数据类型进行转换来方便实际的使用。...1.概念wrapper是在Java中创建对象引用类型的原始类型的方式。我们可以说,通过提供wrapper,使Java在面向对象技术...
  • 工程师培训资料标题Java培训系列课程-抽象精品培训培训人xx本章学习目标掌握继承性的主要作用实现使用限制掌握方法覆写的操作掌握final关键字的使用掌握对象多态性的概念以及对象转型的操作掌握抽象类和接口的定义...
  • Java中的Class

    千次阅读 2021-03-23 11:21:40
    Class类的作用 Class类是一个特殊类,它用于表示JVM运行时类或接口的信息。 Class类提供很多方法用于获取类的各种信息,比如获取类名、判断该类...在每一个基本类型的包装类中都有一个共有的静态变量,例如Integer:
  •  自jdk5之后,java就提供了自动装箱与自动拆箱功能,大大简化了基本类型与其包装类对象之间的转换过程,当然装换过程中要注意类型的匹配。 public class IntAndInteger { public static void main(String[] args)...
  • 实验2 Java类和对象的设计

    千次阅读 多人点赞 2019-12-28 22:50:06
    实验题目:Java类和对象的设计 一、上机目的要求 理解面向对象的编程思想、与对象的概念; 加深理解封装性、继承性多态性; 掌握this、super、final、static等关键字的使用; 掌握抽象类和接口的使用方法; ...
  • **篇基础篇第1章Java概述1.1 Java语言1.1.1 Java语言的特点1.1.2 Java平台的体系结构1.2 Java运行环境与开发环境1.2.1 Java运行环境1.2.2 Java...习题与思考第2章Java程序设计基础2.1标识符关键字2.1.1标识符**篇...
  • 工具类、包装类、abstract模板方法

    千次阅读 2021-09-06 14:36:07
    工具 存放了某一事物的工具方法的. 工具存放的包:工具包(util,utils,tool/tools,helper,helpers),存放工具. 工具如何设计: 工具在开发中其实只需要存在一份即可. 1): 如果工具方法没有使用static修饰,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 75,464
精华内容 30,185
关键字:

java包装类和普通

java 订阅