Java基本类型包装类概述与Integer类、Character类用法分析

更新时间：2019年03月20日 10:31:42 作者：白杨-M

这篇文章主要介绍了Java基本类型包装类概述与Integer类、Character类用法,结合实例形式分析了java基本数据类型与字符串转换相关操作技巧,需要的朋友可以参考下

本文实例讲述了Java基本类型包装类概述与Integer类、Character类用法。分享给大家供大家参考，具体如下：

基本类型包装类概述

将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。

常用的操作之一：用于基本数据类型与字符串之间的转换。

基本类型和包装类的对应

Byte,Short,Integer,Long,Float,Double，Character,Boolean

Integer类

为了让基本类型的数据进行更多的操作，Java就为每种基本类型提供了对应的包装类类型

package cn.itcast_01;
/*
 * 需求1：我要求大家把100这个数据的二进制，八进制，十六进制计算出来
 * 需求2：我要求大家判断一个数据是否是int范围内的。
 *     首先你的知道int的范围是多大?
 *
 * 为了对基本数据类型进行更多的操作，更方便的操作，Java就针对每一种基本数据类型提供了对应的类类型。包装类类型。
 * byte       Byte
 * short      Short
 * int        Integer
 * long        Long
 * float      Float
 * double      Double
 * char        Character
 * boolean      Boolean
 *
 * 用于基本数据类型与字符串之间的转换。
 */
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
    System.out.println(Integer.MAX_VALUE);
    // public static final int MIN_VALUE
    System.out.println(Integer.MIN_VALUE);
  }
}

Integer的构造方法

package cn.itcast_02;
/*
 * Integer的构造方法：
 * public Integer(int value)
 * public Integer(String s)
 *     注意：这个字符串必须是由数字字符组成
 */
public class IntegerDemo {
  public static void main(String[] args) {
    // 方式1
    int i = 100;
    Integer ii = new Integer(i);
    System.out.println("ii:" + ii);
    // 方式2
    String s = "100";
    // NumberFormatException
    // String s = "abc";//这个字符串必须是由数字字符组成
    Integer iii = new Integer(s);
    System.out.println("iii:" + iii);
  }
}

String和int的相互转换

package cn.itcast_03;
/*
 * int类型和String类型的相互转换
 *
 * int -- String
 *     String.valueOf(number)
 *
 * String -- int
 *     Integer.parseInt(s)
 */
public class IntegerDemo {
  public static void main(String[] args) {
    // int -- String
    int number = 100;
    // 方式1
    String s1 = "" + number;
    System.out.println("s1:" + s1);
    // 方式2
    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)
    String s4 = Integer.toString(number);
    System.out.println("s4:" + s4);
    System.out.println("-----------------");
    // String -- int
    String s = "100";
    // 方式1
    // String -- Integer -- int
    Integer ii = new Integer(s);
    // public int intValue()
    int x = ii.intValue();
    System.out.println("x:" + x);
    //方式2
    //public static int parseInt(String s)
    int y = Integer.parseInt(s);
    System.out.println("y:"+y);
  }
}

Integer的进制转换的操作

package cn.itcast_04;
/*
 * 常用的基本进制转换
 * public static String toBinaryString(int i)
 * public static String toOctalString(int i)
 * public static String toHexString(int i)
 *
 * 十进制到其他进制
 * public static String toString(int i,int radix)
 * 由这个我们也看到了进制的范围：2-36
 * 为什么呢?0,...9,a...z，加起来36个
 *
 * 其他进制到十进制
 * public static int parseInt(String s,int radix)
 */
