字符串

1、String字符串一般不用new来初始化。字符串最大的特点是一旦被初始化就不可以再修改，String为final类。字符串常见操作有获取和判断。字符串定义了后放在字符串池中，是一个常量，一旦新的字符串定义就检测字符串池有没有这个字符串，如果有就将之赋给新的字符串。用new创建字符串时是定义两个字符串，白开辟了一个空字符串空间。

package pack;

public class Test
{
    public static void main(String[] args) 
    {
        String str=new String();    //这种方式不常见
        str="hahahah";
        
        String s="hehehehe";        //一般是这种定义方式，s为指向"hehehehe"对象的引用
        s="lalalala";                //此时s为指向"lalalala"对象的引用，对象本身没有变,也不可以变
        
        String str1=new String("nnnnnn");
        String str2="nnnnnn";
        String str3="nnnnnn";
        //str1和str2的区别是：str1在内存中有一个对象，str2有两个对象。
        System.out.println(str1==str2);    //判断两个对象是否相同，此时是两个对象，当然不同
        System.out.println(str2==str3);    //内存中的常量池使str3不再重复开辟空间
        System.out.println(str1.equals(str2));    //判断两个字符串是否相同
        getString();
        getIs();
    }
    public static void str(Object obj)
    {
        System.out.println(obj);
    }
    public static void getString()
    {
        String s="abcdefghi";
        str(s.length());
        str(s.charAt(3));
        str(s.indexOf('n',3)); //找不到就返回-1
        str(s.lastIndexOf("f"));
    }
    public static void getIs()
    {
        String str1="ArrayDemo.java";
        //判断文件是否以Array开头
        str(str1.startsWith("Array"));
        //判断文件是否是.java文件
        str(str1.endsWith(".java"));
        //判断字符串中是否有某个子串Demo
        str(str1.contains("Demo"));
    }
}

2、String类的操作

package pack;
//字符串的转换动作、替换动作、切割动作和获得字符串中的一部分子串，转换大小写，将字符串两端的多个空格去除，对两个字符串进行自然顺序的比较
public class Test
{
    public static void main(String[] args) 
    {
        /*将字符数组转换为字符串
         * 构造函数：String(char[]);
         * 构造函数：String(char[],offset,count);一部分转化为字符串
         * 静态方法：static String copyValueOf(char[]);
         *         static String copyValueOf(char[] data,int offset,int count);
         *         static String valueOf(char[]);
         */
        char[]    a={'a','b','c','d','e'};
        String a1=new String(a);
        String a2=new String(a,1,3);
        sop("a1="+a1);
        sop("a2="+a2);
        /*将字节数组转换为字符串
         * 构造函数：String(byte[]);
         * 构造函数：String(byte[],offset,count);一部分转化为字符串
         */
        
        /*将字符串转成字符数组
         * char[] toCharArray();
         */
        
        /*将字符串转成字节数组
         * byte[] getBytes();
         */
    
        //字符串和字节数组在转换的过程中是可以制定编码表的
        
        
        //字符串的替换动作
        /*String replace(oldchar,newchar);
         * 如果要替换的字符串不存在就返回原字符串
         */
        String a3="hello java";
        String a33=a3.replace('h', 'n'); //字符串不可以被修改，这是又新定义了一个字符串a33
        String a4="hello java1";
        String a5="hello java2";
        a3.replace('a', 'b');
        a4.replace('x', 'b');
        String a6=a5.replace("hello", "nohello");//连续字符串替换需要新定义字符串
        sop("a3="+a3);
        sop("a33="+a33);
        sop("a4="+a4);
        sop("a6="+a6);
        
        //字符串切割动作
        /*String[] split(regex);
         * 
         */
        String s="zhangsan,lisi,wangwu";
        String[] arr=s.split(",");
        for(int i=0;i<arr.length;i++)
        {
            sop(arr[i]);
        }
        
        //获得子串
        String ss="woshine";
        sop(ss.substring(2));//从指定位置开始到结尾，如果index不存在，会出现越界异常
        sop(ss.substring(2,4));//包含头，不包含尾
        
        /*转换：String toUpperCase();
         *         String toLowerCase();
         * 字符串去除两端的空格：String trim();
         * 字符串比较大型： String compareTo();
         */
        String b="  hello  ";
        String c="  adf";
        sop(b.toUpperCase());
        sop(b.toLowerCase());
        sop(b.trim());
        sop(b.compareTo(c)); //以ASCII值比较
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

3、字符串的组成原理就是通过StringBuffer类来实现的。StringBuffer是一个容器（在容器中可以添加任何东西，但容器只有一个），一个字符串缓冲区，具有增删改查的特性，不能被继承,长度是可变的，可以操作多个数据类型，最终会通过toString方法变成字符串。

package pack;
//StringBuffer类
public class Test
{
    public static void main(String[] args) 
    {
        //存储：append();方法将字符串放入缓冲区末尾
        //存储：insert();方法可以将字符插入指定的位置处
        //删除：StringBuffer delete(start,end):删除缓冲区中的数据，包含start，不包含end
        //删除：s.deleteCharAt(index);
        //清空缓冲区：s=new StringBuffer();重新在定义
        //情况缓冲区：s.delete(0,arr.length());
        //获取：char charAt(index);int inexOf(String str);int lastIndexOf(String str);int length();
        //        String subString(int start,int end);
        //修改：StringBuffer replace(start,end,str);void setCharAt(index,'char');
        //反转：StringBuffer reverse();
        //getChars();将字符数组中指定位置的字符存到一个字符数组中
        StringBuffer s=new StringBuffer();
        s.append("abcd").append("eeee");
        s.insert(2, "bbbb");
        sop(s);
        sop(s.delete(0, 1));
        sop(s.deleteCharAt(0));
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

4、StringBuilder是StringBuffer的替代方案。前者是1.5版本后出现的，是线程不同步的，后者是线程同步的。多个线程，建议使用StringBuffer。StringBuilder的效率高，建议使用它开发。一般升级的三个因素是：安全性、代码简洁性、提高效率。

5、基本数据类型和引用数据类型：byte,int,short,long,boolean,float,double,char和Byte,Integer,Short,Long,Boolean,Float,Double,Character。引用类型的最多用处是基本数据类型和字符串之间的转换。

package pack;
//基本数据类型的引用类型
public class Test
{
    public static void main(String[] args) 
    {        
        sop(Integer.MAX_VALUE);
        //基本数据类型转字符串的两种方法
        //基本数据类型+""或者基本数据类型.toString(基本数据类型值);
        
        //字符串转换成基本数据类型
        //基本数据类型  变量=基本数据类型.parse基本数据类型(String);
        //parseInt
        
        //十进制转化为其它进制
        //toBinaryString();toHexString();toOctalString();
        //其它进制转化为十进制
        //parseInt(进制数，进制);
        
        int num=Integer.parseInt("233");
        sop(num+4);
        boolean b=Boolean.parseBoolean("true");
        sop(b);
        
        //JDK1.5版本以后出现的新特性
        Integer x1=null;//新特性中x不可以为空，所以需要判断
        Integer x=2;  //x是引用数据类型，右边是对象。这叫自动装箱，右边等价于new Integer(4);
        x=x+2;  //右边的x+2中的x进行了自动的拆箱动作，从对象变成了int类型，和2进行加法运算，然后装箱赋给x
        
        Integer m=23;
        Integer n=23;
        sop(m==n);        //结果为false
        Integer p=128;
        Integer q=128;
        sop(p==q);        //结果为true，因为在新特性中p和q指向了同一个Integer对象，但数值在byte类型范围内时就不再开辟新空间
        
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}