黑马程序员-------String StringBuffer StringBuilder

来源：互联网发布：几款进销存软件好坏编辑：程序博客网时间：2024/04/29 13:38

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

String

[java] view plaincopy
package day13;  
/** 
 * String 介绍 
 * @author hao 
 * 
 */  
public class StringDemo {  
    public static void main(String[] args) {  
        String s1 = "aslkfjdl";  
        //s1 是一个类类型变量，"aslkfjdl"是一个对象。  
        //字符串的最大特点：一旦被初始化就不可以被改变  
          
        String s2 = new String("aslkfjdl");  
          
        /* 
         * s1和s2有什么区别 
         * s1在内存中有一个对象 
         * s2在内存中有两个对象 
         */  
        System.out.println(s1==s2); //false  
        System.out.println(s1.equals(s2));//true   
        //String类复写Object类的equals方法   比对象  
    }  
}  

=============================================================================

字符串的方法

[java] view plaincopy
package day13;  
/** 
 * 字符串方法 
 * @author hao 
 * 
 *String 类适用于描述字符串事物。 
 *那么它提供了多个方法对字符串进行操作 
 * 
 *常见的操作方法 
 * 
 *"abcd" 
 * 
 *1.获取 
 *  1.1 字符串中的包含的字符数，也就是字符串的长度 
 *      int length（）：获取长度 
 *  1.2 根据位置获取位置上某个字符 
 *      char charAt（int index）： 
 *  1.3 根据字符获取该字符在字符串中的位置 
 *      int indexOf(int ch):返回的是ch在字符串中第一次出现的位置 
 *      int indexOf(int ch, int fromIndex):从fromIndex指定位置开始，获取ch在字符串中的位置 
 * 
 *      int indexOf(String str):返回指定子字符串在此字符串中第一次出现处的索引。 
 *      int indexOf(String str, int fromIndex):返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。 
 *      int lastIndexOf(int ch):返回指定字符在此字符串中最后一次出现处的索引。 
 * 
 *2.判断 
 *  2.1 字符串中是否包含某一个子串 
 *      boolean contains(str) 
 *      特殊之处：indexOf(str):可以索引str第一次出现的位置，如果返回-1，表示该str不在字符串中存在 
 *      所以，也可以用于对指定判断是否包含。 
 *      if(str.indexOf("ss")!=-1)  该方法既可以判断是否包含，还可以获取出现的位置 
 *  2.2 字符中是否有内容 
 *      boolean isEmpty():就是判断长度是否为零 
 *  2.3 字符串是否是以指定内容开头 
 *      boolean startsWith(str) 
 *  2.4 字符串是否是以指定的内容结尾 
 *      boolean endsWith(str) 
 *  2.5 判断内容是否相同，并忽略大小写 
 *      boolean equalsIgnoreCase() 
 * 
 *3. 转换 
 *  3.1 将字符数组转成字符串 
 *      构造方法：String(char[]) 
 *              String(char[],offset,count):将字符数组中的一部分转成字符串 
 *      静态方法：static String copyValueOf(char[] data)   
 *              static String copyValueOf(char[] data, int offset, int count)  
 *               
 *              static String valueOf(char[]): 
 *               
 *  3.2 将字符串转成字符数组 
 *               char[] toCharArray()  
 *  3.3 将字节数组转成字符串 
 *          String(byte[] bytes)  
 *          String(byte[] bytes, int offset, int length) 
 *  3.4 将字符串战场字节数组 
 *          byte[] getBytes[] 
 *  3.5 将基本数据类型转换成字符串 
 *          static String valueOf(int) 
 *          static String valueOf(double) 
 * 
 *  4 替换 
 *      String replace(oldchar,newchar); 
 * 
 *  5 切割 
 *      String[] split(String str) 
 * 
 *  6 子串  获取字符串中的一部分 
 *      String subString(begin) 
 *      String subString(begin,end) 
 * 
 *  7 转换，去除空格 比较 
 *      7.1 将字符串转成大写或者小写 
 *          String toUpperCase() 
 *          String toLowerCase() 
 * 
 *      7.2 将字符串两端的空格去掉 
 *          String trim() 
 * 
 *      7.3 对两个字符串进行自然顺序的比较 
 *          int compareTo(string) 
 */  
public class StringMethodDemo {  
      
    public static void Method_7()  
    {  
        String str = "   Hao Hao   ";  
          
        sop(str.toUpperCase());  
        sop(str.toLowerCase());  
        sop(str.trim());  
          
        String s1 = "hao";  
        String s2 = "haa";  
          
        sop(s1.compareTo(s2));  
    }  
      
    public static void method_sub()  
    {  
        String str = "abcdefg";  
          
        sop(str.substring(2));//从指定位置开始到结尾  
        sop(str.substring(2,4));//包含头 不包含尾     s.subString(0,s.length)  
          
    }  
      
    public static void method_split()  
    {  
        String s = "hao,da,hao,da";  
          
        String[] arr = s.split(",");  
          
        for(int i = 0; i<arr.length; i++)  
        {  
            System.out.println("arr["+i+"]="+arr[i]);  
        }  
    }  
      