public class IntegerDemo {
  public static void main(String[] args) {
    // 十进制到二进制，八进制，十六进制
    System.out.println(Integer.toBinaryString(100));
    System.out.println(Integer.toOctalString(100));
    System.out.println(Integer.toHexString(100));
    System.out.println("-------------------------");
    // 十进制到其他进制
    System.out.println(Integer.toString(100, 10));
    System.out.println(Integer.toString(100, 2));
    System.out.println(Integer.toString(100, 8));
    System.out.println(Integer.toString(100, 16));
    System.out.println(Integer.toString(100, 5));
    System.out.println(Integer.toString(100, 7));
    System.out.println(Integer.toString(100, -7));
    System.out.println(Integer.toString(100, 70));
    System.out.println(Integer.toString(100, 1));
    System.out.println(Integer.toString(100, 17));
    System.out.println(Integer.toString(100, 32));
    System.out.println(Integer.toString(100, 37));
    System.out.println(Integer.toString(100, 36));
    System.out.println("-------------------------");
    //其他进制到十进制
    System.out.println(Integer.parseInt("100", 10));
    System.out.println(Integer.parseInt("100", 2));
    System.out.println(Integer.parseInt("100", 8));
    System.out.println(Integer.parseInt("100", 16));
    System.out.println(Integer.parseInt("100", 23));
    //NumberFormatException
    //System.out.println(Integer.parseInt("123", 2));
  }
}

JDK5的新特性--自动装箱和自动拆箱

package cn.itcast_05;
/*
 * JDK5的新特性
 * 自动装箱：把基本类型转换为包装类类型
 * 自动拆箱：把包装类类型转换为基本类型
 *
 * 注意一个小问题：
 *     在使用时，Integer x = null;代码就会出现NullPointerException。
 *     建议先判断是否为null，然后再使用。
 */
public class IntegerDemo {
  public static void main(String[] args) {
    // 定义了一个int类型的包装类类型变量i
    // Integer i = new Integer(100);
    Integer ii = 100;
    ii += 200;
    System.out.println("ii:" + ii);
    // 通过反编译后的代码
    // Integer ii = Integer.valueOf(100); //自动装箱
    // ii = Integer.valueOf(ii.intValue() + 200); //自动拆箱，再自动装箱
    // System.out.println((new StringBuilder("ii:")).append(ii).toString());
    Integer iii = null;
    // NullPointerException，如果iii为空对象，会报错，需要判断是否为空
    if (iii != null) {
      iii += 1000;
      System.out.println(iii);
    }
  }
}

-128到127之间的数据缓冲池问题

package cn.itcast_06;
/*
 * 看程序写结果
 *
 * 注意：Integer的数据直接赋值，如果在-128到127之间，会直接从缓冲池里获取数据
 */
public class IntegerDemo {
  public static void main(String[] args) {
    Integer i1 = new Integer(127);
    Integer i2 = new Integer(127);
    System.out.println(i1 == i2);
    System.out.println(i1.equals(i2));
    System.out.println("-----------");
    Integer i3 = new Integer(128);
    Integer i4 = new Integer(128);
    System.out.println(i3 == i4);
    System.out.println(i3.equals(i4));
    System.out.println("-----------");
    Integer i5 = 128;
    Integer i6 = 128;
    System.out.println(i5 == i6);
    System.out.println(i5.equals(i6));
    System.out.println("-----------");
    Integer i7 = 127;
    Integer i8 = 127;
    System.out.println(i7 == i8);//true
    System.out.println(i7.equals(i8));
    // 通过查看源码，我们就知道了，针对-128到127之间的数据，做了一个数据缓冲池，如果数据是该范围内的，每次并不创建新的空间
    // Integer ii = Integer.valueOf(127);
  }
}

Character

Character 类在对象中包装一个基本类型 char 的值

package cn.itcast_01;
/*
 * Character 类在对象中包装一个基本类型 char 的值
 * 此外，该类提供了几种方法，以确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写，反之亦然
 *
 * 构造方法：
 *     Character(char value)
 */
public class CharacterDemo {
  public static void main(String[] args) {
    // 创建对象
    // Character ch = new Character((char) 97);
    Character ch = new Character('a');
    System.out.println("ch:" + ch);
  }
}

Character 类，常见方法。

确定字符的类别（小写字母，数字，等等），并将字符从大写转换成小写

package cn.itcast_02;
/*
 * public static boolean isUpperCase(char ch):判断给定的字符是否是大写字符
 * public static boolean isLowerCase(char ch):判断给定的字符是否是小写字符
 * public static boolean isDigit(char ch):判断给定的字符是否是数字字符
 * public static char toUpperCase(char ch):把给定的字符转换为大写字符
 * public static char toLowerCase(char ch):把给定的字符转换为小写字符
 */
