一.包装类：

1.包装类：

Java语言是一个面向对象的语言，但是Java中的基本数据类型却是不面向对象的。基本类型的数据不具备"对象"的特性（没有成员变量和成员方法可以调用），因此，java为每种数据类型分别设计了对应的类，即包装类。

（1）所有包装类都是final类型，因此不能创建他们的子类。
（2）包装类是不可变类，一个包装类的对象自创建后，他所包含的基本类型数据就不能被改变。

2.包装类的特点：

二.Integer类

1.装箱和拆箱

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

2.int到nteger类：

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

（1）方法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:自动装箱的方法:
事实上，编译器自动执行了valueOf方法。

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

valueOf源码分析：

public static Integer valueOf(int i) {
     assert IntegerCache.high>= 127;
     if (i >= IntegerCache.low&& i <= IntegerCache.high)
     return IntegerCache.cache[i+ (-IntegerCache.low)];
     return new Integer(i); 
}

通过查看原码可知，java针对-128-127之间的数据做了一个数据缓冲池。
如果数据是该范围内的，每次并不创建新的空间。
如果数据是该范围内的，就new一个空间

相关面试题：

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

3.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);

4.int类型数据和String形式之间的相互转换：

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.进制的转换：

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,15));
        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,34));
        System.out.println(Integer.toString(100,37));
        System.out.println(Integer.toString(100,36));

        //其他进制转换为十进制
        System.out.println(Integer.parseInt("100",10));
        System.out.println(Integer.parseInt("100",2));
        System.out.println(Integer.parseInt("100",4));
        System.out.println(Integer.parseInt("100",16));
        System.out.println(Integer.parseInt("100",23));
        //System.out.println(Integer.parseInt("123",2));出错，因为2进制没有3
    }

三.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

注意：char和Character类之间的转换方法与int和Integer类之间的转换方法相同

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‘));
    }

包装类

原文：https://blog.51cto.com/14954398/2557581