String类

-------android培训、java培训、期待与您交流！ ---------- 

一，String类：

String类特点：
    1，Java语言中用于描述最常见的字符串数据对象。
    2，字符串数据都是对象。
    3，字符串数据一旦初始化就不可以被改变。
    4，字符串对象都存储在常量池中。
基本数据用==进行比较相同，对象比较相同都用equals方法。

常见的操作有哪些？
1，获取。
    1.1 字符串中包含的字符数也就是字符串的长度。
           int len = str.length():获取长度。
    1.2 根据位置获取某位置上的字符。
           char ch = str.charAt(int index)
    1.3 根据字符获取该字符在字符串上的位置（如果没有找到返回-1）。
           int index = str.indexOf(int ch):返回的是ch在字符串中第一次出现的位置。
           int index = str.indexOf(int ch,int fromIndex):从fromIndex指定位置开始，获取ch在字符串中出现的位置。
           int index = str.indexOf(String str):返回的是str在字符串中第一次出现的位置。
           int index = str.indexOf(String str,int fromIndex):从fromIndex指定位置开始，获取str在字符串中出现的位置。
           int index = str.lastIndexOf(int ch)。
    1.4 获取字符串的一部分
           String str1 = str.substring(int begin);//从指定位置到结尾。
           String str1 = str.substring(int begin,int end);//包含头不包含尾。

代码示例：

