StringBuilder和包装类、基本类型与字符串类型之间的相互转换

一、String和StringBuilder（字符串缓存区）的区别：

StringBuilder和String可以相互转换:
String->StringBuilder:可以使用StringBuilder的构造方法
StringBuilder(String str) 构造一个字符串生成器，并初始化为指定的字符串内容。
StringBuilder->String:可以使用StringBuilder中的toString方法
public String toString()：将当前StringBuilder对象转换为String对象。
(toString方法被重写了)
详细见代码:

public class StringbuilderDemo {
    public static void main(String[] args) {
        demo3();
    }

    private static void demo3() {
        /*
        StringBuilder和String可以相互转换:
        String->StringBuilder:可以使用StringBuilder的构造方法
            StringBuilder(String str) 构造一个字符串生成器，并初始化为指定的字符串内容。
        StringBuilder->String:可以使用StringBuilder中的toString方法
            public String toString()：将当前StringBuilder对象转换为String对象。
        */

        //1.String->StringBuilder
        String str="Hello ";
        StringBuilder bu = new StringBuilder(str);
        System.out.println(bu);
        //往StringBuilder中添加数据
        bu.append("World");
        System.out.println("bu:"+bu);

        //2.StringBuilder->String
        String s=bu.toString();
        System.out.println("s:"+s);
    }

    private static void demo2() {
        /*
    StringBuilder的常用方法:
        1.public StringBuilder append(...)：添加任意类型数据的字符串形式，并返回当前对象自身。
        */
        StringBuilder bu = new StringBuilder();
        //使用append方法往StringBuilder中添加数据
        //append方法返回的是this(就是返回本身，地址不变哦),调用方法的对象bu,this==bu
//        StringBuilder bud2 = bu.append("abcd");
//        System.out.println(bu); //abcd，因为就是相当于在本身改了
//        System.out.println(bud2); //abcd
//        System.out.println(bu==bud2); //比较的是地址 true(这里因为返回本身所以相等)

        //使用append方法无需接收返回值,所以不用上面的bud2来接收了
//        bu.append(1);
//        bu.append(true);
//        bu.append(9.0);
//        bu.append("中国");
//        System.out.println(bu);

        /*
            链式编程:方法返回值是一个对象,可以继续调用方法
         */
        bu.append("abc").append(1).append(true).append(8.8).append('中');
        System.out.println(bu);//abc1true8.8中
    }
    private static void demo1() {
        /*
    java.lang.StringBuilder类:字符串缓冲区,可以提高字符串的效率
    构造方法:
        StringBuilder() 构造一个不带任何字符的字符串生成器，其初始容量为 16 个字符。
        StringBuilder(String str) 构造一个字符串生成器，并初始化为指定的字符串内容。
        */
        //空参数构造方法
        StringBuilder builder1 = new StringBuilder();
        System.out.println("bud1:"+builder1);//打印空字符串
        //带字符串的构造方法
        StringBuilder builder2 = new StringBuilder("abc");
        System.out.println("but2:"+builder2);
    }
}

二、包装类


这里说的是Integer转为int, 直接输出包装类对象会输出其值，因为重写了toString方法，不然就输出地址值了
装箱:把基本类型的数据,包装到包装类中(基本类型的数据->包装类)
构造方法:
1.Integer(int value) 构造一个新分配的 Integer 对象，它表示指定的 int 值。
2. Integer(String s) 构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。
传递的字符串,必须是基本类型的字符串,否则会抛出异常 “100” 正确 “a” 抛异常(因为这个是装为Integer的)
静态方法:
3. static Integer valueOf(int i) 返回一个表示指定的 int 值的 Integer 实例。
4. static Integer valueOf(String s) 返回保存指定的 String 的值的 Integer 对象。
（上面1.2.3.4都可以转为Integer）

拆箱:在包装类中取出基本类型的数据(包装类->基本类型的数据)
成员方法:
int intValue() 以 int 类型返回该 Integer 的值。(若是其他类型的包装类转为基础类型的话，改Value前面的int为xxx（eg:double）就行)

