黑马程序员_笔记十四_String和StringBuffer类

----------android培训、java培训期待与您交流！----------
String类声明时单词的首字母是大写，所以String类本身是一个类，但是此类在使用时有比较多的要求，而且在java中也算是一个比较特殊的类
 
实例化String对象
1 直接为String对象赋值
public class Demo{
    public static void main(String
args[]){
        Stringname = "hello" ;         //实例化String对象
        System. out.println("姓名：" +
name) ;
    }
};
结果：姓名：hello
 
2 通过构造方法 public String(String str)赋值
 
public class Demo{
     public static void main(String
args[]){
        Stringname = newString("hello");          //实例化String对象
        System. out .println("姓名：" +
name) ;
    }
};
 
结果：姓名：hello
 
String类内容的比较
使用==比较字符串的内容
public class Demo{
    public static void main(String
args[]){
        Stringstr1 = "hello" ;                  //直接赋值
        Stringstr2 = new String("hello" )
;     // 通过new赋值
        Stringstr3 = str2;                     //传递引用
        System. out.println("str1 == str2 --> " +
(str1==str2)) ; // false
        System. out.println("str1 == str3 --> " +
(str1==str3)) ; // false
        System. out.println("str2 == str3 --> " +
(str2==str3)) ; // true
    }
};
结果：
str1 == str2 --> false
str1 == str3 --> false
str2 == str3 --> true
虽然以上程序中String内容都一样，但是比较的结果却是有的相等，有的不相等。
从图中可以看出，每个String对象的内容实际上都是保存在堆内存之中的，而且堆中的内容是相等的。但是对str1和str2来说，其内容分别保存在了不同的空间，所以即使内容相同，但是地址的值也是不同的，==是用来进行数值比较的，所以str1和str2比较不相同。str2和str3指向了同一个空间，是同一个地址，所以地址值是相同的。同理str1和str3。所以==是用来比较地址值得
 
使用equals方法对String进行内容的比较
public class Demo{
    public static void main(String
args[]){
        Stringstr1 = "hello" ;                  //直接赋值
        Stringstr2 = new String("hello" )
;     // 通过new赋值
        Stringstr3 = str2;                     //传递引用
        System. out.println("str1 equals str2 --> " +
(str1.equals(str2))) ;   // true
        System. out.println("str1 equals str3 --> " +
(str1.equals(str3))) ;   // true
        System. out.println("str2 equals str3 --> " +
(str2.equals(str3))) ;   // true
    }
};
结果：
str1 equals str2 --> true
str1 equals str3 --> true
str2 equals str3 --> true
 
String类2种实例化方式的区别
String有2种实例化方式，一种是通过直接赋值，一种是使用new调用构造方法来完成，那么有什么区别？
对此，我们首先要明白一个概念，一个字符串就是一个String类的匿名对象，匿名对象就是已经开辟了堆内存空间的并且可以使直接使用的对象。。
 
验证一个字符串就是String类匿名对象
 
public class Demo{
    public static void main(String
args[]){
        System. out.println( "\"hello\"
equals\"hello\" -->"
                +( "hello").equals("hello" ))
;
    }
};
 
结果："hello" equals"hello" -->true
从上可以发现，一个字符串可以调用String类中的方法，也就证明了一个字符串就是一个String类的匿名对象
所以对于String str1 =”hello“来说，实际上就是把一个在堆内存中开辟好的堆内存空间的使用权给了str1对象，实际上是用这种方式还有一个好处，如果一个字符串已经被一个名称所引用，则以后再有相同的字符串声明时，就不会再重新开辟空间
 
采用直接赋值声明多个String类对象，观察地址
public class Demo{
    public static void main(String
args[]){
        Stringstr1 = "hello" ;                  //直接赋值
        Stringstr2 = "hello" ;                  //直接赋值
        Stringstr3 = "hello" ;                  //直接赋值
        System. out.println("str1 == str2 --> " +
(str1==str2)) ; // true
        System. out.println("str1 == str3 --> " +
(str1==str3)) ; // true
        System. out.println("str2 == str3 --> " +
(str2==str3)) ; // true
    }
};
结果：str1 == str2 --> true
str1 == str3 --> true
str2 == str3 --> true
String使用直接赋值的方式后，只要是以后声明的字符串内容相同，则不会再开辟新的内存空间
 
字符串的内容不可改变
在使用String类进行操作时，还有一个特性特别重要，那就是字符串的内容，一旦申明的则不可改变。
public class Demo{
    public static void main(String
args[]){
        Stringstr = "hello" ;      //声明字符串
        str= str + " world!!!" ;   //修改字符串
        System. out.println("str = " +
str) ;
    }
};
 