public class CharacterDemo {
  public static void main(String[] args) {
    // public static boolean 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 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 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'));
    System.out.println("-----------------------------------------");
    // public static char toUpperCase(char ch):把给定的字符转换为大写字符
    System.out.println("toUpperCase:" + Character.toUpperCase('A'));
    System.out.println("toUpperCase:" + Character.toUpperCase('a'));
    System.out.println("-----------------------------------------");
    // public static char toLowerCase(char ch):把给定的字符转换为小写字符
    System.out.println("toLowerCase:" + Character.toLowerCase('A'));
    System.out.println("toLowerCase:" + Character.toLowerCase('a'));
  }
}

统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数

package cn.itcast_03;
import java.util.Scanner;
/*
 * 统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)
 *
 * 分析：
 *     A:定义三个统计变量。
 *       int bigCont=0;
 *       int smalCount=0;
 *       int numberCount=0;
 *     B:键盘录入一个字符串。
 *     C:把字符串转换为字符数组。
 *     D:遍历字符数组获取到每一个字符
 *     E:判断该字符是
 *       大写  bigCount++;
 *       小写  smalCount++;
 *       数字  numberCount++;
 *     F:输出结果即可
 */
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 + "个");
  }
}

PS：这里再为大家推荐几款功能相似的在线工具供大家参考：

在线任意进制转换工具：
http://tools.jb51.net/transcoding/hexconvert

字数统计工具：
http://tools.jb51.net/code/zishutongji

在线字母大小写转换工具：
http://tools.jb51.net/transcoding/upper

更多关于java相关内容感兴趣的读者可查看本站专题：《Java字符与字符串操作技巧总结》、《Java数组操作技巧总结》、《Java数学运算技巧总结》、《Java数据结构与算法教程》及《Java操作DOM节点技巧总结》

希望本文所述对大家java程序设计有所帮助。

您可能感兴趣的文章:

java 内部类（匿名类，匿名对象，静态内部类）详解及实例
这篇文章主要介绍了java 内部类详解及实例代码的相关资料,需要的朋友可以参考下
2016-12-12
spring IOC中三种依赖注入方式
这篇文章主要介绍了spring IOC中三种依赖注入方式,Spring使用注入方式，为什么使用注入方式，这系列问题实际归结起来就是一句话，Spring的注入和IoC（本人关于IoC的阐述）反转控制是一回事
2021-08-08
Java教程package和import访问控制的步骤详解
这篇文章主要为大家介绍了Java教程package和import访问控制的步骤详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2023-06-06
详解Java数组的四种拷贝方式
Java数组一共有四种拷贝方式： for循环、copyof/copyOfRange、arraycopy和clone。本文将为大家详细介绍一下这四种方式，感兴趣的可以了解一下
2022-02-02
浅析java程序中hibernate的应用总结
hibernate可以理解为是一个中间件它负责把java程序的sql语句接收过来发送到数据库,而数据库返回来的信息hibernate接收之后直接生成一个对象传给java
2013-07-07
shade解决mybatis包冲突问题
这篇文章主要介绍了shade解决mybatis包冲突问题，本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
2020-08-08
JAVA简单分组的算法实现
本文介绍了“JAVA简单分组的算法实现”，需要的朋友可以参考一下
2013-03-03
SpringMVC拦截器超详细解读
SpringMVC的处理器拦截器,类似于Servlet开发中的过滤器Filter，用于对处理器进行预处理和后处理。依赖于web框架，在实现上基于Java的反射机制，属于面向切面编程（AOP）的一种运用
2022-07-07
详解使用Spring的BeanPostProcessor优雅的实现工厂模式
这篇文章主要介绍了详解使用Spring的BeanPostProcessor优雅的实现工厂模式，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2020-07-07
HttpServletRequest对象方法的用法小结
HttpServletRequest对象代表客户端的请求，当客户端通过HTTP协议访问服务器时，HTTP请求头中的所有信息都封装在这个对象中，开发人员通过这个对象的相关方法，即可以获得客户的这些信息
2017-03-03

Java基本类型包装类概述与Integer类、Character类用法分析

相关文章

最新评论

大家感兴趣的内容

最近更新的内容

常用在线小工具