Java面向对象
Java异常
Java数组
Java常用类
Java集合
Java IO流
Java线程
Java反射
Socket编程
Java注解开发
Java GoF设计模式
HashMap
Java内存模型
Java线性表

Java包装类

Java包装类概述

Java为每个基本数据类型都提供了一个对应的包装类

基本类型

包装类

byte

Byte

short

Short

int

Integer

long

Long

float

Float

double

Double

char

Character

boolean

Boolean

为什么要提供包装类?

package com.wkcto.chapter04.wrapperclass;
/**
 * 为什么提供包装类??
 * 		为了编程更加方便
 * 
 * @author 蛙课网
 *
 */
public class Test01 {

	public static void main(String[] args) {
		
		m1("hello"); 		//把"hello"字符串对象的引用传递给形参xx
		
		m1(456); 
		/*
		 *  在调用方法时 ,不能直接把456 等基本类型数据传递给形参xx
		 *  这儿没有出现错误, 因为系统会自动的把整数 456 转换为对应的包装类对象, 再把这个包装类对象的引用传递给xx形参
		 *  在本例中,如果没有包装类的话, 需要定义很多的方法重载来接收不同类型的数据, 如果有了包装类,只需要定义一个方法即可
		 */
		
	}
	
	//定义一个方法,该方法可以接收任意类型的数据,包括整数,小数,字符,布尔, 引用类型数据都可以	
	public static void m1( Object xx ) {   	//形参xx只能接收引用类型的数据
		
	}

}

包装类的继承结构图

Java包装类对象的创建

Character包装类的构造方法只有一个,根据基本类型创建包装类对象

其他的包装类构造方法都有两个, 根据基本类型创建包装类对象, 根据字符串创建包装类对象

package com.wkcto.chapter04.wrapperclass;
/**
 * 创建包装类对象
 * @author 蛙课网
 *
 */
public class Test02 {

	public static void main(String[] args) {
		//1) 根据基本类型创建包装类对象
		Boolean bb = new Boolean(true);
		Character cc = new Character('A');
		Integer ii = new Integer(456);
		Double dd = new Double(3.14);
		
		//2) 根据字符串创建包装类对象,  Character没有这个构造方法
		Integer i2 = new Integer("369");
		Double dd2 = new Double("2.58");
		//注意, 根据字符串创建包装类对象时, 字符串要符合数字的格式
//		i2 = new Integer("abc"); 	// java.lang.NumberFormatException 数字格式异常
		dd2 = new Double("2e3");	//科学计数法
		System.out.println( dd2 );  //2000.0
		dd2 = new Double("147");
		System.out.println( dd2 ); 
//		dd2 = new Double("147wkcto");  //java.lang.NumberFormatException

		Boolean bb2 = new Boolean("true");
		System.out.println( bb2 );
		//注意, Boolean包装类会把"true"字符串转换为true, 其他的字符串都转换为false
		bb2 = new Boolean("hehe");
		System.out.println( bb2 );
		
	}

}

Java包装类的字段

package com.wkcto.chapter04.wrapperclass;
/**
 * 包装类的常量 
 * @author 蛙课网
 *
 */
public class Test03 {

	public static void main(String[] args) {
		System.out.println( Integer.BYTES);			//4
		System.out.println( Integer.SIZE);			//32
		System.out.println( Integer.TYPE);			//int
		System.out.println( Integer.MIN_VALUE);		//-2147483648
		System.out.println( Integer.MAX_VALUE);		//2147483647
		
		System.out.println( Double.POSITIVE_INFINITY);
		System.out.println( Double.NEGATIVE_INFINITY);
		System.out.println( Double.NaN);
		
//		System.out.println( 10 / 0 );  		//java.lang.ArithmeticException
		System.out.println( 10 / 0.0 ); 	//Infinity
		System.out.println( -10 / 0.0 ); 	//-Infinity
		System.out.println( 0 / 0.0 ); 		//NaN,  Not a Number
		
		System.out.println("----------------");
		System.out.println( Character.MIN_VALUE);
		System.out.println( Character.MAX_VALUE);
		System.out.println( (int)Character.MIN_VALUE);
		System.out.println( (int) Character.MAX_VALUE);
	}

}

Java包装类的常用方法

package com.wkcto.chapter04.wrapperclass;
/**
 * 包装类的常用 方法
 * @author 蛙课网
 *
 */
public class Test04 {

