【Java入门】常用类-Intager、BigDecimal、String

---

学习目标

• 了解基本类型和包装类的区别

• 掌握什么是装箱和拆箱，什么是自动装箱和拆箱

• 掌握BigDecimal的加减乘除和保留精度操作

• 掌握String常用方法

• 掌握StringBuilder的操作

• 掌握String、StringBuilder、StringBuffer三者的区别

一、Integer

1.1、包装类

包装类就是把基本数据类型封装到一个类中，提供便利的方法，让开发者更方便的操作基本类型。

包装类的出现不是为了取代基本数据类型。

包装类位于 java.lang 包中

1.2、常用方法

Integer内部封装了一个int类型的基本数据类型value，并提供了方法对int值进行操作，还提供了int值和String之间的转换。

public static void main(String[] args) {
    // 传入一个int值构建一个Integer对象，此构造方法不推荐使用
    Integer i1 = new Integer(10);
    // 推荐使用
    Integer i2 = Integer.valueOf(10);

    // Integer 可以把String -> int
    Integer i3 = Integer.valueOf("100");
    int num = i3.intValue();
    System.out.println(num);

    // 实际开发过程中
    int num2 = Integer.parseInt("200");
    System.out.println(num2);

	// int -> String
    Integer i1 = Integer.valueOf(10);
    String str2 = i1.toString();
    System.out.println(str2);

    // 实际开发过过程中 int -> String
    String str3 = Integer.toString(10);

    // 更推荐语法糖
    int num = 10;
    String str = num + "";

    /**
    * 总结
    * Integer 作为一个中间桥梁 int <- Integer -> String
    */
}

1.3、装箱和拆箱

• 装箱：把基本类型数据转成对应的包装类对象。
• 拆箱：把包装类对象转成对应的基本数据类型。

装箱操作：

// 这样会创建对象，从而占用内从
方式一：	Integer num1 = new Integer(17);
//建议，不会创建对象，直接通过类调用方法，节约内存
方式二：	Integer num2 = Integer.valueOf(17);	

拆箱操作：

Integer	num3  =  Integer.valueOf(17);	//装箱操作
int val = num3.intValue();	//拆箱操作

从Java5开始提供了的自动装箱（AutoBoxing）和自动拆箱（AutoUnBoxing）功能：

• 自动装箱：可把一个基本类型变量直接赋给对应的包装类变量。
• 自动拆箱：可以把包装类对象直接赋给对应的基本数据类型变量。

// 装箱操作,17是int类型的常量，赋值给Integer类型的变量后，17的类型也自动装箱变为Integer类型
Integer	num4  =  17;
// 拆箱操作	
int val2 = num4;		

自动装箱和拆箱，在底层依然是手动装箱和拆箱。

二、BigDecimal

float和double都不能表示精确的小数，使用BigDecimal类可以解决该问题，BigDecimal用于处理金钱或任意精度要求高的数据。

BigDecimal不能直接把赋值和运算操作，只能通过构造器传递数据，而且必须使用字符串类型的构造器，操作BigDecimal主要是加减乘除四个操作。

2.1、基本运算

2.2、精度控制和除不尽的问题

public static void main(String[] args) {
    // 
    BigDecimal num1 = new BigDecimal("10.0");
    BigDecimal num2 = new BigDecimal("3.0");

    // 1. 保留位数和精度控制
    // RoundingMode 舍入模式
    // RoundingMode.HALF_UP     四舍五入
    // RoundingMode.HALF_Down   四舍六入
    BigDecimal r1 = num1.multiply(num2).setScale(2,RoundingMode.HALF_UP);
    System.out.println("r1 = " + r1);

    // 2. 除不尽问题
    // java.lang.ArithmeticException
    // Non-terminating decimal expansion; no exact representable decimal result.
    // 报错原因:除不尽(3.333333333...333...)
    BigDecimal r2 = num1.divide(num2,3,RoundingMode.HALF_UP);
    System.out.println("r2 = " + r2);
}

上述代码分别表示乘法和除法按照四舍五入方式保留两位小数。

三、String

字符串（字符序列），表示把多个字符按照一定得顺序连成的字符序列。

字符串的分类（根据同一个对象，内容能不能改变而区分）：

• 不可变的字符串——String：当String对象创建完毕之后，该对象的内容是不能改变的，一旦内容改变就变成了一个新的对象。