结果：str = hello world!!!
一个String对象内容的改变实际上是通过内存地址的断开-连接变化完成的，而本身字符串中的内容并没有任何的变化
 
 
String类的常用方法代码实例
1 字符串与数组的转换
使用toCharArray()方法将字符串变成字符数组
public class Demo{
    public static void main(String
args[]){
        Stringstr1 = "hello" ;         //定义字符串
         char c[] = str1.toCharArray() ; //将一个字符串变为字符数组
         for(int i=0;i<c.length;i++){     //循环输出
            System. out.print(c[i] + "、" )
;
        }
        System. out.println("" );        //换行
        Stringstr2 = new String(c) ;   //将全部的字符数组变为String
        Stringstr3 = new String(c,0,3) ;   //将部分字符数组变为String
        System. out.println(str2);      //输出字符串
        System. out.println(str3);      //输出字符串
    }
};
结果：
h、e、l、l、o、
hello
hel
 
2 从字符串中取出指定位置的字符
使用charAt（）方法
public class Demo{
    public static void main(String
args[]){
        Stringstr1 = "hello" ;         //定义String对象
        System. out.println(str1.charAt(3));    //取出字符串中第四个字符
    }
};
结果：l
 
3 字符串与byte数组的转换
字符串可以通过getBytes（）方法将String类变为一个byte数组
public class Demo{
    public static void main(String
args[]){
        Stringstr1 = "hello" ;         //定义字符串
         byte b[] = str1.getBytes();    //将字符串变为byte数组
        System. out.println(new String(b))
; // 将全部的byte数组变为字符串
        System. out.println(new String(b,1,3))
;    // 将部分的byte数组变为字符串
    }
};
 
结果：hello
ell
 
4 取得一个字符串的长度
PS:在数组中，使用length取得数组的长度，但是操作的最后没有（），而字符串使用length是一个方法，后面有（）
public class Demo{
    public static void main(String
args[]){
        Stringstr1 = "hello" ;     //定义字符串变量
        System. out.println("\"" +str1+"\"的长度为：" +str1.length())
;
    }
};
结果："hello"的长度为：5
 
5 查找一个指定的字符串是否存在
在String中使用indexOf（）方法，可以返回指定的字符串位置，如果不存在则返回-1
 
public class Demo{
    public static void main(String
args[]){
        Stringstr1 = "abcdefgcgh" ;                 //声明字符串
        System. out.println(str1.indexOf("c" ));        //查到返回位置
        System. out.println(str1.indexOf("c" ,3))
;   // 查到返回位置，从第4个位置开始查找
        System. out.println(str1.indexOf("x" ));        //没有查到返回-1
    }
};
结果：2
7
-1
 
 
6 去掉左右空格
使用trim（）方法去掉字符串空格
public class Demo{
    public static void main(String
args[]){
        Stringstr1 = "   hello    " ;     //定义字符串
        System. out.println(str1.trim()) ;   //去掉左右空格后输出
    }
};
 
7 字符串截取
在String中提供了2个subString（）方法，一个是从指定位置截取到字符串结尾，另外一个是截取指定范围的内容
 
public class Demo{
    public static void main(String
args[]){
        Stringstr1 = "hello world" ;       //定义字符串
        System. out.println(str1.substring(6)) ; //从第7个位置开始截取
        System. out.println(str1.substring(0,5)) ; //截取0~5个位置的内容
    }
    }
结果：world
hello
 
8 按照指定的字符串拆分字符串
在String中通过split（）方法进行字符串的拆分操作，拆分的数据将一字符串数组的形式返回
 
public class Demo{
    public static void main(String
args[]){
        Stringstr1 = "hello world" ;       //定义字符串
        Strings[] = str1.split( " ") ;      //按空格进行字符串的拆分
         for(int i=0;i<s.length;i++){         //循环输出
            System. out.println(s[i]) ;
        }
    }
};
结果：
hello
world
 
9字符串的大小写转换
使用toUpperCase()和toLowerCase（）方法进行大小写转换
 
public class Demo{
    public static void main(String
args[]){
        System. out.println("将\"hello
world\"转成大写：" + "hello world" .toUpperCase())
;
        System. out.println("将\"HELLO
WORLD\"转成小写：" + "HELLO WORLD" .toLowerCase())
;
    }
};
结果：将"hello world"转成大写：HELLO WORLD
将"HELLO WORLD"转成小写：hello world
 
10 判断是否以指定的字符串开头或者结尾
在String中使用startsWith（）方法判断字符串是否以指定的内容开头，使用endsWith（）方法判断字符串是否以指定的内容结尾
public class Demo{
    public static void main(String
args[]){
        Stringstr1 = "**HELLO" ;           //定义字符串
        Stringstr2 = "HELLO**" ;           //定义字符串
         if(str1.startsWith("**" )){           //判断是否以“**”开头
            System. out.println("（**HELLO）以**开头" )
;
        }
         if(str2.endsWith("**" )){             //判断是否以“**”结尾
            System. out.println("（HELLO**）以**结尾" )
;
        }
    }
};
结果：（**HELLO）以**开头
（HELLO**）以**结尾
 
