精华内容
下载资源
问答
  • Java包装类的共同点

    千次阅读 2019-03-10 23:19:32
    渣渣海除了写点博客外,还有github哦...之前写过一篇博客,讲了基础的Java包装类的装包拆包过程,下面补充一下包装类它们的一些共同点。 1.所有包装类都重写了Object方法 我们也很容易知道Object的方法有: bo...

    渣渣海除了写点博客外,还有github哦,欢迎进去看看,如果有喜欢的,记得加个小星星哦。

    github地址:https://github.com/xuhaihan?tab=repositories

    之前写过一篇博客,讲了基础的Java包装类的装包拆包过程,下面补充一下包装类它们的一些共同点。

    1.所有包装类都重写了Object方法

       我们也很容易知道Object的方法有:

    boolean equals(Object obj)
    int hashcode()
    String toString()

      1.1 equals

       equals 基本上用于判断当前对象和参数传入的对象是否相同,Object类的默认实现是比较地址。对于两个变量,指向同一个对象地址时,equals才会返回true,与==运算符结果相同。一般这个默认实现是不符合我们需要的比较两个对象相等,需要子类重写这个实现。以Long为例,其equals方法代码实现如下:

    public boolean equals(Object obj){
        if(obj instanceof Long){
          return value==((Long)obj).longValue();
       }
       return false;
    }

    对于Float,equals方法实现跟上面还有点区别,需要注意一下,其equals实现:

    public boolean equals(Object obj){
       return (obj instanceof Float) && (floatToIntBits((Float) obj).value) ==floatToIntBits(value));
    }

    上面代码出现了一个floatToIntBits()方法,这里将float的二进制表示看做int。为什么要使用这个方法呢?因为float类型要比较相等的时候,只有当他们表示的二进制完全一样的时候才相等。所以比较两个float相等转成成了二进制对应int值的比较。Double实现euqals方法也类似,有兴趣的可以自己找源码看看。

    1.2 hashCode

       hashCode 返回一个对象的哈希值。哈希值是一个int类型的数,一般有对象中不变的属性值映射得来。一般在容器类会对对象进行区分。一个对象的哈希值不能改变,相同对象的哈希值相同,不同对象的可以相同,也可以不同,一般是不同。对于hashcode与equals的关系,我这里推荐一个博主的文章,写的比我详细,我这里就在这里引用他的文章。

    https://blog.csdn.net/xlgen157387/article/details/88087963

    包装类也重写了hashCode,根据包装类的基本类型值计算hashCode,对于Byte、Sort、Integer、Character,hashCode就是其中内部的值,具体代码为:

    public int hashCode(){
       return (int)value;
    }

    对于Boolean,hashCode代码如下:

    public int hashCode(){
       return value ? 1231 : 1237
    }

    为什么选择这两个值,因为它们都是质数,即只能被1和本身整除的数,质数用于哈希时,不易冲突。

    其他的包装类也类似,就不在赘述,读者可以自行查看源代码,比较容易看懂,不难。

    1.3 toString

     每个包装类都重写了toString方法,返回对象的字符串表示,这个也容易理解,不过多阐述。

    2. 包装类都实现了Comparable接口

     Java API 的Comparable 接口如下:

    public interface Comparable<T> {
       public int compareTo(T o)
    }

    使用了泛型,具体参数类型由实现接口的类传入。每个包装类的实现基本都是根据类型值进行比较的,不过多说明。

    3.包装类除了toString方法外,还有一些跟String相关的方法

      除了Character方法外,每个包装类都有一个静态的valueOf(String) 方法,根据字符串表示返回包装类对象。例如:

    Boolean b=Boolean.valueOf("true");
    Float f=Float.valueOf("123.45f");
    

    也有一个静态方法parseXXX(String) 方法,根据字符串表示返回基本类型,如:

    boolean b=Boolean.parseBoolean("true");
    double d = Double.parseDouble("123.45");

    都有一个静态的toString方法,根据基本类型值返回字符串表示,如

    System.out.println(Boolean.toString(true));

    对于整数类型,字符串表示除了默认的十进制外,还可以表示为其他禁止,如二进制,八进制,十六进制,包装类有静态方法进行相互转换,比如

    System.out.println(Integer.toBinaryString(12345)); //换成二进制
    System.out.println(Integer.toHexString(12345)); //换成十六进制

    4.常用常量

    包装类除了定义静态方法和实例方法外,还定义一些静态变量,以Boolean类型为例有:

    public static final Boolean TRUE = new Boolean(true);
    public static final Boolean FLASE = new Boolean(false);

    所有数值都定义了MAX_VLAUE和MIN_VALUE,表示能表示的最大/最小,比如,Integer:

    public static final int MIN_VALUE=0x80000000;
    public static final int MAX_VALUE=0x7fffffff;

    Float和Double还定义了一些特殊数值,比如正无穷,负无穷,非数值

    5.Number

    6种数值类型都有一个共同的父类Number。Number是一个抽象类,定义如下方法:

    byte byteValue()
    short shortValue()
    int intValue()
    long longValue()
    float floatValue();
    double doubleValue();

    通过这些方法,包装类实例返回任意类型的基本数值类型。

    6.不可变性

     包装类都是不可变类,就是指实例对象一旦创建,没有办法修改对象。通过如下实现:

    • 包装类都申明了final,不能被继承
    • 内部基本类型是私有,而且声明了final
    • 没有定义setter方法

      之所以定义为不可变类,主要是为了程序更加简单安全,不用担心数据被意外改写,可以安全共享数据,特别是在多线程环境下。

    展开全文
  • Java 包装类是什么

    万次阅读 多人点赞 2018-04-26 14:29:49
    包装类就是将基本的数据类型以及一些辅助方法封装到类中,例如 class IntDemo { private int num; public IntDemo(int num) { this.num = num; } public int intValue() { return this.num; } } Java...

     java中的数据类型int,double等不是对象,无法通过向上转型获取到Object提供的方法,而像String却可以,只因为String是一个对象而不是一个类型。基本数据类型由于这样的特性,导致无法参与转型,泛型,反射等过程。为了弥补这个缺陷,java提供了包装类。

     包装类顾名思义就是将基本的数据类型以及一些辅助方法包装到类中,例如自己实现一个int的包装类:

    class IntDemo {
        private int num;
        public IntDemo(int num) {
            this.num = num;
        }
        public int intValue() {
            return this.num;
        }
    }

    1. Java提供的包装类

     虽然上面的IntDemo类能实现一些辅助功能,而且可以支持泛型反射等功能,但是如果如果每次使用都自己封装这么一个类的话,就太繁琐了。所以,java为我们提供了基本数据类型的包装类,这些包装类分为两类,一种是对象型包装类,不继承任何其他类(Object的直接子类),另一种是数值型包装类,继承于Number类。

     对象型(Object 的直接子类)包装类:

    // boolean的包装类
    public final class Boolean implements java.io.Serializable,
                                          Comparable<Boolean>
    
    // char的包装类
    public final
    class Character implements java.io.Serializable, Comparable<Character>

     数值型(继承了Number类)包装类:

    // byte的包装类
    public final class Byte extends Number implements Comparable<Byte>
    
    // short的包装类
    public final class Short extends Number implements Comparable<Short> 
    
    // int的包装类
    public final class Integer extends Number implements Comparable<Integer>
    
    // long的包装类
    public final class Long extends Number implements Comparable<Long> 
    
    // float的包装类
    public final class Float extends Number implements Comparable<Float> 
    
    // double的包装类
    public final class Double extends Number implements Comparable<Double> 

     Boolean和Character两个类就是正常的属性方法封装,但是数值型的包装类继承了一个Number类。

    public abstract class Number implements java.io.Serializable

    其中定义的方法如下:

    Number类的方法

     其实Number中定义的方法就是用于拆箱装箱的。

    2. 拆箱与装箱

     装箱:

      将基本数据类型封装为包装类对象,利用每一个包装类提供的构造方法实现装箱操作。

     拆箱:

      将包装类中包装的基本数据类型数据取出。

    // 装箱
    Integer integer1 = new Integer(1);
    // 拆箱
    int integer2 = integer1.intValue(); 

     JDK1.5之后提供自动拆装箱。

    // 自动装箱
    Integer integer1 = 1;
    // 自动拆箱
    int integer2 = integer1; 

    3. 自动装箱的内存复用

     自动装箱时,对于Integer var = ?,如果var指向的对象在-128 至 127 范围内的赋值时,生成的Integer实例化对象是由 IntegerCache.cache() 方法产生,它会复用已有对象。和String的共享池操作是一个道理,cache()方法会将位于-128~127范围内产生的Integer对象入池,下次使用的时候,从池中拿去,就不会在创建了。

     所以,在这个数值区间内的 Integer对象的栈指向(属性名) 可以直接使用==进行判断,因为值相同,指向的就是同一片区域。但是这个区间之外的所有数据,自动装箱都会在堆上产生实例化,并不再复用已有对象,这是一个大坑,为了避免这个问题,推荐使用 equals 方法进行Integer的判断。

     对于所有数值型的包装类来说,都会涉及到上面这种问题,一定要多加注意。

     而对于手动装箱,即采用new进行包装类创建时,不会发生内存复用,因为new关键字每次使用,都会开辟新的空间,这和String采用构造方法创建字符串不入池相对应。

    4. 包装类编码规约

     所有的相同类型的包装类对象之间值的比较,全部使用equals()方法。

     所有的POJO(简单Java类,只包含基本属性,有参构造,get/set)类属性必须使用包装类数据类型,类属性即static属性。

     RPC(远程方法调用)方法返回值和参数必须使用包装数据类型。

     推荐所有的局部变量使用基本数据类型。

    5. 包装类对字符串与基本数据类型转换的支持

     实际工程中,各种数据的接收是通常是通过字符串完成的,所以要掌握包装类对字符串转换的方法。

    // String->int
    public static int parselnt(String s)throws NumberFormatException;
    
    // String->double 
    public static double parseDouble(String)throws NumberFormatException;
    
    // String->Boolean 
    public static boolean parseBoolean(String s)

     字符串转数值类型时字符串只能包含数字,否则会抛出 NumberFormatException 异常,这是一个非受查异常。

     但是字符串转Boolean是个特例,parseBoolean()方法会将”true”转为true,而将非”true”的字符串转为false。

    展开全文
  • 最近在业务中碰到了 Integer 默认值的判空 导致的业务逻辑问题,引起了兴趣,针对基本数据类型和其包装类有什么区别?测试过程中应该注意哪些问题呢?...回答这些问题前,我们先来看看java中基本数据类型和包装类有哪些
    • 一、Java中基本数据类型的包装类
    • 二、Java中8种基本数据类型及其默认值
    • 三、基本数据类型比包装类性能好?
    • 四、基本数据类型和包装类的区别
    • 五、测试中注意什么?
    • 六、附录



    最近在业务中碰到了 Integer 默认值的判空 导致的业务逻辑问题,引起了兴趣,针对基本数据类型和其包装类有什么区别?测试过程中应该注意哪些问题呢?

    回答这些问题前,我们先来看看java中基本数据类型和包装类有哪些

     

     

    一、Java中基本数据类型的包装类

     

            Java是面向对象的编程语言,但它也包含了8种基本数据类型以及对它的包装类,主要是为了照顾程序员传统的习惯。同时,也带来了一些方便。例如,在java中,泛型类的定义,使用的参数必须是对象(包装类),无法直接使用基本数据类型;另外,从性能方面来考虑,使用对象进行逻辑处理也会引起额外的开销,对于逻辑多的程序来说,这些开销可能会引起性能的下降,从而影响到服务能力。

           Java的基本数据类型分成boolean类型和数值类型。数值类型又可以分成整型和浮点型。包含:byte、short、int、long、char、float、double、boolean




    下面来看一个程序示例

    程序示例

    1 Integer i = 100;

    2 Integer j = 100;

    3 System.out.print(i == j); //true


    Integer i = 128;

    Integer j = 128;

    6 System.out.print(i == j); //false


           对于第4行,java编译的时候,会先翻译成 Integer i = Integer.valueOf(128)返回一个int值(自动装箱)。而java API中对Integer类型的valueOf的定义如下,对于-128到127之间的数,会进行缓存,Integer i = 127时,会将127进行缓存,下次再写Integer j = 127时,就会直接从缓存中取,就不会new了。


     

    二、Java中8种基本数据类型及其默认值

     包装类对应的初始值是null

    Java中8种基本数据类型总结

     

     

     

     

     

    序号

    数据类型

    大小/位

    封装类

    默认值

    可表示数据范围

    1

    byte(位)

    8

    Byte

    0

    -128~127

    2

    short(短整数)

    16

    Short

    0

    -32768~32767

    3

    int(整数)

    32

    Integer

    0

    -2147483648~2147483647

    4

    long(长整数)

    64

    Long

    0

    -9223372036854775808~9223372036854775807

    5

    float(单精度)

    32

    Float

    0.0

    1.4E-45~3.4028235E38

    6

    double(双精度)

    64

    Double

    0.0

    4.9E-324~1.7976931348623157E308

    7

    char(字符)

    16

    Character

    0~65535

    8

    boolean

    8

    Boolean

    flase

    true或false

     【摘自<https://blog.csdn.net/fysuccess/article/details/40656761>】

     

    三、基本数据类型比包装类性能好?

     

     我们先来看看基本数据类型和包装类在内存中的存储位置

    Java中的基本数据类型是直接存储在堆栈中,能高效读取;包装类是通过引用指向具体实例,实例存储在堆(heap)中,指向实例的引用则存储在堆栈(Stack)中。

     

     

    【以下摘自 thinking in java 第二章】

    Java中,有六个地方都可以保存数据:

    (1) 寄存器。这是最快的保存区域,因为它位于和其他所有保存方式不同的地方:处理器内部。然而,寄存器的数量十分有限,所以寄存器是根据需要由编译器分配。我们对此没有直接的控制权,也不可能在自己的程序里找到寄存器存在的任何踪迹。

    (2) 堆栈。驻留于常规RAM(随机访问存储器)区域,但可通过它的“堆栈指针”获得处理的直接支持。堆栈指针若向下移,会创建新的内存;若向上移,则会释放那些内存。这是一种特别快、特别有效的数据保存方式,仅次于寄存器。创建程序时,Java编译器必须准确地知道堆栈内保存的所有数据的“长度”以及“存在时间”。这是由于它必须生成相应的代码,以便向上和向下移动指针。这一限制无疑影响了程序的灵活性,所以尽管有些Java数据要保存在堆栈里——特别是对象句柄,但Java对象并不放到其中。

    (3) 堆。一种常规用途的内存池(也在RAM区域),其中保存了Java对象。和堆栈不同,“内存堆”或“堆”(Heap)最吸引人的地方在于编译器不必知道要从堆里分配多少存储空间,也不必知道存储的数据要在堆里停留多长的时间。因此,用堆保存数据时会得到更大的灵活性。要求创建一个对象时,只需用new命令编制相关的代码即可。执行这些代码时,会在堆里自动进行数据的保存。当然,为达到这种灵活性,必然会付出一定的代价:在堆里分配存储空间时会花掉更长的时间!

    (4) 静态存储。这儿的“静态”(Static)是指“位于固定位置”(尽管也在RAM里)。程序运行期间,静态存储的数据将随时等候调用。可用static关键字指出一个对象的特定元素是静态的。但Java对象本身永远都不会置入静态存储空间。

    (5) 常数存储。常数值通常直接置于程序代码内部。这样做是安全的,因为它们永远都不会改变。有的常数需要严格地保护,所以可考虑将它们置入只读存储器(ROM)。

    (6) 非RAM存储。若数据完全独立于一个程序之外,则程序不运行时仍可存在,并在程序的控制范围之外。其中两个最主要的例子便是“流式对象”和“固定对象”。对于流式对象,对象会变成字节流,通常会发给另一台机器。而对于固定对象,对象保存在磁盘中。即使程序中止运行,它们仍可保持自己的状态不变。对于这些类型的数据存储,一个特别有用的技巧就是它们能存在于其他媒体中。

     

    通过这段话可以看出,就速度而言,寄存器>堆栈>堆>其他;因此,基本数据类型的性能优于包装类

     

     

    四、基本数据类型和包装类的区别


    1 定义不同。包装类属于对象,基本数据类型不是

    2 声明和使用方式不同。包装类使用new初始化,有些集合类的定义不能使用基本数据类型,例如 ArrayList<Integer>

    3 初始值不同。包装类默认值为null,基本数据类型则不同的类型不一样(具体见上表)

    4 存储方式和位置不同,从而性能不同。基本数据类型存储在 堆栈(stack)中,包装类则分成 引用和实例,引用在堆栈(stack),具体实例在堆(heap)中

     

    五、测试中注意什么?

           回归到测试,在测试中,需要注意什么?

    1 包装类的默认值需要注意。业务逻辑实现中,包装类和基本数据类型默认值是不同的,使用包装类时,如果不注意默认值,当做基本数据类型做兜底策略判空时,可能会引起异常错误

    2 性能不同。因此在 计算密集型的程序设计中,需要注意使用性能问题,也许使用基本数据类型可以有效提高性能呢。

     

     

    六 附录

    为了证明基本数据类型确实比包装类更高效,做一个简单的实验

    实验平台:戴尔笔记本 E5440 

    操作系统:Windows7

    处理器:Intel(R) Core(TM) i5-4300U CPU @ 1.90GHz 2.50GHz

    RAM:8GB

    磁盘:LITEONIT LCS-256M6S 2.5


    程序示例

    public class wrapperTest {
        public static void main(String[] args){
     int[] intArray=new int[10000000];
     int[] intArrayb=new int[10000000];
     Integer[] inteArray=new Integer[10000000];
     //初始化
     for(int i =1;i<=10000000;i++)
            {
                intArray[i-1]=i;
     intArrayb[i-1]=i;
     inteArray[i-1]=i;
     }
     int sum=0;
    
     //int time test
     long startTime=System.currentTimeMillis();
     for(int i =1;i<=10000000;i++)
            {
                sum +=intArray[i-1];
     }
            long endTime=System.currentTimeMillis();
     System.out.println("int 消耗时间:"+(endTime-startTime));
    
     //int time test
     startTime=System.currentTimeMillis();
     for(int j =1;j<=10000000;j++)
            {
                sum +=intArrayb[j-1];
     }
            endTime=System.currentTimeMillis();
     System.out.println("int 消耗时间:"+(endTime-startTime));
    
     //Integer time test
     sum=0;
     startTime=System.currentTimeMillis();
     for(int i =1;i<=10000000;i++)
            {
                sum +=inteArray[i-1];
     }
            endTime=System.currentTimeMillis();
     System.out.println("Integer 消耗时间:"+(endTime-startTime));
     }
    }


    输出结果

    int 消耗时间:10
    int 消耗时间:10
    Integer 消耗时间:21


    这里并不是要做定量分析,更多的是定性结果分析,从简单实验来看,一百万次的数值相加操作,int耗时10ms,Integer耗时 21ms,由此可见基本数据类型的性能更好一些

    展开全文
  • java 包装类 Boolean

    千次阅读 2018-07-28 21:03:47
    Boolean 一个Boolean类型的对象只包含一个类型为boolean的字段,此类还为boolean和String的相互转换提供了很多方法。 构造方法 Boolean(boolean value); 该方法创建一个表示value参数的Boolean对象 ...

    Boolean

    一个Boolean类型的对象只包含一个类型为boolean的字段,此类还为boolean和String的相互转换提供了很多方法。

    构造方法

    Boolean(boolean value);
    该方法创建一个表示value参数的Boolean对象

    创建一个表示value参数的Boolean对象

    Boolean b=new Boolean(true);

    以String变量为参数,创建Boolean对象

    Boolean bool=new Boolean("ok");
    返回值为 boolean 的方法

    1.booleanValue() 将Boolean对象的值以对应的boolean值返回
    2.equals(Object obj)  判断调用该方法的obj是否相等
    3.parseBoolean(String s)  将字符串参数解析为boolean4.valueOf(String s) 返回一个用指定字符串表示的boolean

    返回值为 String

    1.toString()  返回表示boolean值得String对象
    package org.day05hk;
    
    public class GetBoolean {
        public  static void main(String[] args){
            Boolean b1=new Boolean(true);
            Boolean b2=new Boolean("ok");
            System.out.println("b1:"+b1.booleanValue());
            System.out.println("b2:"+b2.booleanValue());
        }
    }
    

    常量

    1.TRUE 对应基值true的Boolean对象
    2.FALSE 对应基值 false 的Boolean对象
    3.TYPE 基本类型boolean的class对象

    展开全文
  • Java包装类对象比较中存在的问题

    千次阅读 2017-07-14 22:21:48
    本文章以Integer包装类为例,讲解一些包装类比较过程中存在的问题。 首先看一段代码: Integer i1 = 10; Integer i2 = 10; System.out.println(i1 == i2);//true Integer i3 = 1000; Integer i4 = 1000;
  • Java包装类与基本类型进行比较的坑

    千次阅读 2017-08-09 18:58:19
    Java包装类与基本类型进行比较的坑
  • Java包装类及自动装箱、拆箱

    千次阅读 多人点赞 2019-03-19 15:00:31
    Java包装类 基本类型 大小 包装器类型 boolean / Boolean char 16bit Boolean byte 8bit Byte short /16bit Short int 32bit Integer long 64bit Long float 32bit Float double 64bit Double...
  • 初识Java(Java包装类-Double 和 Number)

    千次阅读 2018-04-28 23:13:11
    一、Double Double 和 Float 包装类是对 double 、 float 基本类型的封装,它们都是 Number 类的子类,又都是对小数进行操作,所以常用方法基本相同。 Double 类在对象中包装一个基本类型为 double 的值。每个 ...
  • 事件:包装类型为静态变量,与基本类型进行==比较过程中,报空指针异常 Exception in thread "main" java.lang.NullPointerException at com.lei.java8.TestCharaterNull.main(TestCharaterNull.java:9)
  • java包装类为什么会有包装类

    千次阅读 2019-05-26 23:22:30
    Java是面向对象的语言,但并不是“纯面向对象”的,因为我们经常用到的基本数据类型就不是对象。但是我们在实际应用中经常需要将基本数据转化成对象,以便于操作。比如:将基本数据类型存储到Object[]数组或集合中的...
  • 像int类型的包装类Integar 我觉得int本来就是由很多整数组成的啊,我觉得int就是一个类,干嘛还要Integar这样的包装类
  • java包装类的实例化秘密

    千次阅读 2014-11-24 16:01:39
    包装类的实例化 所有的包装类都是不可变的 实例化方法: 构造方法 除了Character类,其他包 Integer(int x) Integer(String x) NumberFormatException异常 对于Boolean构造方法的参数不区分 大...
  • Java包装类传递形参

    千次阅读 2017-08-22 09:52:43
    Java包装类传递形参先看一段程序:package com.interview.bytelearn;/** * 原题链接:https://www.nowcoder.com/questionTerminal/1bab09264a1c4528aa60ee9bca5f0976 */public class Test2 { public static void ...
  • java包装类集合类详解

    2010-06-11 22:27:15
    java包装类和集合类详解,如果对这两个类库还不清楚的 可以参考
  • Java中的包装类

    万次阅读 多人点赞 2019-04-16 15:34:10
    一、包装类概述 二、包装类的自动装箱、自动拆箱机制 三、包装类中的缓存机制 四、包装类的四则运算、位运算、比较运算、逻辑运算 五、包装类作为方法的形参、返回值 六、包装类作为集合的元素 七、包装类使用...
  • Java包装类作用及注意点

    万次阅读 多人点赞 2018-03-16 19:30:50
    Java中对每种基本类型都有一个对应的包装类,这里主要讲解包装类的作用和包装类使用时的一些注意点。 包装类的作用 作用主要有以下两方面: - 编码过程中只接收对象的情况,比如List中只能存入对象,不能存入...
  • Java包装类(wrapper)

    千次阅读 2018-12-01 21:51:43
    定义: Java语言是面向对象的...2、包装类是不可变类,在构造包装类对象后,不允许更改包装在其中的值。 3、方便在基本数据类型与字符串之间进行转换。 4、可以更加便捷的对基本数据类型进行操作。 5、方便在集...
  • java包装类详解

    千次阅读 2014-12-27 17:41:03
    一.java包装类 java语言是一个面向对象的语言,但是Java中的基本数据类型却是不面向对象的,这在实际使用时存在很多的不便,为了解决这个不足,在设计类时为每个基本数据类型设计了一个对应的类进行代表,这样八个...
  • Java包装类(int为例)

    千次阅读 2019-09-16 13:27:54
    Java提供了两个类型系统,基本类型与引用类型,使用基本类型在于效率,然而很多情况,会创建对象使用,因为对象可以做更多的功能,如果想要我们的基本类型像对象一样操作,就可以使用基本类型对应的包装类,如下: ...
  • JAVA包装类的作用

    万次阅读 多人点赞 2019-04-16 12:04:37
    为了使用方便和解决这个不足,在设计类时为每个基本数据类型设计了一个对应的类进行代表,这样八种基本数据类型对应的类统称为包装类(Wrapper Class),包装类均位于java.lang包。 二、包装类的用途 为了使用方便Java...
  • Java 八大包装类(超详细!)

    千次阅读 2021-05-01 16:42:23
    一、8种基本数据类型对应的包装类型名 基本数据类型 包装类型 byte java.lang.Byte(父类Number) short java.lang.Short(父类Number) int java.lang.Integer(父类Number) long java.lang.Long...
  • JAVA包装类

    千次阅读 2018-01-13 15:56:34
    但是Java中的基本数据类型却是不面向对象的,这在实际使用时存在很多的不便,为了解决这个不足,在设计类时为每个基本数据类型设计了一个对应的类进行代表,这样八个和基本数据类型对应的类统称为包装类(Wrapper ...
  • 第1关:基本数据类型和包装类之间的转换 package step1; public class Task { public static void main(String[] args) { //请在此添加实现代码 /********** Begin **********/ //定义float对象 float f = ...
  • Java包装类(Wrapper)作用详解

    千次阅读 2019-08-14 16:47:39
    第一,基本数据类型之间的相互转换不是都可以制动转换的,而你强制转换又会出问题,比如String类型的转换为int类型的,那么jdk为了方便用户就提供了相应的包装类。 例子: public class Integer{ private int i; ...
  • Java包装类的介绍与应用

    千次阅读 2014-07-10 10:58:22
    Java的设计中提倡一种思想,j
  • JAVA包装类Boolean的使用

    千次阅读 2011-12-29 19:04:09
    对于Boolean使用了字符串构造方式,并且之后使用了toString()方法将true和false以字符串形式输出。 /** * 对于Boolean使用了字符串构造方式,并且之后使用了toString()方法将true和false以字符串形式输出。 *...
  • java包装类的意义

    千次阅读 2019-02-20 15:40:48
    java中有8个基本类型,他们是以值的形式...包装类是不可变类,在构造了包装类对象后,不允许更改包装类在其中的值。 基本类型 包装类 int Integer char Character long Long double Double short...
  • java包装类的比较用法

    千次阅读 2018-01-12 10:14:27
    java包装类的比较用法 一、前言 java中 ,包装类是一个对象,也是一个具体的数值。对于对象比较可以用 equals()方法,对于数值的比较可以用 == 进行比较,那么对于包装类该用那种方法比较合适呢? ...
  • 什么是包装类?对基本数据类型进行包装,把基本数据类型包装成一个对象 包装类的作用?把基本数据类型变的更强大,以面向对象的思想来去使用这些类型。
  • Java初学阶段,想必很多人都会先学Java中的一些基本类型以及他们的包装类,如下 int --> Integer long --> Long double --> Double ...等等 很多人在学的时候感觉这用处不大啊,也不知道什么时候用,该...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 307,581
精华内容 123,032
关键字:

java包装类

java 订阅