public class Bao {
    public static void main(String[] args) {
        //装箱:把基本类型的数据,包装到包装类中(基本类型的数据->包装类)
        //构造方法
        Integer in1 = new Integer(1);//方法上有横线,说明方法过时了
        System.out.println(in1);//1 重写了toString方法，不然就输出地址值了

        Integer in2 = new Integer("2");//这里的字符串要写数字的，不然报NumberFormatException错
        System.out.println(in2);//2

        //静态方法
        Integer in3 = Integer.valueOf(3);
        System.out.println(in3);

        Integer in4 = Integer.valueOf("4");
        System.out.println(in4);
        //拆箱:在包装类中取出基本类型的数据(包装类->基本类型的数据)
        int i = in3.intValue();
        System.out.println(i);
    }
}

自动装箱与自动拆箱:基本类型的数据和包装类之间可以自动的相互转换
JDK1.5之后出现的新特性(就不用写上面那么麻烦的代码了，但上面才是它的原理)，见代码：

import java.util.ArrayList;

public class Zidong {
    public static void main(String[] args) {
        /*
            自动装箱:直接把int类型的整数赋值包装类
            Integer in = 1; 就相当于 Integer in = new Integer(1);
         */
        Integer in=1;
        //System.out.println(i1);
         /*
            自动拆箱:in是包装类,无法直接参与运算,可以自动转换为基本数据类型,在进行计算
            in+2;就相当于 in.intVale() + 2 = 3
            in = in.intVale() + 2 = 3 又是一个自动装箱
         */
         in=in+1;
        //System.out.println(in);
        ArrayList<Integer> list=new ArrayList<>();
        /*
            ArrayList集合无法直接存储整数,可以存储Integer包装类
        */
        list.add(1); //-->自动装箱 list.add(new Integer(1));

        Integer a = list.get(0); //-->自动拆箱  list.get(0).intValue();
        System.out.println(a);
    }
}

三、基本类型与字符串类型之间的相互转换

1.基本类型->字符串(String)
1.1.基本类型的值+"" 最简单的方法(工作中常用)
1.2.包装类的静态方法toString(参数),不是Object类的toString() 重载（参数列表不同，这里是重载不是重写哦）
static String toString(int i) 返回一个表示指定整数的 String 对象。
1.3.String类的静态方法valueOf(参数)
static String valueOf(int i) 返回 int 参数的字符串表示形式。
2.字符串(String)->基本类型
使用包装类的静态方法parseXXX(“字符串”);
Integer类: static int parseInt(String s)
Double类: static double parseDouble(String s)
除了Character类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型：

• public static byte parseByte(String s)：将字符串参数转换为对应的byte基本类型。
• public static short parseShort(String s)：将字符串参数转换为对应的short基本类型。
• public static int parseInt(String s)：将字符串参数转换为对应的int基本类型。
• public static long parseLong(String s)：将字符串参数转换为对应的long基本类型。
• public static float parseFloat(String s)：将字符串参数转换为对应的float基本类型。
• public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型。
• public static boolean parseBoolean(String s)：将字符串参数转换为对应的boolean基本类型。

字符串的拼接：

		String s22="200";
        System.out.println(s22+900);//200900

public class Bao {
    public static void main(String[] args) {
        //基本类型->字符串(String)
        int i1=100;
        String s1=i1+"";//要写+""，不然转不了
        System.out.println(s1+200);//100200字符串的拼接

        String s2 = Integer.toString(100);//100也可以这样转为string
        System.out.println(s2+300);//100300

        String s3 = String.valueOf(100);
        System.out.println(s3+400);//100400


        //字符串(String)->基本类型
        int i = Integer.parseInt(s1);
        System.out.println(i);//100

        double v = Double.parseDouble(s2);
        System.out.println(v);//100.0

//        int a = Integer.parseInt("a");//NumberFormatException
//        System.out.println(a);
    }
}