	public static void main(String[] args) {
		Integer i1 = new Integer(147);
		
		//每个包装类都有一个value字段,保存的是这个包装类对应的基本类型数据
		//1) 从Number继承的方法,可以把包装类对象转换为基本类型的数据, 实际上是把value字段进行强制类型转换
		double dd = i1.doubleValue();
		byte bb = i1.byteValue(); 			//-128~127
		System.out.println( dd );
		System.out.println( bb  );
		
		//2)包装类都实现了Comparable接口,重写了compareTo()方法, 可以比较两个包装类的大小, 根据value字段
		Integer i2 = new Integer("258");
		System.out.println( i1.compareTo(i2));    		//-1  表示i1小于i2
		Boolean bb1 = new Boolean(true);
		Boolean bb2 = new Boolean(false);
		System.out.println( bb1.compareTo(bb2)); 		//1
		
		//3) 都重写了equals()
		System.out.println( i1.equals(i2));
		System.out.println( bb1.equals(bb2));
		//小数采用近似值保存,有时不准确, 如0.1在计算机中是无法准确的表示
		System.out.println( Double.doubleToLongBits(1.1));
		System.out.println( Double.doubleToLongBits(0.9));
		System.out.println( 2 - 1.1 );
		System.out.println( Double.doubleToLongBits(2-1.1));
		System.out.println( Double.doubleToLongBits(2-1.1) == Double.doubleToRawLongBits(0.9));
		
		//4) Integer.parseInt(String)可以把字符串转换为int数据
		String text = "456";
		int num = Integer.parseInt(text);
		System.out.println( num );
		//Double.parseDouble(String)可以把字符串转换为double数据
		double pi = Double.parseDouble("3.14");
		//Boolean.parseBoolean(String) 可以把字符串转换为boolean数据
		boolean flag = Boolean.parseBoolean("true");
		//在把字符串转换为基本类型数据时, 字符串要符合目标类型的格式
//		num = Integer.parseInt("3.14");  //java.lang.NumberFormatException
		
		//5) 把十进制数转换为二进制/八进制/十六进制
		System.out.println( Integer.toBinaryString(100));
		System.out.println( Integer.toOctalString(100));
		System.out.println( Integer.toHexString(100));
		
		//6) toString(int) 把基本类型转换为字符串
		text = Integer.toString(100);
		text = Double.toString(3.14);
		text = Boolean.toString(false);
		
		//7) valueOf() 把基本类型/字符串转换为包装类对象
		i1 = Integer.valueOf(258);
		i1 = Integer.valueOf("147");  	//字符串要符合数字格式		
		Double double1 = Double.valueOf(3.14);
		double1 = Double.valueOf("3.56");		
		Boolean boolean1 = Boolean.valueOf(false);
		boolean1 = Boolean.valueOf("adjklfj");				
	}
}

Java装箱与拆箱

装箱就是把基本类型数据转换为包装类对象。

拆箱就是把包装类对象转换为基本类型数据。

在Java中, 装箱与拆箱可以自动进行,

package com.wkcto.chapter04.wrapperclass;
/**
 * 装箱与拆箱
 * @author 蛙课网
 *
 */
public class Test05 {

	public static void main(String[] args) {
		Integer i1 = 789; 		//自动装箱, 系统根据基本类型数据789自动创建一个包装类对象 , 把该对象的引用保存到i1中
		Integer i2 = 789; 		//根据789创建一个新的Integer对象, 把该对象的引用保存到i2中
		
		int num = i1; 			//自动拆箱, 系统把i1对象的value字段赋值给num
		
		//包装类对象判等
		System.out.println( i1.equals(i2));   	//true
		System.out.println( i1 == i2 ); 		//false
		
		Integer i3 = 88;
		Integer i4 = 88;
		System.out.println( i3 == i4 ); 		//true
		/*
		 * Java认为-128~127之间的整数是使用最频繁的, 这个范围内的整数装箱后采用享元模式
		 * 	-128~127之间的整数生成的包装类对象存储在方法区的常量池中
		 * 	在执行i3 = 88时, 会在常量池中创建一个包装类对象, 
		 * 	在执行 i4 = 88时, 直接把常量池中的包装类对象的引用赋值给i4, 即现在i3和i4引用了常量池中同一个包装类对象
		 */
		
		Long  gg1 = 123L;
		Long  gg2 = 123L;
		System.out.println( gg1 == gg2 );  		//true
		
	}

}

练习 int/String/Integer之间的相互转换

String  text = “456”;

int  num = Integer.parseInt(  text  );

text = “” + num;

text = String.valueOf( num );

text = Integer.toString( num )

全部教程