包装类知识点

文章目录

• • 1.基本数据类型和包装类的对应
  • 2. 8种包装类种其中6个都是数字对应的包装类，他们的父类都是Number，可以先研究一下Number中公共方法：
  • 3.装箱和拆箱
  • 4.以int Integer类为案例学习
  • • • • int到Integer类：
        • Integer类到 int:
        • int到String String到int
  • 5.Character类
  • • • • 1.Character类概述：
        • 2.Character类的构造方法：
        • • 3.Character类的方法：

1.基本数据类型和包装类的对应

基本数据类型：byte、short、int、long、floot、double、boolean、char
8种包装类型：Byte、Short、Integer、Long、Floot、Double(父类都是Number)、Boolean、Character（父类都是Object）

2. 8种包装类种其中6个都是数字对应的包装类，他们的父类都是Number，可以先研究一下Number中公共方法：

Number是一个抽象类，无法实例化对象
​ Number类中有这样的方法：
 ​ byte byteValue()以 byte 形式返回指定的数值。
 ​ abstract double doubleValue() 以 double 形式返回指定的数值。
 ​ abstract float floatValue()以 float 形式返回指定的数值。
    abstract int intValue()以 int 形式返回指定的数值。
​      abstract long longValue()以 long 形式返回指定的数值。
  ​ short shortValue() short 形式返回指定的数值。

​ 这些方法是负责拆箱的[把引用数据类型都转换成基本数据类型]

3.装箱和拆箱

 装箱：将基本数据类型变为包装类对象。
 拆箱：将包装类中包装的基本数据类型取出。

package Integer;
/*
关于Integer类的构造方法，有两个：
    Integer(int)
    Integer(String)

 */
public class Test02 {
    public static void main(String[] args) {
        //将数字100转换为Integer类型
        Integer x = new Integer(100);
        System.out.println(x);
        //将字符串123转换为Integer类型
        Integer y = new Integer("123");
        System.out.println(y);

        Double d = new Double(1.23);
        System.out.println(d);
        Double e = new Double(1);
        System.out.println(e);
    }

package Integer;
/*
在JDK1.5之后支持自动拆箱和自动装箱
 */
public class Test04 {
    public static void main(String[] args) {
       Integer x = 100;//自动装箱 int类型自动转换为Integer
       int y = x;//自动拆箱  Integer自动转换为int
    }
}

4.以int Integer类为案例学习

int到Integer类：

 三种方法：
    （１）使用Integer类的构造方法
 （２）使用Integer类内部的valueOf( )方法
（３）自动装箱

方法1：使用Integer类的构造方法

public Integer(int value)：将int类型转换为Integer类。
public Integer(String s)：将String类型转换为Integer类。
注意：使用此构造方法时，字符串内的字符必须由数字组成，不可以是字母或者
其他形式 ，否则抛出NumberFormatException。

public static void main(String[] args)
  {
    //方式1:public Integer(int value)
  	int i= 100;
  	//将int类型的i转换为Integer类型的ii
  	Integer ii = new Integer(i);
  	System.out.println("ii:"+ii);
  	
  	//方式２:public Integer(String s)
  	String s = "100";
  	//String s = "abc";出错,因为这个字符串必须由数字字符组成。	
  	Integer iii = new Integer(s);
  	System.out.println("iii:"+iii);//100	
  }

方法2:使用Integer类内部的valueOf方法

    public static Integer valueOf(int i)：将int类型转换为Integer类。

Integer i3 = Integer.valueOf(30);

方法3:自动装箱的方法

