字符串工作方法

package tStringBufferStringBuilder;

/*
 * java.lang.StringBuffer;
 * java.lang.StringBuilder
 * 
 *         1.StringBuffer和StringBuilder是什么？
 *             是一个字符串缓冲区
 *         2.工作原理
 *             预先在内存中申请一块空间，以容纳字符序列，
 *             如果预留的空间不够用，则进行自动扩容，以
 *             容纳更多字符序列
 *         3.StringBuffer,StringBuilder和String最大的区别？
 * 
 *             String是不可变得字符序列，存储字符串常量池中
 * 
 *             StringBuffer底层是一个char数组，但是该char数组是可变的
 *             并且可以自动扩容
 * 
 *         4.StringBuffer和StringBuilder的默认初始化容量是16
 * 
 *         5.如何优化StringBuffer和StringBuilder呢？
 *             最好在创建StringBuffer之前，预测StringBuffer的存储字符数量，
 *             然后再创建StringBuffer的时候采用指定初始化容量的方式创建StringBuffer
 *             为了减少底层数组的拷贝。提高效率。
 * 
 *         6.StringBuffer和StringBui1der的区别？
 * 
 *             StringBuffer是线程安全的。（可以在多线程的环境下使用而不会出现问题.）
 *             StringBuilder是非线程安全的。（在多线程环境下使用可能出现问题.）
 */
public class Test01 {

    public static void main(String[] args) {

        //创建字符串缓冲区对象
        StringBuffer sb = new StringBuffer(); //默认值16
        
        //可以向StringBuffer中追加字符串
        String[] ins = {"体育","音乐","睡觉"};
        
        //推荐字符串频繁拼接使用StringBuffer或者StringBuilder
        for(int i=0; i){
            
            if(i==ins.length-1){
                
                sb.append(ins[i]);
                
            }else{
                
                sb.append(ins[i]);
                sb.append("，");
            }
        }
        
        System.out.println(sb);
    }

}

package tStringBufferStringBuilder;

/*
 * java中八种基本数据类型对应的包装类型：
 * 基本数据类型         包装类型
 *   byte        java.lang.Byte;
 *   short       java.lang.Short;
 *   int         java.lang.Integer;
 *   long        java.lang.Long;
 *   
 *   float       java.lang.Float;
 *   double      java.lang.Double;
 *   
 *   boolean     java.lang.Boolean;
 *   
 *   char        java.lang.Character
 *   
 *     思考：java中提供的八种基本数据类型不够用吗？
 *         为什么java中还要提供对应的包装类呢？
 *     其实为了方便
 */
public class IntegerTest01 {

    //需求：规定m1方法可以接收java中任何一种数据类型
    //m1方法如果想接收byte类型的数据，可以将byte类型先包装成java.lang.Byte;再传递参数
    public static void m1(Object o){
        System.out.println(o);
    }
    public static void main(String[] args) {

        //基本数据类型
        byte b = 10;
        
        //经过包装，变成引用类型
        Byte b1 = new Byte(b);
        
        m1(b); //不行
        m1(b1); //Byte已经将Object中的toString方法重写
    }

}

package tStringBufferStringBuilder;

/*
 * 以java.lang.Integer;类型为例，讲解八种类型
 */
public class IntegerTest02 {

    public static void main(String[] args) {

        //获取int类型的最大值和最小值
        System.out.println("int最小值：" + Integer.MIN_VALUE);
        System.out.println("int最大值：" + Integer.MAX_VALUE);
        
        //int推byte
        System.out.println("byte最小值：" + Byte.MIN_VALUE);
        System.out.println("byte最大值：" + Byte.MAX_VALUE);
        
        //创建Integer类型的对象
        Integer i1 = new Integer(10); //int-->Integer
        Integer i2 = new Integer("123"); //String-->Integer
        
        System.out.println(i1); //10
        System.out.println(i2); //123
        
        //以下程序编译可以通过。但是运行的时候会报异常。数字格式化异常
        //虽然可以将字符串转换成Integer类型，但是该字符串也必须是"数字字符串"
        //Integer i3 = new Integer("abcd"); //NumberFormatException
    }

}

package tStringBufferStringBuilder;

/*
 * 关于Integer中常用的方法
 */
public class IntegerTest03 {