    public static void method_replace()  
    {  
        String s = "Hello Java";  
          
    //  String s1 = s.replace('a', 'e');  
    //  String s2 = s.replace('w', 'e');//如果替换的字符不存在，将返回原串  
        String s1 = s.replace("Java","hao");  
          
        sop("s="+s);  
        sop("s1="+s1);  
    }  
      
    public static void method_trans()  
    {  
        char[] arr = {'a','b','c','d','e','f'};  
        String str = new String(arr);  
        sop(str);  
          
        String s1 = "xkdjflzz";  
          
        char[] arr1 = s1.toCharArray();  
        for (char c : arr1) {  
            System.out.println(c);  
        }  
          
    }  
      
    public static void method_is()  
    {  
        String str = "ArrayDemo.java";  
          
        //判断文件名称是否以Array开头  
        sop(str.startsWith("Array"));  
        //判断文件名称是否以.java结尾  
        sop(str.endsWith(".java"));  
        //判断文件名称是否包含Demo  
        sop(str.contains("Demo"));  
    }  
      
    public static void method_get()  
    {  
        String str = "abcadef";  
        //长度  
        sop(str.length());  
          
        //根据索引获取字符  
        sop(str.charAt(2));  
          
        //根据字符获取索引  
        sop(str.indexOf('a',2));  
          
        //根据字符串获取索引  
        sop(str.indexOf("ad"));  
          
        //反向索引一个字母的位置  
          
        sop(str.lastIndexOf('a'));  
    }  
      
    public static void main(String[] args) {  
          
        Method_7();  
        //method_sub();  
          
    //  method_split();  
          
    //  method_replace();  
    //  method_trans();  
        //method_is();  
        //method_get();  
        /*String s1 = "abc"; 
        String s2 = new String("abc"); 
        String s3 = "abc"; 
         
        System.out.println(s1==s2);//false 
        System.out.println(s1==s3);//true 
        */  
          
    }  
      
    public static void sop(Object obj)  
    {  
        System.out.println(obj);  
    }  
}  

=========================================================================================
字符串的练习

1.字符串的反转

[java] view plaincopy
package day13;  
/** 
 * 将一个字符串反转，将字符串指定的部分进行反转 "abcdefg""abfedcg" 
 * @author hao 
 *思路： 
 *1.曾经学习过对数组的元素进行反转 
 *2.将字符串变成数据，对数组进行反转 
 *3.将反转的字符数组变成字符串 
 *4.只要将或反转的部分的开始和结束的位置作为参数传递即可 
 */  
public class ReverseDemo {  
  
    public static String getReverse(String str, int begin,int end)  
    {  
        //1.将字符串变成字符数组  
        char[] arr = str.toCharArray();  
        //2.将字符数组进行反转  
        char[] arr1 =reverse(arr,begin,end);  
        //3.将字符数组变成字符串  
        return new String(arr1);  
    }  
    public static String getReverse(String str)  
    {  
          
        return getReverse(str,0,str.length()-1);  
          
    }  
    //交换给定范围的字符数组  
    private static char[] reverse(char[] arr,int begin,int end) {  
          
        for(;begin<end;begin++,end--)  
        {  
            remove(arr,begin,end);  
        }  
        return arr;  
    }  
    //交换两个字符  
    private static void remove(char[] arr, int begin, int end) {  
              
        char temp = arr[begin];  
        arr[begin] = arr[end];  
        arr[end] = temp;  
          
          
    }  
      
    public static void main(String[] args) {  
        String str= "abcdef";  
        System.out.println(getReverse(str,2,4));  
        System.out.println(getReverse(str));  
    }  
}  

2.模拟trim方法

[java] view plaincopy
package day13;  
/** 
 * 模拟一个trim方法，去除字符串两端的空格 
 * @author hao 
 * 
 *思路： 
 *1.判断字符串第一个位置是否是空格，如果是继续向下判断，直到不是空格为止 
 *  结尾处判断空格也是如此 
 *2.当开始和结尾都判断不是空格时，就是要获取字符串 
 */  
public class TrimDemo {  
    public static String trimTest(String str)  
    {  
        int begin = 0,end = str.length()-1;  
          
        while(begin<=end && str.charAt(begin)==' ')  
            begin++;  
        System.out.println("begin="+begin);  
          
        while(begin<= end && str.charAt(end)==' ')  
            end--;  
        System.out.println("end="+end);  
          
        return str.substring(begin,end+1);  
    }  
      
    public static void main(String[] args)  
    {  
        String s = "  hao  ";  
          
        System.out.println(trimTest(s));  
    }  
}  

3. 获取一个字符串在另一个字符串中出现的次数

[java] view plaincopy
package day13;  
/** 
 * 获取一个字符串在另一个字符串中出现的次数 
 * @author hao 
 *"abhaoledahaolvhaopp" 
 *思路： 
 *1.定义一个计数器 
 *2.获取hao第一次出现的位置 
 *3.从第一个出现的位置后剩余的字符串中继续获取hao出现的位置 
 *      每获取一次就计数一次 
 *4.当获取不到是，计数完成 
 */  
