java程序员从笨鸟到菜鸟之(十六)包装类型Inter和Character

最新推荐文章于 2021-02-27 10:16:49 发布

wzj_110

最新推荐文章于 2021-02-27 10:16:49 发布

阅读量491

点赞数

分类专栏： Java 文章标签：包装类型

本文链接：https://blog.csdn.net/wzj_110/article/details/78403958

版权

Java 专栏收录该内容

67 篇文章 1 订阅

订阅专栏

Inter

Jdk5.0以后的新特性：自动拆装箱

自动拆装箱解释：

实例1：

package org.westos.integer_03;
/**
 * Jdk5.0以后的新特性:自动拆装箱
 * @author Apple
 */
public class IntegerTest2 {
	
	public static void main(String[] args) {
		//创建一个Integer对象
		Integer i = new Integer(100) ;
		i += 200 ;
		System.out.println("i:"+i);
		
		/**
		 * 通过反编译工具查看源码:
		 * 	Integer i = new Integer(100); //将int类型值通过构造的形式自动装箱为Integer类型
			i = Integer.valueOf(i.intValue() + 200);//i.intValue()--->int类型的数据:把Integer--->int:自动拆箱
			自动装箱了
			System.out.println((new StringBuilder("i:")).append(i).toString());
		 */
	}
}

实例2：

package org.westos.integer_03;
/**
 * Integer类的构造方式:
 * 	public Integer(int value):将一个int类型的数据封装成一个引用类型
 * 	public Integer(String s):将一个字符数类型封装成一个Integer类型
 * 			注意事项:
 * 				该字符串必须是数字字符串!,否则:java.lang.NumberFormatException
 * @author Apple
 */
public class IntegerDemo2 {
	
	public static void main(String[] args) {
//		public Integer(int value)
		//创建一个Integer对象
		Integer i = new Integer(100);
//		Integer i = 100 ;//jdk5以后的自动装箱!
		System.out.println("i:"+i);
		
		//public Integer(String s)
//		String s = "abc" ;
		String s = "20" ;
		Integer ii = new Integer(s) ;
		System.out.println("s:"+s);
	}
}

实例3：

package org.westos.integer_03;
/**
 * 需求:求一个整数100对应的二进制,八进制,十六进制
 * 需求:要求出Integer类型范围:
 * 
 * java的jkd5.0以后:还有一些新特性:自动拆装箱,可变参数,增强for循环,静态导入,枚举...
 * 	
 * 对于每个基本数据类型都会被自动封装成一个引用类型
 * 		基本类型				引用类型
 * 		int					Integer
 * 		char				Character
 * 		byte				Byte
 * 		boolean				Boolean
 * 		double				Double
 * 		float				Float
 * 		long				Long
 * 		short				Short
 * 
 * 将基本类型--->引用类型的作用:就是为了和String类型作为转换
 * 				
 * @author Apple
 */
public class IntegerDemo {
	
	public static void main(String[] args) {
		//public static String toBinaryString(int i)
		System.out.println(Integer.toBinaryString(100)) ;
		
		//public static String toOctalString(int i)
		System.out.println(Integer.toOctalString(100));
		
		//public static String toHexString(int i)
		System.out.println(Integer.toHexString(100));
		
		//public static final int MAX_VALUE
		//public static final int MIN_VALUE
		System.out.println(Integer.MAX_VALUE);//2147483647
		System.out.println(Integer.MIN_VALUE);//-2147483647
	}
}

实例4：

package org.westos.integer_03;
/**
 * int类型和String类型的相互转换
 * @author Apple
 */
public class IntegerTest {
	
	public static void main(String[] args) {
		
		//定义一个int类型的数据
		int number = 100 ;
		
		//方式1)字符串拼接符
		String s1 = "" + number ;
		System.out.println("s1:"+s1);
		
		//方式2:int--->Integer类型
		Integer i = new Integer(number) ;
		//Integer--->String
		//public String toString()
		String s2 = i.toString() ;
		System.out.println("s2:"+s2);
		
		//方式3)public static String toString(int i)
		String s3 = Integer.toString(number) ;
		System.out.println("s3:"+s3);
		//方式4)
		//public static Integer valueOf(int i)
		Integer integer= Integer.valueOf(number) ;
		String s4 = integer.toString() ;
		System.out.println("s4:"+s4);
		
		System.out.println("---------------------------");
		
		//定义一个字符串:
		String s = "10" ;
		//方式1:String--->Integer---->int
		Integer ii = new Integer(s) ;
		//public int intValue()以 int 类型返回该 Integer 的值
		int num = ii.intValue() ;
		System.out.println("num:"+num);
		//public static int parseInt(String s)
		int num2 = Integer.parseInt(s) ;
		System.out.println("num2:"+num2);
		
		
		//Integer的内存缓存区:IntegerCashe
		//low = -128
		//high=127
		Integer i1 = 127 ;		//----->底层在封装的时候:Integer integer = Inteter.valueOf(int i) ;
		Integer i2 = 127 ;
		
		
		
		System.out.println(i1==i2);//true
		Integer i3 = 128 ;
		Integer i4 = 128 ;
		System.out.println(i3==i4);//false

	}
}