    public static void main(String[] args) {

        //int-->Integer
        //基本数据类型-->引用类型
        Integer i1 = new Integer(10);
        
        //Integer-->int
        //引用类型-->基本数据类型
        int i2 = i1.intValue();
        
        System.out.println(i2 + 1); //11
        
        //重要：static int parseInt(String s);
        //String-->int
        int age = Integer.parseInt("25");
        System.out.println(age + 1); //26
        
        //"abc"这个字符串必须是“数字字符串才行”
        //int price = Integer.parseInt("abc"); //NumberFormatException
        
        
        //重要：static double parseDouble(String s);
        double price = Double.parseDouble("3.0");
        System.out.println(price + 1);
        
        
        //将int类型的十进制转换成2进制
        String s1 = Integer.toBinaryString(10);
        System.out.println(s1); //1010
        
        //将int类型的十进制转换成16进制
        String s2 = Integer.toHexString(10);
        System.out.println(s2); //a
        
        //将int类型的十进制转换成8进制
        String s3 = Integer.toOctalString(10);
        System.out.println(s3); //12
        
        //int-->Integer
        Integer i3 = Integer.valueOf(10);
        
        //String-->Integer
        Integer i4 = Integer.valueOf("10");
        
        System.out.println(i3);
        System.out.println(i4);
    }

}

package tStringBufferStringBuilder;

/*
 * 三种类型相互转换：Integer int String
 */
public class IntegerTest04 {

    public static void main(String[] args) {

        //1. int-->Integer
        Integer i1 = Integer.valueOf(10);
        
        //2. Integer-->int
        int i2 = i1.intValue();
        
        //3. String-->Integer
        Integer i3 = Integer.valueOf("10");
        
        //4. Integer-->String
        String s1 = i3.toString();
        
        //5. String-->int
        int i4 = Integer.parseInt("123");
        
        //6. int-->String
        String s2 = 10 + "";
    }

}

package tStringBufferStringBuilder;

/*
 * JDK5.0新特性：自动装箱、自动拆箱
 */
public class IntegerTest05 {

    public static void main(String[] args) {

        //JDK5.0之前的
        
        //int-->Integer(装箱)
        Integer i1 = new Integer(10);
        
        //Integer-->(拆箱)
        int i2 = i1.intValue();
        
        
        //JDK5.0以后
        Integer i3 = 10; //自动装箱
        int i4 = i3; //自动拆箱
        
        m1(321); //自动装箱
        System.out.println(m2(10,5)); //自动装箱
    }

    public static void m1(Object o){
        System.out.println(o);
    }
    
    public static int m2(Integer i1, Integer i2){
        return i1 - i2; //自动拆箱
    }
}

package tStringBufferStringBuilder;

/*
 * 深入自动装箱和自动拆箱：
 *         1.自动装箱和自动拆箱是程序编译阶段的一个概念，
 *         和程序运行无关
 * 
 *         2.自动装箱和自动拆箱主要目的是方便程序员编码
 */
public class IntegerTest06 {

    public static void main(String[] args) {

        Integer i1 = new Integer(10);
        Integer i2 = new Integer(10);
        
        //这里不会有自动拆箱，还是比的是内存地址
        System.out.println(i1 == i2); //false
        
        //比较两个Integer类型的数据是否相等，不能用"=="
        //Integer已经重写了Object中的equals方法，比较的是数据
        System.out.println(i1.equals(i2)); //true
        
        
        //重点
        Integer i3 = 128;
        Integer i4 = 128;
        
        //上面的等同于
        //Integer i3 = new Integer(128);
        //Integer i4 = new Integer(128);
        
        System.out.println(i3 == i4); //false
        
        //注意以下程序
        //如果数据类型是在(-128~127)之间，java中引入了一个"整型常量池"，在方法区中
        //该整型常量池只存储-128~127之间的数据。
        Integer i5 = 127; //这个程序不会在堆中创建对象，会直接从整形常量池中拿
        Integer i6 = 127;
        System.out.println(i5 == i6); //true
        
        Integer i7 = -128;
        Integer i8 = -128;
        System.out.println(i7 == i8); //true
        
        Integer i9 = -129;
        Integer i10 = -129;
        System.out.println(i9 == i10); //false
    }

}