知识点1-Java中的包装类型

• 使用原始数据类型声明的变量，如：

  • int num = 10；

  • 这里的num只是一个变量，而不是对象；

• Java提供一系列包装类，以便将原始数据类型当作对象进行操作；

  • 好处：基本数据类型封装成对象，在对象中定义了属性和方法，可以方便的操作该数据（得到整型最大值，最小值，进制转换等等）

• 在java.lang包中，对于每个基本数据类型都有一个相应的包装类。

• Java语言中的8个包装器类型如下所示；

  类型	字节型	短整型	整型	长整型	单精度 浮点型	双精度 浮点型	字符型	布尔型
  基本数据类型	byte	short	int	long	float	double	char	boolean
  包装器类型	Byte	Short	Integer	Long	Float	Double	Character	Boolean

  • 除了整型及字符型外，其他的包装器类型名字都是将基本数据类型首字、母变大写即可；

  • 以Integer类为例，可以把int类型转换成Integer引用类型；

知识点2- Integer类

• 以Integer为例：

  public final class Test extends Number implements Comparable<Integer>{
      //此类是final的，不能派生出子类
  }

• 基本数据类型和字符串之间的转换

• 举开发中例子说明

  public class Test {
      public static void main(String[] args) {
          String count = "10";
          //字符串转成基本数据类型int
          int c = Integer.parseInt(count);
          System.out.println("字符串\"10\"转成基本数据类型int：" + c);
      }
  }
  /**
   *字符串"10"转成基本数据类型int：10
   */

• 以Integer为访问类里的属性:

  public class Test {
      public static void main(String[] args) {
          //int类型表示范围是 -2^31 到 2^31-1
          System.out.println(Integer.MAX_VALUE+"(2^31-1)");
          System.out.println(Integer.MIN_VALUE+"(-2^31)");
      }
  }
  /**
   *2147483647(2^31-1)
   * -2147483648(-2^31)
   */

• Integer的构造方法:

知识点3- Java中的包装类型-Integer静态方法

• 除了Character类以外，其它的包装类都有静态的parseXxx方法（Xxx指代具体的数据类型），用于将字符串转换成相对应的基本数据类型值。

  //类型转换 ParseXxx
  public class ParseTest {
      public static void main(String[] args) {
          //被转换的字符串
          String str = "118";
          //int
          int i = Integer.parseInt(str);
          System.out.println("把字符串118转换成int值：" + i);
          //short
          short s = Short.parseShort(str);
          System.out.println("把字符串118转换成short值：" + s);
          //byte
          byte b = Byte.parseByte(str);
          System.out.println("把字符串118转换成byte值：" + b);
          //long
          long l = Long.parseLong(str);
          System.out.println("把字符串118转换成long值：" + l);
          //float
          float f = Float.parseFloat(str);
          System.out.println("把字符串118转换成float值：" + f);
          //double
          double d = Double.parseDouble(str);
          System.out.println("把字符串118转换成double值：" + d);
          //boolean
          boolean bl = Boolean.parseBoolean("true");
          System.out.println("把字符串true转换成boolean值：" + bl);
      }
  }
  /**
   * 把字符串118转换成int值：118
   * 把字符串118转换成short值：118
   * 把字符串118转换成byte值：118
   * 把字符串118转换成long值：118
   * 把字符串118转换成float值：118.0
   * 把字符串118转换成double值：118.0
   * 把字符串true转换成boolean值：true
   */

知识点4- Java中的包装类型-Character类的常用方法

• Character类中的常用方法:

  方 法 原 型	说 明
  boolean isLetter(char ch)	判断字符ch是否为英文字母
  boolean isDigit(char ch)	判断字符ch是否为0~9之间的数字
  boolean isUpperCase(char ch)	判断字符ch是否为大写形式
  boolean isLowerCase(char ch)	判断字符ch是否为小写形式
  boolean isWhitespace(char ch)	判断字符ch是否为空格或换行符

• 注意：以上方法都是静态方法，可以直接通过类名调用，返回值均为boolean类型，如果是返回true，否则返回false。