Character类

实例1：

package org.westos.character_04;
/**
 * Character类在对象中包装一个基本类型 char的值。Character类型的对象包含类型为char的单个字段
 * 构造方法:
 * 		public Character(char value)构造一个新分配的 Character 对象，用以表示指定的 char 值。 
 * @author Apple
 */
public class CharacterDemo {
	
	public static void main(String[] args) {
		//创建一个Character类的对象
//		Character character = new Character((char)97) ;
		Character character = new Character('a') ;
		System.out.println("character:"+character);
	}
}

实例2：

package org.westos.character_04;
/**
 * Character类的判断功能:
 * 	public static boolean isLowerCase(char ch)确定指定字符是否为小写字母。
 * 	public static boolenn isUpperCase(char ch)确定指定字符是否为大写字母
 * 	public static boolean isDigit(char ch)确定指定字符是否为数字。
 * 
 * Character常用的转换功能:
 * 		public static char toUpperCase(char ch):将指定字符转换成大写
 * 		public static char toLowerCase(char ch):将指定字符转换成小写
 * 	
 * 需求:键盘录入一个字符串,统计该字符串中大写字母字符,小写字母字符,数字字符有多少个(不考虑其他字符,使用Character提供的判断功能去完成)
 * @author Apple
 */
public class CharacterDemo2 {
	public static void main(String[] args) {
		
		//public static boolean isLowerCase(char ch)确定指定字符是否为小写字母
		System.out.println("isLowerCase:"+Character.isLowerCase('a'));
		System.out.println("isLowerCase:"+Character.isLowerCase('A'));
		System.out.println("isLowerCase:"+Character.isLowerCase('0'));
		System.out.println("---------------------------------------");
		//public static boolenn isUpperCase(char ch)确定指定字符是否为大写字母
		System.out.println("isUpperCase:"+Character.isUpperCase('a'));
		System.out.println("isUpperCase:"+Character.isUpperCase('A'));
		System.out.println("isUpperCase:"+Character.isUpperCase('0'));
		System.out.println("---------------------------------------");
		//public static boolean isDigit(char ch)确定指定字符是否为数字。
		System.out.println("isDigit:"+Character.isDigit('a'));
		System.out.println("isDigit:"+Character.isDigit('A'));
		System.out.println("isDigit:"+Character.isDigit('0'));
		
		
	}
}

实例3：

package org.westos.character_04;

import java.util.Scanner;

/**
 * 需求:键盘录入一个字符串,统计该字符串中大写字母字符,小写字母字符,数字字符有多少个(不考虑其他字符,使用Character提供的判断功能去完成)
 * 	分析:
 * 		1)定义三个统计变量
 * 			bigCount 
 * 			smallCount
	 * 		numberCount
	 * 2)创建键盘录入对象,录入并接收一个字符串
	 * 3)将字符串转换成字符数组
	 * 4)遍历字符数组,获取到每一个字符
	 * 5)使用Character类中的判断功能判断是否是大写,小写,数字字符
	 * 6)输出
 * 		
 * @author Apple
 */
public class CharacterTest {
	
	public static void main(String[] args) {
		//定义三个统计变量
		int bigCount = 0 ;
		int smallCount = 0 ;
		int numberCount = 0;
		
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//录入并接收数据
		System.out.println("请您输入一个字符串:");
		String line = sc.nextLine();
		
		//将字符串转换成字符数组
		char[]  chs = line.toCharArray() ;
		for(int x = 0 ; x < chs.length ; x ++){
			//获取每一个字符
			char ch = chs[x] ;
			
			//判断
			if(Character.isUpperCase(ch)){
				bigCount ++ ;
			}else if(Character.isLowerCase(ch)){
				smallCount ++ ;
			}else if(Character.isDigit(ch)){
				numberCount ++ ;
			}
		}
		
		//输出
		System.out.println("大写字母字符共有:"+bigCount+"个");
		System.out.println("小写字母字符共有:"+smallCount+"个");
		System.out.println("数字字符共有:"+numberCount+"个");
	}
}

实例4：

package 测试2;

public class Demo2 {
	public static void main(String[] args) {
		// 5种整形的包装类Byte,Short,Integer,Long,Character的对象，
		// 在值小于127时可以使用常量池,也即对象不负责创建和管理大于127的这些类的对象；
		Integer i1 = 127;
		Integer i2 = 127;
		System.out.println(i1 == i2); // 输出true
		/*
		 *对Integer对象的代码补充:
		public static Integer valueOf(int i) {
			final int offset = 128;
			if (i >= -128 && i <= 127) {

				return IntegerCache.cache[i + offset];
			}
			return new Integer(i);
		}
		*/

		// 值大于127时，不会从常量池中取对象
		Integer i3 = 128;
		Integer i4 = 128;
		System.out.println(i3 == i4); // 输出false

		// Boolean类也实现了常量池技术
		Boolean bool1 = true;
		Boolean bool2 = true;
		System.out.println(bool1 == bool2); // 输出true

		// 浮点类型的包装类没有实现常量池技术()
		Double d1 = 1.0;
		Double d2 = 1.0;
		System.out.println(d1 == d2); // 输出false
	}


}