 Integer ii = 100;//编译器自动执行了Integer ii = Integer.valueOf(100)	

相关面试题：

public static void main(String[] args)
	{
		Integer i1 = new Integer(127);
		Integer i2 = new Integer(127);
		System.out.println(i1 == i2);//false
		System.out.println(i1.equals(i2));//true 重写了equals方法，比较的内容
		
		
		Integer i3 = new Integer(128);
		Integer i4 = new Integer(128);
		System.out.println(i3 == i4);//false
		System.out.println(i3.equals(i4));//true
	
		Integer i5 = 128;
		Integer i6 = 128;
		System.out.println(i5 == i6);//false
		System.out.println(i5.equals(i6));//true
		
		Integer i7 = 127;
		Integer i8 = 127;
		System.out.println(i7 == i8);//true
		System.out.println(i7.equals(i8));//true
		

Integer类到 int:

 （１）调用包装类的intValue()方法
 （２）通过自动拆箱：

方法1:调用包装类的intValue()方法

      public int intValue()：以 int 类型返回该 Integer 的值。

public void test2() {
        Integer i1 = new Integer(14);
        Float f1 = new Float(12.3F);
        //1.调用包装类的XxxValue()方法
        int i2 = i1.intValue();//i2 = 14
        float f2 = f1.floatValue();//f2 = 12.3
        }

方法2:通过自动拆箱：

       编译器自动执行了valueOf方法

        //5是基本数据类型，通过自动装箱变成对象类型。
        //编译器执行了Integer iii = Integer.valueOf(5)
        Integer iii=5;
        //自动拆箱，实际上执行了 int iii2 = iii.intValue()
        int iii2=iii;
        System.out.println(iii2);

int到String String到int

public static void main(String[] args)
	{
		//int--String把int类型的数据转化为字符串的形式
		int number = 100;
		
		//方式１:字符串的拼接
		String s1 = "" + number;
		System.out.println("s1:"+s1);
		
		//方式２:String类的valueOf可以把任意类型的数据转换成String类型
		String s2 = String.valueOf(number);
		System.out.println("s2:"+s2);
		
		//方式3
		//int -- Integer -- String
		Integer i = new Integer(number);
		String s3 = i.toString();
		System.out.println("s3:"+s3);
		
		//方式4
		//public static String toString(int i)返回一个表示该 Integer 值的 String 对象。
		String s4 = Integer.toString(number);
		System.out.println("s4:"+s4);
		
		
		//String--int
		String s ="100";
		//方式１
		//String--Integer--int
		//String--Integer
		Integer ii = new Integer(s);
		//Integer--int
		//public int intValue()以 int类型返回该 Integer的值
		 int x = ii.intValue();
		System.out.println("x:"+x);
		
		//方式２
		//public static int parseInt(String s)
		int y = ii.parseInt(s);
		System.out.println("y:"+y);
	}

5.Character类

1.Character类概述：

Character类在对象中包装了一个char的值,用于对单个字符进行操作。
该类提供了几种方法来操纵字符，以确定字符的类别（小写字母，数字，等等），
并将字符从大写转换成小写等。

2.Character类的构造方法：

public Character(char value)：将char类型转换为Character类。

Character ch1 = new Character('a');
System.out.println("ch1:"+ch1);  //ch1:97

3.Character类的方法：

public static void main(String[] args)
	{
		//public static boolean isUpperCase(int codePoint)判断给定的字符是否为大写字符
		System.out.println(Character.isUpperCase('A'));
		System.out.println(Character.isUpperCase('a'));
		System.out.println(Character.isUpperCase('0'));
		
		//public static boolean isLowerCase(char ch):判断给定的字符是否是小写字符
		System.out.println(Character.isUpperCase('A'));
		System.out.println(Character.isUpperCase('a'));
		System.out.println(Character.isUpperCase('0'));
		
		// public static boolean isDigit(int codePoint):判断给定的字符是否是数字
		System.out.println(Character.isUpperCase('A'));
		System.out.println(Character.isUpperCase('a'));
		System.out.println(Character.isUpperCase('0'));
		
		//public static char toUpperCase(char ch):把给定的字符转换为大写字符
		System.out.println(Character.toUpperCase('a'));
		
		//public static char toLowerCase(char ch):把给定的字符转换为小写字符
		System.out.println(Character.toLowerCase('A'));
	}