• Character类的常用方法示例:

  public class CharacterTest {
      public static void main(String[] args) {
          char[] chs = {'+', 'b', 'B', ' ', '7'};
          for (char ch : chs) {
              if (Character.isLetter(ch)) {
                  System.out.println(ch + "是一个英文字母");
              }
              if (Character.isDigit(ch)) {
                  System.out.println(ch + "是一个0到9的数字");
              }
              if (Character.isLowerCase(ch)) {
                  System.out.println(ch + "是一个小写形式");
              }
              if (Character.isUpperCase(ch)) {
                  System.out.println(ch + "是一个大写形式");
              }
              if (Character.isWhitespace(ch)) {
                  System.out.println(ch + "是一个空格或者换行符");
              }
          }
      }
  }
  /**
   * b是一个英文字母
   * b是一个小写形式
   * B是一个英文字母
   * B是一个大写形式
   * 是一个空格或者换行符
   * 7是一个0到9的数字
   */

知识点4- Java自动装箱与拆箱的使用方法

• 1、装箱和拆箱

  • 装箱：基本数据类型转换为包装器类型，称为装箱（boxing）；例如，int型转换为Integer类型；

  • 拆箱：包装器类型转换为基本数据类型，称为拆箱（unboxing）；例如Integer类型转换为int类型；

  • JDK1.5以后，装箱拆箱可以自动进行；例如：

    public class Wrapper {
        public static void main(String[] args) {
            //包装类型的两种赋值方式
            Integer ai = new Integer(10);
            Integer bi = 10;
            //手动装箱和拆箱
            Integer aoi = new Integer(20);
            //手动拆箱
            int i1 = aoi.intValue();
            //手动装箱
            Integer aoi2 = new Integer(i1);
            //自动拆装箱
            Integer aoi3 = 128;
            int i3 = aoi3;
            Integer aoi4 = i3;
            Integer aoi5 = i3 + 80;
        }
    }

• 2、在自动装箱拆箱过程中，Java使用到了常量池；

• • 常量池就是方法区的一部分,是内存的逻辑分区

  • java考虑 -128~127 这些数据使用频率比较高，使用常量池可以节约内存

public class WrapperTest {
    public static void main(String[] args) {
        Integer i1 = 10;
        Integer i2 = 10;
        Integer io1 = new Integer(10);
        Integer io2 = new Integer(10);
        //i1和i2在常量池中（方法区的一部分） ，只有一个对象，节省内存
        System.out.println(i1 == i2);     //true
        //io1和io2实例对象在堆内中
        //对象实例存放到堆内中，是默认方式
        System.out.println(io1 == io2);   //false
        //i1在常量中，io1在堆内存中
        System.out.println(i1 == io1);    //false

        Integer i3 = 128;
        Integer i4 = 128;
        Integer io3 = new Integer(128);
        Integer io4 = new Integer(128);
        //存放的值 超过 -128~127 范围，数据就放到堆内存中
        System.out.println(i3 == i4);     //false
        //io1和io2实例对象在堆内中
        System.out.println(io3 == io4);   //false   
        //i1在常量中，io1在堆内存中
        System.out.println(i3 == io3);    //false    
    }
}

• • String与常量池

public class StringTest {
    public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "abc";
        String str3 = new String("abc");
        String str4 = new String("abc");
        //直接复制字符串，把abc存放到常量池（只存储一个）
        System.out.println(str1 == str2);   //true     
        //堆中
        System.out.println(str3 == str4);   //false     
        System.out.println(str1 == str3);   //false
        str1 = "bcd";   //在常量池中 再创建一个bcd字符串对象
        System.out.println("=====================================");
        //常量池中存放 "ab"和 "cd" 字符串对象
        String a1 = "ab";
        String b1 = "cd";
        // 拼接abcd对象放到堆内存中  +号拼接字符串，每次加一次就会重新创建String对象，如果频繁的拼接字符串效率低
        String c1 = a1 + b1;
        String c2 = "ab" + "cd";   //java编译器优化 String c2 = "abcd";
        String c3 = "abcd";
        System.out.println(c1 == c2);   //false
        System.out.println(c1 == c3);   //false
        System.out.println(c2 == c3);   //true
    }
}