public class GetStringTime {  
      
    public static int getTimes(String s1,String key)  
    {  
        int count = 0;  
        while(s1.length()>=key.length())  
        {  
            int index = s1.indexOf(key);  
            if(index!=-1)  
            {  
                s1=s1.substring(index+key.length());  
                count++;  
                //System.out.println(count);  
            }else  
                return count;  
        }  
        return count;  
    }  
      
    public static int getTimes2(String str,String key)  
    {  
        int count =0;  
        int index = 0;  
        while((index=str.indexOf(key,index))!=-1)  
        {  
            System.out.println(index);  
            index = index+key.length();  
            count++;  
        }  
                      
            return count;  
    }  
      
    public static void main(String[] args) {  
        String s1 = "abhaoledahaolvhaopp";  
        String key = "hao";  
        System.out.println(getTimes(s1,key));  
        System.out.println(getTimes2(s1,key));  
    }  
}  

4.获取两个字符串中最大的相同子串

[java] view plaincopy
package day13;  
/** 
 * 获取两个字符串中最大的相同子串，第一个动作：将短的那个串进行长度一次递减的子串打印 
 * "lklj9ewpooehaodpwepo" 
 * "djfhaodlleslfj" 
 * @author hao 
 * 
 *思路： 
 *  1.将短的那个子串按照长度递减的方式获取到 
 *  2.将每获取到的子串去和长串比较判断是否包含  如果包含，已经找到 
 */  
public class LongString {  
    public static String getLong(String s1,String s2)  
    {     
        String max,min;  
        if(s1.length()> s2.length()){  
            max=s1;  
            min = s2;  
        }  
        else  
        {  
            min = s1;  
            max = s2;  
        }  
              
        for(int i = 0; i<min.length(); i++)  
            for(int start=0, end =min.length()-i;end!=min.length()+1;start++,end++)  
            {  
                String temp = min.substring(start,end);  
            //  System.out.println(temp);  
                if(max.contains(temp))  
                    return temp;  
            }  
        return "";  
    }  
      
    public static void main(String[] args) {  
        String s1 = "lklj9ewpooehaodpwepo";  
        String s2 = "djfhaodlleslfj";  
          
        System.out.println(getLong(s2,s1));  
    }  
}  

==================================================================================================

StringBffer介绍与方法

[java] view plaincopy
package day13;  
/** 
 * StringBuffer 
 * @author hao 
 * 
 *StringBuffer 是一个容器 
 *特点： 
 *1.长度可以变化 
 *2.可以存储多种数据 
 *3.最终可以通过toString方法编程字符串 
 * 
 *1.存储（create） 
 *      StringBuffer append()：将指定数据作为参数添加到已有数据的结尾 
 *      StringBuffer insert(index,数据)：可以将数据添加到指定的位置 
 * 
 *2.删除（delete） 
 *      StringBuffer delete(start,end):删除缓存区中的数据，包含start 不包含end 
 *      StringBuffer deleteCharAt(index): 删除指定的字符 
 * 
 *3.修改（update） 
 *      StringBuffer replace(start,end,string) 
 *      void setCharAt(int index, char ch) 
 * 
 *4.获取（read） 
 *      char charAt(index) 
 *      int  indexOf(String str) 
 *      int  lastIndexOf(String str) 
 *      int  length() 
 *      String substring(int start,int end) 
 * 
 *5.反转 
 *      StingBuffer reverse() 
 * 
 *6. void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)   
 *       将字符从此序列复制到目标字符数组 dst。 
 *======================================================================== 
 *   
 *      StringBuffer 是线程同步的 
 *      StringBuilder 是线程不同步的（1.5版本出现 ） 
 *      开发时建议 使用 StringBuilder 
 * 
 *  升级三个因素： 
 *  1.提高效率 
 *  2.简化书写 
 *  3.提高安全性 
 *   
 */   
public class StringBufferDemo {  
      
    public static void method_updata()  
    {  
        StringBuffer sb = new StringBuffer("abcdefg");  
          
        sb.replace(2, 4, "hao");  
          
        sop(sb);  
    }  
      
    //删除  
    public static void method_delete()  
    {  
        StringBuffer sb = new StringBuffer("abcdefg");  
          
        sb.delete(1, 2);  
    //  sb.delete(0, sb.length()); 清除缓存区  
        sop(sb);  
    }  
      
    //存储  
    public static void method_create()  
    {  
        StringBuffer sb = new StringBuffer();  
          
        sb.append(88).append("hao").append("dd");  
        sop(sb);  
          
        sb.insert(2, "xx");  
          
        sop(sb);  
          
//      StringBuffer sb1 = sb.append("lll");  
          
//      sop(sb==sb1);// true  
//      sop(sb.equals(sb1));//true  
    }  
      
    public static void main(String[] args) {  
          
        method_updata();  
          
//      method_delete();  
//      method_create();  
    }  
      
    public static void sop(Object str)  
    {  
        System.out.println(str);  
    }  
}  

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

0 0