精华内容
下载资源
问答
  • 基本数据类型的包装类 一:使用规范和特性 01.集合中的泛型类型<T> 不允许出现基本数据类型 02.定义了一个基本数据类型的变量,变量名不能点出来东西, 包装类可以 03.基本数据类型不能转换成对象, 包装类...

    基本数据类型的包装类

    一:使用规范和特性
      01.集合中的泛型类型<T> 不允许出现基本数据类型
      02.定义了一个基本数据类型的变量,变量名不能点出来东西, 包装类可以
      03.基本数据类型不能转换成对象, 包装类可以
      04.所有的包装类都是由final修饰的, 不允许被继承
      05.在基本数据类型需要转换成对象的时候 使用包装类
      06.jdk1.5以后,允许基本数据类型和包装类进行混合运算,底层有装箱和拆箱操作

      基本数据类型   包装类
        byte      Byte
        short     Short
        int      Integer
        long      Long
        float      Float
        double       Double
      上面的六种都是数值类型!都是 extends Number implements Comparable<T>
      Number抽象类:
        public abstract class Number implements java.io.Serializable 支持 序列化

      基本数据类型   包装类
         char      Character
       boolean     Boolean
      上面两种都是 implements java.io.Serializable, Comparable<T>

    二:自动装箱,拆箱的机制
       装箱和拆箱 ===》包装类和对应基本数据类型的转换
       装箱: 把基本数据类型转换成对应的包装类 Integer num=1;
       拆箱: 把包装类转换成对应的基本数据类型 int num2=num;

     1 /**
     2      * 01.所有的包装类 都有将对应的基本数据类型作为参数 来构造自己的实例
     3      * 02.除了Character以外的7种包装类 都有将  String作为参数 来构建自己的实例
     4      * 6种数值类型的包装类都继承了Number
     5      * 所以在用String作为参数来创建自己实例的时候,
     6      * 如果参数不能转换成数值 则抛出 NumberFormatException
     7      */
     8     public void test01() {
     9         //基本数据类型创建对象
    10         Byte b = new Byte((byte) 1);//类型强制转换
    11         Short s = new Short((short) 1);//类型强制转换
    12         Integer i = new Integer(1);
    13         Long l = new Long(1);
    14 
    15         //Float有三种实例化的方法  参数分别是double   float  和 String
    16         Float f = new Float(1.0);
    17         Double d = new Double(5.2);
    18 
    19         Character c = new Character('1'); 
    20         Character c2 = new Character((char) 50);// char的数值取值范围  0-65535
    21         Boolean bo = new Boolean(true);
    22         
    23     }
     1 /**
     2      * 03.除了Character以外的7种包装类 都有parseXxx(String s),
     3      *      用于将字符串封装成相应的包装类,该方法是静态方法。 
     4      *      001. 四种整型对应的包装类 都是 parseXxx(String s,int radix)//radix 进制转换
     5      *      002. 其他的四种都没有 parseXxx(String s,int radix)
     6      *      003. Character压根没有parseXxx()
     7      */
     8  9     public void test03() {
    10         Byte b = new Byte("1");
    11         Short s = new Short("1");
    12         Integer i = new Integer("1");
    13         Long l = new Long("1");
    15         Float f = new Float("1");
    16         Double d = new Double("1");
    17         Character c = new Character('1'); // 没有parseXxx
    18         Boolean bo = new Boolean("TRUE");
    19     }

      装箱和拆箱的操作:

     1 /**
     2      * 04.      valueOf()===》装箱
     3      *      把基本数据类型转换成对应的包装类  
     4      *      除了Character没有参数是String类型的方法
     5      *       xxxValue()方法===》拆箱 
     6      *      把xxx类型转换成对应的基本数据类型  
     7      */
     8     public void test05() {
     9         int num = 5;
    10         Integer i = Integer.valueOf(num); // 装箱
    11         num = i.intValue(); // 拆箱
    12     }        

      进制转换:

    /**
         * 05.进制转换  需要学习 位运算
         */
        @Test
        public void test04() {
            System.out.println("2进制的10对应的数据===》" + Integer.toBinaryString(10));
            System.out.println("8进制的10对应的数据===》" + Integer.toOctalString(10));
            System.out.println("16进制的10对应的数据===》" + Integer.toHexString(10));
        }

      面试题:

    /**
         * 经典的面试题
         *  因为Integer.valueOf() 会缓存  -128 到  127 之间的数据!
         *  如果我们的数字在这个区间,不会去创建新的对象,而是从缓存池中获取!
         *  否则就new  Integer();
         */
        public void test06() {
            int num1 = 127;
            int num2 = 127;
            System.out.println(num1 == num2); // true
            Integer a1 = new Integer(127);
            Integer b1 = new Integer(127);
            System.out.println(a1 == b1);// false
            Integer a = 127;
            Integer b = 127;
            System.out.println(a == b);// true
            Integer c = 128;
            Integer d = 128;
            System.out.println(c == d); // false
        }
        public void test07() {
            System.out.println("1" + 1 + 1);// 111
            System.out.println(1 + 1 + "1" + 1);// 211
        }

     

    转载于:https://www.cnblogs.com/ak666/p/8109110.html

    展开全文
  • 主要记录了基本数据类型的包装类以及自动装箱与自动拆箱。

    上一篇:25.常用类



    一.包装类

    我们知道,Java是一种面向对象的语言,但是,基本数据类型却不是面向对象的。但是Java给我们提供了基本数据类型的包装类,以方便对对象的操作。

    基本数据类型 包装类
    byte Byte
    short Short
    int Integer
    long Long
    float Float
    double Double
    char Character
    boolean Boolean

    在上述的包装类中,除了Character 和Integer类,其余的包装类实际上都是基本数据类型的首字母大写。

    Integer 和 Character

    Integer 和 Character 的常用方法:

    public class Test6 {
    	public static void main(String[] args) {
    		// 基本数据类型的包装类
    		//除了int:Integer 和char:Character其余六种都是首字母大写
    		
    		//Integer
    		Integer integer = new Integer(2021);
    		//表示 int 类型能够表示的最大值
    		System.out.println(integer.MAX_VALUE);
    		//表示 int 类型能够表示的最小值
    		System.out.println(integer.MIN_VALUE);
    		//返回指定的 String的值的 Integer 对象
    		System.out.println(integer.valueOf("2022"));//2022
    		
    		//以 int 类型返回该 Integer 的值
    		System.out.println(integer.intValue());//2021
    		//转换为十进制数
    		System.out.println(integer.parseInt("20222",16));//131618
    		//返回 String 对象
    		System.out.println(integer.toString());//2021
    		//二进制数
    		System.out.println(integer.toBinaryString(2));
    		
    		//Character
    		Character character = new Character('a');
    		//是否是字母
    		System.out.println(character.isLetter('a'));
    		//是否是数字
    		System.out.println(character.isDigit('5'));
    	}
    
    }
    

    二.自动装箱与自动拆箱

    自动装箱是把一个基本数据类型直接赋给对应的包装类。
    自动拆箱是把一个包装类对象直接赋给对应的基本数据类型。
    例如:

    public class Test7 {
    	public static void main(String[] args) {
    		// 自动装箱与自动拆箱
    		Integer number1 = 99;//自动将99包装成Integer
    		int number2 = number1;//自动将99——>int
    		
    		String str =""+number1;//字符串型
    		System.out.println(number1.toString());//"99"
    	}
    
    }
    
    

    展开全文
  • 基本数据类型的包装类 Java是一种纯面向对象语言,但是java中有8种基本数据类型,破坏了java为纯面向对象的特征。为了承诺在java中一切皆对象,java又给每种基本数据类型分别匹配了一个类,这个类我们称之为包装类...
    基本数据类型的包装类

    Java是一种纯面向对象语言,但是java中有8种基本数据类型,破坏了java为纯面向对象的特征。为了承诺在java中一切皆对象,java又给每种基本数据类型分别匹配了一个类,这个类我们称之为包装类。

    注意:每个基本数据类型都有一个与之匹配的包装类。

    1 基本数据类型与其包装类



    包装类的层次结构:




    2 数据的装箱和拆箱
    2.1 装箱和拆箱


    装箱:把基本数据类型包装为对应的包装类对象 

    Integer i1 = new Integer(10);  // 利用构造方法
    Integer i2 = Integer.valueOf(10); //利用包装类中的静态方法

    拆箱:把包装类对象转换为对应的基本数据类型。


    int i3= i1.intValue();  //返回包装类对象i1对应的基本数据


    2.2 自动装箱和自动拆箱


    前面的装箱和拆箱操作,相对较麻烦。自jdk1.5开始,java增加的对基本数据类型的自动装箱和自动拆箱操作。java编译器在编译时期会根据源代码的语法来决定是否进行装箱或拆箱。

    1. 自动装箱:可以直接把一个基本数据类型赋值给包装类
       例如: Double d = 3.3;  //自动装箱操作
    2. 自动拆箱:可以直接把一个包装类对象,赋值给基本类型

       例如:int a = new Integer(3); //自动拆箱。

    示例代码:

      int a1 = 18;
    ​
            Integer i = a1;// 自动装箱  等价于:{int a2 = Integer.valueOf(a1);}
            
            int a2 = i;// 自动拆箱 等价于:{int a2 = i.intValue();}


     
    自动装箱的特点
            Integer a = new Integer(666);
            Integer b = new Integer(666);
            System.out.println(a == b);// false
    ​
            Integer a1 = new Integer(1);
            Integer b1 = new Integer(1);
            System.out.println(a1 == b1);// false
    ​
            Integer a2 = 666;// new Integer(666);
            Integer b2 = 666;// new Integer(666);
            System.out.println(a2 == b2);// false
    ​
            Integer a3 = 127;// 没有new
            Integer b3 = 127;// 没有new
            System.out.println(a3 == b3);// true  内部存储了256个数字,从-128到127,如果输入的数在这个范围就不会new,否则就会new
            
            Integer a4 = Integer.valueOf(126);// 没有new
            Integer b4 = Integer.valueOf(126);// 没有new
            System.out.println(a4 == b4);// true
            
            Boolean bool11 = new Boolean(true);
            Boolean bool12 = new Boolean(true);
            System.out.println(bool11 == bool12);// false
    ​
            Boolean bool21 = true;
            Boolean bool22 = true;
            System.out.println(bool21 == bool22);// true
    ​
            Boolean bool31 = Boolean.valueOf(true);
            Boolean bool32 = Boolean.valueOf(true);
            System.out.println(bool31 == bool32);// true


    2.3 手动装箱 与 手动拆箱

            int a = 12;
            Integer i = new Integer(a);// 手动装箱的过程
            int b = i.intValue();// 手动拆箱的过程
            System.out.println(a == i);// 包装类 与 基本数据类型 比较。则包装类 会 自动拆箱





    展开全文
  • 概念java在设计之初,有一个基本原则:一切皆对象。但是基本数据类型不是对象,不具备“对象”的...基本数据类型及对应的包装类基本数据类型对应的包装类byteByteshortShortintIntegerlongLongfloatFloatdoubleDo...

    概念

    java在设计之初,有一个基本原则:一切皆对象。但是基本数据类型不是对象,不具备“对象”的特性——不携带属性、没有方法可调用。为了解决此类问题,Java为每种基本数据类型分别设计了对应的类,称之为包装类(Wrapper Classes).

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

    基本数据类型

    对应的包装类

    byte

    Byte

    short

    Short

    int

    Integer

    long

    Long

    float

    Float

    double

    Double

    char

    Character

    boolean

    Boolean

    每个包装类的对象可以封装一个相应的基本类型的数据,并提供了其它一些有用的方法。包装类对象一经创建,其内容(所封装的基本类型数据值)不可改变.

    包装类虽然都是object的子类,但严格来说又可分为两种:

    对象包装类(object直接子类):Character、Boolean

    数值包装类(Number直接子类):Byte、Short、Integer、Long、Float、Double

    Number继承了Object类,是一个抽象类。里面定义了六个抽象方法:byteValue()、shortValue()、intValue()、longValue()、floatValue()、doubleValue()。

    数据的装箱与拆箱

    基本类型和对应的包装类可以相互装换:

    由基本类型向对应的包装类转换称为装箱,例如把 int 包装成 Integer 类的对象;

    包装类向对应的基本类型转换称为拆箱,例如把 Integer 类的对象重新简化为 int;

    示例:

    public class testDemo {

    public static void main(String[] args) {

    int m = 500;

    Integer obj = new Integer(m); // 手动装箱

    int n = obj.intValue(); // 手动拆箱

    System.out.println("n = " + n);

    Integer obj1 = new Integer(500);

    System.out.println("obj 等价于 obj1?" + obj.equals(obj1));

    }

    }

    输出结果:

    n = 500

    obj 等价于 obj1?true

    自动拆箱和装箱

    上面的例子都需要手动实例化一个包装类,称为手动拆箱、装箱。Java 1.5 之前必须手动拆箱装箱。

    Java 1.5 之后可以自动拆箱装箱,也就是在进行基本数据类型和对应的包装类转换时,系统将自动进行,并且可以直接利用包装类进行数学计算。

    示例:

    public class testDemo {

    public static void main(String[] args) {

    Integer obj = 10; // 自动装箱

    int n = obj; // 自动拆箱

    System.out.println("n = " + n);

    System.out.println(obj * 2); //包装类直接进行数学计算。

    Integer obj1 = 10;

    System.out.println("obj 等价于 obj1?" + obj.equals(obj1));

    }

    }

    输出结果:

    n = 10

    20

    obj 等价于 obj1?true

    由于存在自动装箱,那么object可以接收一切数据类型了,包括基本数据类型。

    流程:基本数据类型--> 自动装箱--> 向上转型为object

    但object类型不能直接转为基本数据类型,要先转为对应的包装类,然后自动拆箱。

    手动装箱与自动装箱的区别

    手动装箱与自动装箱与String两种实例化方式的区别是一样的。

    自动装箱(即直接赋值)将会比使用构造方法的方式节省一块堆内存空间,并自动入对象池。而手动装箱(使用构造方法)会产生两块堆内存,而且不会保存在对象池中。

    但是和String不同的是包装对象没有intern()方法,无法手动入池。

    示例:

    public class testDemo {

    public static void main(String[] args) {

    Integer obja = 10;//直接赋值,自动装箱

    Integer objb = 10; //直接赋值,自动装箱

    Integer objc = new Integer(10); //手动装箱

    System.out.println(obja == objb);

    System.out.println(obja == objc);

    System.out.println(objb == objc);

    System.out.println(obja.equals(objc));

    }

    }

    输出结果:

    true

    false

    false

    true

    数据类型的转换

    包装类提供了基本数据类型和String类型相互转换的功能。

    将 String 转为基本数据类型

    Integer类:

    public static int parseInt(String s)

    Double类:

    public static double parseDouble(String s)

    Boolean类:

    public static boolean parseBoolean(String s)

    .....

    需要注意的是Character类里面并不存在将字符串变为字符的方法,因为String类有一个charAt()的方法,可以根据索引取出字符。

    基本数据类型转为String

    有两种方式:

    任何基本数据类型与字符串使用了"+"操作之后都将转为String类型。

    在String类中定义有valueOf()方法,该方法可以接收所有的基本数据类型。

    展开全文
  • 基本数据类型的包装类 基本数据类型 包装类 * byte Byte * short Short * int Integer * long Long * float Float * double Double * boolean Boolean * char ...
  • java中基本数据类型的包装类 首先,我们要了解Java中数据类型的分类: 基本数据类型 ps: java中默认小数是double型,整数是int型 char类型的默认值为’\u0000’,打印出来是空字符,也就是什么都没有,强转为整数...
  • java中基本数据类型的包装类也是值传递
  • 【八种基本数据类型的包装类】 byte ——Byte short ——Short int ——Integer long—–Long float—–Float double—-Double char—-Character boolean—Boolean【基本数据类型变成对象包装类的好处】
  • 集合中,不能存储基本数据类型,如果你想要把基本数据类型存储到数组,集 合中,就必须把它转换成基本数据类型的包装类 //1.使用NSNumber 包装 int数据类型 NSNumber * number1 = [NSNumber numberWithInt:a]; NSLog...
  • java基本数据类型的包装类及其转换,取值等相关操作1.基本数据类型对应的包装类2.基本数据类型和布尔型转String3.包装类转基本数据类型4.其它数据类型转String;5.String类几种重要函数: 1.基本数据类型对应的包装类...
  • 1.基本数据类型的包装类 java是一个面向对象编程语言,也就是说一切操作都要用对象的形式进行.但是有个矛盾: 基本数据类型(char,int,double等)不具备对象特性(不携带属性和方法) 这样非面向对象的基本数据类型...
  • 基本数据类型的包装类—  Integer类 字符串和基本数据类型的包装类 ----------- android培训、java培训、java学习型技术博客、期待与您交流! ------------ 1. 基本数据类型包装类 1). 基本数据类型包装类...
  • 概念java在设计之初,有一个基本原则:一切皆对象。但是基本数据类型不是对象,不具备“对象”的...基本数据类型及对应的包装类基本数据类型对应的包装类byteByteshortShortintIntegerlongLongfloatFloatdoubleDo...
  • 基本数据类型对象包装类:为了方便操作基本数据类型值,将其封装成了对象,在对象中定义了属性和行为丰富了该数据操作,用于描述该对象类就称为基本数据类型对象包装类 基本数据类型 包装类  byte Byte  ...
  • 基本数据类型的包装类 包装类基本知识 Java是面向对象的语言,但不是“纯面向对象”,基本数据类型就不是对象。但是我们在实际使用中经常需要将基本数据转化成对象,便于操作。 比如:Object[]数组、集合的...
  • Java每个基本类型在java.lang包中都有一个相应的包装类; 包装类有何作用: 提供了一系列实用的方法; 集合不允许存放基本数据类型数据,存放数字时,要用包装类型; 基本数据类型 包装类 byte Byte short Short ...
  • 基本数据类型的包装类为什么需要包装类? Java语言是一个面向对象的语言,但是Java中的基本数据类型却是不面向对象的, 在很多时候却需要使用的是Object类型。这在实际使用时存在很多的不便,为了解决 这个不足,...
  • Java学习(十)基本数据类型的包装类

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,835
精华内容 3,934
关键字:

基本数据类型的包装类