StringBuffer类
String类有一条特性，一旦内容声明，其内容就不可改变，那么如果一个字符串要被经常改变，就必须使用StringBuffer类。
PS:StringBuffer类支持的大部分方法和String类相似.StrigBuffer在实际开发中可以提升代码的性能，所以使用比较多.下面介绍一些常用的
 
字符串连接操作--通过append连接各种类型的数据
public class Demo{
    public static void main(String
args[]){
        StringBufferbuf = new StringBuffer() ;    //声明StringBuffer对象
        buf.append( "Hello ");                   //向StringBuffer中添加内容
        buf.append( "World").append("!!!" )
;     // 可以连续调用append()方法
        buf.append( "\n");                       //添加一个转义字符
        buf.append( "数字 = ").append(1).append("\n")
;  //
添加数字
        buf.append( "字符 = ").append('C').append( "\n");     //添加字符
        buf.append( "布尔 = ").append(true )
;    // 添加布尔值
        System. out.println(buf);           //直接输出对象，调用toString()
        }
        
    }
结果：Hello World!!!
数字 = 1
字符 = C
布尔 = true
 
验证StringBuffer的内容是可以修改
public class Demo{
    public static void main(String
args[]){
        StringBufferbuf = new StringBuffer() ;    //声明StringBuffer对象
        buf.append( "Hello ") ;      
         fun(buf);       //传递StringBuffer内容
        System. out.println(buf) ;   //打印内容
    }
    public static void fun(StringBuffers){     //接收StringBuffer引用
        s.append( "hei ").append("ma" )
; // 修改StringBuffer的内容
        }
        
    }
结果：Hello hei ma
 
在任意位置为StringBuffer添加内容
public class Demo{
    public static void main(String
args[]){
        StringBufferbuf = new StringBuffer() ;    //声明StringBuffer对象
        buf.append( "World!!") ;     //添加内容
        buf.insert(0, "Hello ");        //在第一个内容之前添加内容
        System. out.println(buf) ;
        buf.insert(buf.length(), "heima~") ; //在最后添加内容
        System. out.println(buf) ;
        }
        
    }
 
结果：
Hello World!!
Hello World!!heima~
 
字符串反转操作
public class Demo{
    public static void main(String
args[]){
        StringBufferbuf = new StringBuffer() ;    //声明StringBuffer对象
        buf.append( "World!!") ;     //添加内容
        buf.insert(0, "Hello ");        //在第一个内容之前添加内容
        Stringstr = buf.reverse().toString() ;     //将内容反转后变为String类型
        System. out.println(str);       //将内容输出
        }
        
    }
结果：
!!dlroW olleH
 
替换指定范围的内容
public class Demo{
    public static void main(String
args[]){
        StringBufferbuf = new StringBuffer() ;    //声明StringBuffer对象
        buf.append( "Hello ").append("heima" );        //向StringBuffer添加内容
        buf.replace(6,11, "baima") ;     //将world的内容替换
        System. out.println("内容替换之后的结果：" +
buf) ;  // 输出内容
        }
        
    }
结果：内容替换之后的结果：Hello baima
 
字符串截取
public class Demo{
    public static void main(String
args[]){
        StringBufferbuf = new StringBuffer() ;    //声明StringBuffer对象
        buf.append( "Hello ").append("World!!" )
;        // 向StringBuffer添加内容
        buf.replace(6,11, "heima") ;     //将world的内容替换
        Stringstr = buf.substring(6,9) ;    //截取指定范围的内容
        System. out.println("内容替换之后的结果：" +
str) ;  // 输出内容
        }
        
    }
结果：内容替换之后的结果：hei
 
查找指定的内容是否存在
通过indexOf（）方法可以查找指定的内容，如果查找到了，则返回内容的位置，如果没有查找到则返回-1
 
public class Demo{
    public static void main(String
args[]){
        StringBufferbuf = new StringBuffer() ;    //声明StringBuffer对象
        buf.append( "Hello ").append("World!!" )
;        // 向StringBuffer添加内容
         if(buf.indexOf("Hello" )==-1){
            System. out.println("没有查找到指定的内容" )
;
        } else{  //不为01表示查找到内容
             System.out.println( "可以查找到指定的内容" )
;
        }
        }
        
    }
结果：可以查找到指定的内容
 
小结
1 String类在java中较为特殊，String可以使用直接赋值的方式，也可以通过构造方法进行实例化，前者只产生一个实例化对象，而且此实例化对象可以重用，后者将产生2个实例化对象，其中一个是垃圾空间，String中比较内容采时采用equals方法
而==比较的只是2个字符串的地址值。
2 字符串的内容一旦申明则不可以改变
3 频繁需要修改字符串的操作时，可以使用StringBuffer，效率高