• 可变的字符串——StringBuilder/StringBuffer：当StringBuilder对象创建完毕之后，对象的内容可以发生改变，当内容发生改变的时候，对象保持不变。

3.1、String本质概述

String 类型表示字符串，Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。

String 在内存中是以字符数组的形式存在

// jdk1.8 and before
public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];
 
    ...
}

我们可以认为，String对字符数组的封装，并提供以只读的形式操作其封装的字符数组的方法。

String对象的创建的两种方式：

1、直接赋一个字面量:       String   str1  =  "ABCD";//直接存储在方法区的常量池中,节约内存
2、通过构造器创建:         String   str2  =  new String("ABCD");

字符串内存图

• 通过字面量创建的字符串分配在常量池中，所以字面量字符串是常量；它们的值在创建之后不能更改，因为 String 对象是不可变的，所以可以共享。

  例如：

  // str1 和str2 共享常量池中的 a
  String str1 = "a";
  String str2 = "a";
  

• 通过new 操作创建的字符串分配在堆区。创建的String对象每次的重新赋值就相当于在堆内存中重新创建了一个对象

  例如：

  String str1 = new String("a");
  str1 = "b"
  

• 字符串的拼接，其实就是一次次的创建新的对象
  例如：

  String str1 = "a";
  String str2 = "b";
  String str3 = "c";
  str1 = str1 + str2;// "a" + "b" = "ab"
  str1 = str1 = str3;// "ab" + "c" = "abc"
  

String对象的 “空” 值

表示引用为空(null)
String  str1 = null;   //没有初始化，没有分配内存空间.  

内容为空字符串
String  str2  = "";     // 已经初始化，分配内存空间，不过没有内容

3.2、字符串常用的方法

四、StringBuilder&StringBuffer

4.1、可变字符串的概述

String类型提供了对字符串的只读操作，也即调用字符串的部分方法都会返回一个新的字符串。

如果需要对包装的字符数组进行增、删、改、查时，就需要可变字符串。

java中提供了两类可变字符串的类型StringBuffer、StringBuilder。

4.2、StringBuffer

StringBuffer封装了一个字符数组，并提供了对该字符数组进行增、删、改、查的方法。所以，我们完全可以把StringBuffer看成一个"字符的容器"!

可变字符串内存图

StringBuffer构造方法

• StringBuffer() : 初始化默认容量是16的可变字符串
• StringBuffer(int capacity) 初始化容量是capacity的可变字符串

StringBuffer常用方法

public static void main(String[] args) {
    // 创建一个可变字符串容器，默认容量是16个字符
    StringBuffer sb = new StringBuffer();

    // 创建一个可变字符串容器，容量是100个字符
    // StringBuffer sb2 = new StringBuffer(100);

    // 【1】追加
    sb.append('A');
    sb.append('B');
    // 链式操作
    sb.append("C").append("D");
    System.out.println(sb.toString());

    // 【2】添加 insert
    sb.insert(0, 'E');
    sb.insert(0, "hello").insert(0, "world");
    System.out.println(sb);

    // 返回容器的容量
    System.out.println(sb.capacity());
    // 返回容器中字符的个数
    System.out.println(sb.length());

    // 当空间不足时，能否继续添加？=> 自动拓容
    sb.append(123);
    System.out.println(sb.length());
    System.out.println(sb.capacity());

    // 【2】删除
    // 删除指定位置index的字符
    //sb.deleteCharAt(10);
    // delete(start,end) 含头不含尾
    sb.delete(0, 10);
    System.out.println(sb);

    // 【3】修改
    sb.replace(0, 5, "eabcd");
    System.out.println(sb);

    sb.setCharAt(0, 'f');
    System.out.println(sb);
}

4.3、StringBuilder

StringBuffer在源代码级别上已经做到了线程安全，所以StringBuffer非常适合多线程环境。
如果在单线程条件下使用可变字符串序列时，一定优先考虑StringBuilder。

面试题: StringBuffer和StringBuilder的区别(了解+)

• 相同点：
  都是字符串可变缓冲区，api提供了相同的增删改查操作。
• 不同点:
  StringBuffer 线程安全，效率低；StringBuilder线程不安全，效率高。
  StringBuffer jdk1.0; StringBuilder jdk1.5