JAVA——Character&String&StringBuffer类

字符串在编程中很常用，Java中提供了很多方法，可以查看API文件

Character类

Java语言为内置数据类型char提供了包装类Character类。

char ch = 'a';
// Unicode 字符表示形式
char uniChar = '\u039A'; 
// 字符数组
char[] charArray ={ 'a', 'b', 'c', 'd', 'e' };

//装箱：将一个char类型的参数传递给需要一个Character类型参数的方法 
//原始字符 'a' 装箱到 Character 对象 ch 中
Character ch = 'a';
 
// 原始字符 'x' 用 test 方法装箱
// 返回拆箱的值到 'c'
char c = test('x');

String类（字符串的本质是字符数组）

1. 创建字符串

        //1、直接赋值
        String s="Hello";
        //2、使用构造方法赋值 String(String original)
        String s2=new String("hello");
        //3、String(char[] value)
        char [] chs={'h','e','l','l','o'};
        String s3=new String(chs);
        //4、String(char[] value, int offset, int count)
        //offset 从第一个下标开始取
        //count 取多少个字符
        String s4=new String(chs,1,1);

直接赋值与new区别
直接赋值，是将“字符串”直接放入常量池中。所以只要字符串相同，指向就一样
new是在堆中开辟空间，new一下就对应一个地址，再指向常量池，所以就算赋的字符串相同，地址也不同。

2. 连接字符串

//1、string1.concat(string2);
//2、"Hello," + " runoob" + "!"

3. .length()方法返回字符串长度
4. 遍历字符串

   String s="welcome to java world HHFGH";
   char [] chs=s.toCharArray();
   //第一种遍历字符串的方式
   for(int i=0;i<chs.length;i++){
       System.out.print(chs[i]);
   }
   //直接遍历字符串
   for(int i=0;i<s.length();i++){
        System.out.print(s.charAt(i));
   }

5. ==与equal区别
   ==对于string来说是比较两者之间的地址
   equal才是真正比较两个字符串是否相等

6. 一些常用方法

        String s="hello world java haha java";
        //获取字符串中的每个字符
        char c=s.charAt(6);
        //找大字符串中小字符串的第一次出现索引,如果没有，返回-1
        int index=s.indexOf("java");
        //indexOf(String str, int fromIndex)
        index=s.indexOf("java",index+1);
        //字符串截取
        String ss=s.substring(3);
        //截取指定的区间,[3,10)
        ss=s.substring(3,10);
        //比较时忽略大小写
        String s1="HELLO";
        System.out.println(s.equalsIgnoreCase(s1));
        //是否以...开头,一般用在判断姓名是否姓张....
        System.out.println(s.startsWith("l"));
        //是否以...结尾,一般用在判断文件是那种类型,.doc,.txt,.java
        System.out.println(s.endsWith("llo"));
        //判断字符串是否为空
        System.out.println(s.isEmpty());
        //trim去除字符串首尾空格
        System.out.println(s.trim().length());
        //字符串分割
        String names="jack,rose,tom,lucy,jhone";
        String [] strs=names.split(",");
        for(int i=0;i<strs.length;i++){
            System.out.println(strs[i]);
        }
        //字符串替换
        String ss="hello java i like java i enjoy java";
        System.out.println(ss.replace("java","c++"));
        System.out.println(ss.replaceAll("java","php"));
    }

【注意】空字符串与空格不一样

StringBuffer & StringBuilder

String & StringBuffer & StringBuilder 区别

-String在进行连接时，在字符串常量池中将两个地址中的字符串连接后，赋给新地址，再回指给变量。原先字符串空间不会消失。

• 在使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象。即在连接字符串时，不开辟空间，直接在原先域上添加。
• StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。StringBuilder 相较于 StringBuffer 有速度优势，推荐使用

1. 字符串静态，不常修改，优先使用String。如常量的声明，少量的字符串操作(拼接，删除等)。
2. 在单线程情况下，如有大量的字符串操作情况，应该使用StringBuilder来操作字符串。不能使用String"+"来拼接而是使用，避免产生大量无用的中间对象，耗费空间且执行效率低下（新建对象、回收对象花费大量时间）。如JSON的封装等。
3. 在多线程情况下，如有大量的字符串操作情况，应该使用StringBuffer。如HTTP参数解析和封装等

public static void stringBuilderConcat(){
        StringBuilder sb=new StringBuilder();
        long start=System.currentTimeMillis();
        //10000次所消耗的时间2毫秒
        //6毫秒
        for(int i=1;i<=100000;i++){
            sb.append("hello");
        }
        long end=System.currentTimeMillis();
        //消耗时间
        long time=end-start;
        System.out.println("StringBuilder字符串拼接所消耗的时间为:"+time+"毫秒");
    }

    public static void stringConcat(){
        String str="";
        long start=System.currentTimeMillis();
        //10000次所消耗的时间371毫秒
        //23840毫秒
        for(int i=1;i<=100000;i++){
            str+="hello";
        }
        long end=System.currentTimeMillis();
        //消耗时间
        long time=end-start;
        System.out.println("String字符串拼接所消耗的时间为:"+time+"毫秒");
    }