public static void methodDemo(){    String str = "adjhdfkkx";    //获取长度    System.out.println(str.length());    //获取某一位置上的字符   System.out.println(str.charAt(3));    //根据字符获取位置   System.out.println(str.indexOf('h'));    //获取字符串的一部分    System.out.println(str.substring(2,6));}

2，判断。
      2.1 字符串中是否包含某一个子串。
             boolean b = str1.contains(str);原理是判断字符串是否存在
             特殊之处：indexOf(str)可以索引str第一次出现的位置，如果返回-1，表示该str不在字符串中存在。
             所以，也可以用于对指定判断是否包含。
       2.2 字符串中是否有内容。
             boolean b = str.isEmpty();原理就是判断长度是否为0.
       2.3 字符串是否是以指定内容开头。
             boolean b = str1.startsWith(str);
       2.4 字符串是以指定内容结尾。
             boolean b = str1.endsWith(str);
       2.5 判断字符串内容是否相同。复写了Object类中的equals方法。
             boolean b = str1.equels(str);
       2.6 判断字符串内容是否相同，并忽略大小写。
             boolean b = str1.equelsIgnoreCase(str);

 示例

public static void methodDemo1() {String str = "abdenbacsdn";String str1 = "nba";//判断str中是否包含str1,返回值booleanboolean b = str.contains(str1);//判断字符串中是否以指定内容开头boolean b1 = str.startsWith("ad");//判断字符串内容是否相同boolean b2 = str.equals(str1);}

 
3，转换
       3.1 将字符数组转换成字符串。
              构造函数：String(char[])
                                  String(char[],offset,count):将字符数组中的一部分转换成字符串。
              静态方法：static String copyValueOf(char[]);
                                  static String valueOf(char[] data, int offset, int count)  
                                  static String valueOf(char[])  
       3.2 将字符串转换成字符数组。**
              char[] chs = toCharArray():
        3.3 将字节数组转换成字符串。
               构造函数：String(byte[])
                                   String(byte[],offset,count):将字节数组中的一部分转换成字符串。
         3.4 将字符串转换成字节数组。
                byte[]bt= getBytes():
         3.5 将基本数据类型转换成字符串。
                String valueOf(int)
                String valueOf(double)

                 // 3+"";//相当于String.valueOf(3);

代码演示：

public static void methodDemo2() {char[] chs = {'n','b','a','c','s','d','n'};//将字符数组转成字符串String str = new String(chs);String str1 = new String(chs,2,4);//将从第2角标开始往后推移4个角标的字符转成字符串System.out.println(str+"::"+str1);//将字符串变成字符数组char[] chs1 = str.toCharArray();System.out.println(chs1);}

特殊：字符串和字节数组在转换过程中，是可以指定编码表的。

4，替换。
           String str = str.replace(char oldChar, char newChar);  
            如果要替换的字符不存在，返回的还是原串。
5，切割。
            String[] str = split(regex)；
6，转换，去除空格，比较。
7.1 将字符串转成大写或者小写。
            String str = str.toUpperCase();
            String str = str.toLowerCase();
7.2 将字符串两端的多个空格去除。
            Stirng str = str.trim();
7.3 对两个字符串进行自然顺序的比较。
            int compareTo(string);

二，StringBuffer:
  StringBuffer是字符缓冲区，是一个容器。
 特点：
       1，长度是可变化的。
       2，可以直接操作多个数据类型。
       3，最终会通过toString方法变成字符串。
  
  1，存储。
        StringBuffer append():将指定数据作为参数添加到已有数据的结尾处。
        StringBuffer insert(index,数据)：可以将数据插入到指定index位置。  
  2，删除。
        StringBuffer delete(int start,int end) ：删除缓冲区中的数据。包含start，不包含end
        StringBuffer deleteCharAt(index)：删除指定位置的字符。
         
  3，获取。
        char charAt(int index)  
        int indexOf(String str) 
        int lastIndexOf(String str) 
        int length() 
        String substring(int start, int end)  
  
  4，修改。
       StringBuffer replace(int start, int end, String str) 
       void setCharAt(int index, char ch) 
 
  5,反转。
       StringBuffer reverse();
  
  6,将缓冲区中指定数据存储到指定字符数组中。
         void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)  

代码演示：

public static void methodDemo() {//创建一个字符串缓冲区。StringBuffer sb = new StringBuffer();//添加元素sb.append("csdnjavawebitcast");sb.insert(4, "my");//将"my"插入到角标4的位置。System.out.println(sb);//删除元素sb.delete(4, 5);System.out.println(sb);//获取元素char ch = sb.charAt(5);//获取角标为5的字符。int index = sb.indexOf("java");//获取java所在的角标。System.out.println("index="+index);//修改元素StringBuffer str = sb.replace(9, 12, "se");System.out.println(str);}

    JDK1.5版本以后出现了StringBuilder。
  StringBuffer是线程同步。
  StringBuilder是线程不同步。
  以后开发，建议使用StringBuilder，只有在多线程时才使用StringBuffer。


StringBuffer和数组容器的区别？ 
      1，数组容器是固定长度的。
            StringBuffer是可变长度的。
      2，数组容器一旦初始化就明确了元素的类型。
             StringBuffer可以存储任意类型。包括基本和引用。
      3，数组存储完元素可以对元素进行操作（通过角标）。
            StringBuffer存储完元素后，都会变成字符串，只能用字符串的方法来操作。
什么时候用StringBuffer或者StringBuilder？
数据个数可以是固定的，可是是不固定的，数据类型也可以是固定的，或者不固定的。
只要最终这些数据都需要变成字符串来操作时，就可以使用字符串缓冲区。

巩固练习：

package day02;public class StringTest2 {/** * @param args */public static void main(String[] args) {// TODO Auto-generated method stub/* * 综合性练习： * 1，获取一个子串在字符串中出现的次数。 * "nbawernbatyunbaidfnbaghjnba" nba出现了几次。  *  * 思路： * 1，需要对nba在整串中进行查找。 *  2，如果找到了，记录nba出现的位置， *  3，再从这个位置+nba长度的位置开始继续查找剩下的字符串中是否还有nba。 *  4，通过计数器来记录每次查找的次数  *   *  步骤: *  1，先有计数器。 *  2，定义变量记录每次出现的位置。 *  3，可以通过String类中的indexOf方法来完成对子字符串的索引。  *  4，指定的子串有可能有很多，需要不断的查找(循环 ，条件，找不到了就结束。). *   */String str = "nbawernbatyunbaidfnbaghjnba" ;String key = "nba" ;//System.out.println(str.indexOf(key,3));int count = countString(str,key);System.out.println("count="+count);/*  * 2，对字符串进行反转。 如："abcd"-->"dcba"; * 思路： * 1，一看反转，就让我想到了曾经的数组反转。 * 2，可以将字符串转成数组， * 3，数组进行反转。(无非就是头尾角标元素的位置置换。) * 4，将数组变成字符串。 *  */String str1 = "abcde";System.out.println(str1);str1 = reverseString(str1);System.out.println(str1);/* 3，对一个字符串中的字符进行字典顺序的排序生成一个有序的字符串。 * 如："cbda"--->"abcd"; * 思路： * 1，一看排序，就想到数组。 * 2，将字符串先转成数组。 * 3，对数组排个序。 * 4，将排序的数组变成字符串。 *  */stringSort();/*  * 4，获取两个字符串中最大相同子串。 * 如："rtyuicctvoprtyu" *         "cvbcctvnm"  最大相同是cctv *          * 思路： * 1，既然获取的最大子串，找到其中一个比较短的为参照， * 去判断大中的是否包含短串。 * 2，如果不包含，将短的长度按照依次递减的方式获取短串中的子串。 * 并不断地判断是否在长串中存在， * 3，如果存在，视为找到，结束。 */getMaxSubString();}private static void getMaxSubString() {// TODO Auto-generated method stubString str1 = "rtyuicctvoprtyu";String str2 = "cvbcctvnm" ;String maxStr = (str1.length()>str2.length()? str1:str2);//找到长的字符串String minStr = (str1.length()>str2.length()? str2:str1);//找到短的字符串为参照p:for(int x=0;x<minStr.length();x++){for(int y=0,z=minStr.length()-x;z<minStr.length()+1;y++,z++){String temp = minStr.substring(y, z);//System.out.println(temp);if(maxStr.contains(temp)){System.out.println("最大子串是："+temp);break p;//跳出p指向的循环}}}}private static void stringSort() {// TODO Auto-generated method stubString str = "cde2ba-8+1fq";char[] chs = str.toCharArray();for(int x=0;x<chs.length-1;x++){for(int y=x+1;y<chs.length;y++){if(chs[x]>chs[y]){char temp = chs[x];chs[x]=chs[y];chs[y]=temp;}}}String str1 = String.valueOf(chs);System.out.println(str1);}private static String reverseString(String str) {// TODO Auto-generated method stub//将字符串便字符数组char[] chs = str.toCharArray();//将字符数组反转for(int start=0,end=chs.length-1;start<end;start++,end--){char temp = chs[start] ;chs[start] = chs[end] ;chs[end] = temp ;}//将数组变成字符串return String.valueOf(chs);}private static int countString(String str, String key) {// TODO Auto-generated method stubint count = 0 ;int index = 0 ;while((index=str.indexOf(key,index))!=-1){count++;index = index + key.length() ;System.out.println("index="+index);}return count;}}

三，对象包装类：

对象包装类的好处：可以讲基本数据类型和字符串之间进行相互转换。


基本数据类型--->字符串
1，基本数据类型对象包装类中的方法 static String toString(基本类型)
2，String类中的方法 Static String valueOf(基本类型)
重点掌握的就是：
字符串--->基本类型数据。
基本类型参数，字符串
基本类型 parse基本类型类名(是基本类型格式的字符串)
格式：Xxx parseXxx(XxxString)
如：Integer parseInt(IntString)
   long parseLong(longString)
如：Integer.parseInt("24");
在八个基本类型对象包装类 中中有一个对象没有parse方法，就是Character


十进制--->其他进制。
二进制：static String toBinaryString(int)
十六进制：static String toHexString(int)
八进制：static String toOctalString(int)
其它进制--->十进制。
int parseInt(intString,radix);//intString：int类型的字符串。


基本数据类型值--->基本类型数据对象
使用构造函数。既可以接收基本数值，也可以接收基本数值的字符串形式。
可以使用基本类型对象中的方法。如，static Integer  valueOf(int);
基本类型对象--->基本数据类型数值
int intvalue();
如，Integer i = new Integer(34);
int num = i.intValue();




对象想要进行比较，必须通过方法来完成，这个方法就是compareTo。
而很多对象都可以进行比较。所以这个方法定义在Comparable接口中。
想要对象具备比较功能，只要实现Comparable接口。
例如，

Integer a = new Integer(7); Integer b = new Integer(5); System.out.println(a.compareTo(b));

基本类型值比较用比较运算符进行比较。
引用数据类型使用comparaTo进行比较。

基本数据类型对象包装类jdk1.5后的新特性。 
新特性的出现无非就是简化书写，让这些对象可以象操作基本数值一样进行运算。
//Integer i = new Integer(5);
//基本数据类型对象包装类，对象创建的简化写法。
Integer i = 5;//i = new Integer(5);自动装箱。自动完成了对象创建的动作。Integer.valueOf(5);
i  = i/*.intValue()*/ + 5;//=右边的i会先转成基本数据值(自动拆箱)，然后再和5进行加法运算。 
//=右边运算完的结果，再次被自动装箱变成Integer对象赋给i。
//一旦简化就有弊端：多具备一个值null。记住要使用自动装箱拆箱时，建议进行null的健壮性判断。
//Integer x = null;//
//x = x.intValue() + 4;//会出现空指针异常。


在jdk1.5后的新特性自动装箱中，
如果数值在byte类型范围内(-128~127)。如果该对象数值重复出现，多个引用其实指向的同一个Integer对象。
但是如果超出byte范围，都会生成新的Integer对象
例如：  

Integer m = 127;Integer n = 127;System.out.println(m==n);//trueSystem.out.println(m.equals(n));//trueInteger a = new Integer(127);Integer b = new Integer(127);System.out.println(a==b);//falseSystem.out.println(a.equals(b));//true

                                                                       ------- android培训、java培训、期待与您交流！ ----------