黑马程序员-----String类

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

1、 字符串是一个特殊的对象，字符串一旦被初始化，就不可以被改变。
2、 字符串的特点：
1） 是一个对象
2） 是一个常量，不能被改变。
3） 字符串比较有自己独特的方式，叫做equals(),String类复写了Object类中的equals方法，用于判断内容是否相同。
4） 常见混淆问题：

String s1=”abc”;
String s2=new String(“abc”);
问：s1和s2有什么区别？
分析：s1在内存中有一个对象，s1是一个类类型变量，“abc”是一个对象。
      S2在内存中有两个对象，new String()是一个对象，“abc”是一个对象。
s1.equals(s2);//结果为false

3、 String类对字符串的常见操作：(重点)
1） int length();
2） char charAt(int index);获取位置上的某个字符
3） int indexOf(int ch);ch在字符串中第一次出现的位置
4） int indexOf(int ch，int fromIndex);从fromIndex指定位置开始，获取ch在字符串中出现的位置
5） int indexOf(String str);str在字符串中第一次出现的位置
6） int indexOf(String str，int fromIndex);从fromIndex指定位置开始，获取str在字符串中出现的位置
7） int lastIndexOf (int ch);ch在字符串中最后一次出现的位置
8） int lastIndexOf(int ch，int fromIndex);从fromIndex指定位置开始，进行反向搜索
9） int lastIndexOf (String str);str在字符串中最后一次出现的位置
10） int lastIndexOf (String str，int fromIndex);从fromIndex指定位置开始，获取str在字符串中最后一次出现的位置
11） boolean contains(str):字符串中是否包含某个子串
12） boolean isEmpty();字符串中是否有内容
13） boolean startsWith(str);字符串是否以指定的内容开头
14） boolean endsWith(str);字符串是否以指定的内容结尾
15） 将字符数组转成字符串
构造方法：
String(char[]);
String(char[]，offset,count);将字符数组中的一部分转成字符串，offset代表字符在数组中的起始位置，count代表包含的字符个数。
静态方法：
static String copyValueOf(char[]);
static String copyValueOf(char[],int offset,int count);
static String ValueOf(char[]);
16） char[] toCharArray();将字符串转成字符数组
17） String (byte[]);将字节数组转成字符串
String (byte[]，offset,count);将字节数组的一部分转成字符串。
18） byte[] getBytes();将字符串转换成字节数组
19） 将基本数据类型转成字符串
static String valueOf(int);//小括号里可以填所有的基本数据类型
20） 替换：String replace(oldchar,newchar);
21） 切割：String[] split(regex);
22） 获取字符串中的一部分（获取子串）
String substring(begin);从指定位置开始到结尾
String substring(begin,end);包含头，不包含尾
23） 将字符串转成大写或小写
String toUpperCase();
String toLowerCase();
24） 将字符串两边的多个空格去除
String trim();
25） 对两个字符串进行自然顺序的比较
int compareTo(String);

总结：java中“==”在比较常量时，是比较常量的值是否相等；如果比较的是对象，则是比较两个变量是否引用同一个对象。
即：
检查两个字符串引用是否指向同一个对象可以通过“==”符号判断；
检查两个字符串的内容是否相等可以通过equals()方法判断。

4、 字符串示例演示1：
/*
* 模拟一个trim方法，去除字符串两端的空格。
*
* 思路：
* 1,字符串转变成字符数组
* 2、定义一个指针进行循环，是指针指到第一个字符和最后一个字符处。
* 3，用字符串中的一个方法：substring方法获取子字符串
*
*/

public class 第九题 {
    public static void main(String[] args) {
        String s="      safgskkopirxzplmn       ";
        System.out.println("原字符串为："+s);
        myTrim(s);


    }
    public static void myTrim(String s)
    {

        int start=0;
        int end=s.length()-1;
        while(start<end && s.charAt(start)==' ')
        {
            start++;
        }
        while(start<end && s.charAt(end)==' ')
        {
            end--;
        }

        String str=s.substring(start,end);
        System.out.println("现字符串为："+str);

    }

}

字符串示例演示2：
/*
* 将一个字符串进行反转，将字符串中指定的部分进行反转；
* “abcdefg”—>”abfedcg
*
* 1,定义一个字符数组，长度为字符串的长度。
* 2，for循环遍历数组，从字符串的最后一个开始获取字符，并放在字符数组的前面，即字符数组的第一个元素存放的是字符串的最后一个字符。
* 3，将字符数组转换成字符串。
*
*/

public class 第十题 {

    public static void main(String[] args) {

        String s="  abcdefg  ";
        System.out.println(s);
        s=reverse(s);

        System.out.println(s);

    }

    public static String reverse(String str)
    {
        char[] ch=new char[str.length()];
        for(int i=0;i<str.length();i++)
        {
            ch[i]=str.charAt(str.length()-1-i);

        }
        return  String.valueOf(ch);
    }

}

字符串示例演示3：
/*
* 获取一个字符串在另一个字符串中出现的次数。
* 例如：从字符串”abkkcdkkefkkskk”中获取kk出现的次数。
*
* 思路：
* 1，将字符串进行切割，通过spit(kk)方法
* 2定义一个计数器，获取字符串数组中的个数，因为数组中有几个字符串kk就出现了几次。
*/

public class 第十一题 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String s="abkkcdkkefkkskk";
        //mySpit(s);
        System.out.println(""+getCount(s,"kk"));

    }
    //方法一：有缺陷，如果kk出现在数组的第一个位置上时，就不准确了。
    /*public static void mySpit(String s)
    {
        int count=0;
        String[] str=s.split("kk");
        for(int x=0;x<str.length;x++)
        {
            count++;
        }
        System.out.println(count);
    }
    */
    //方法二：
    public static int getCount(String s,String key)
    {
        int index=0;
        int count=0;
        while((index=s.indexOf(key, index))!=-1)//获取kk第一次出现的位置
        {
            count++;
            index=index+key.length();//将索引定义在关键字后第一个位置处，从这开始遍历。
        }
        return count;
    }

}

字符串示例演示4：
/*
* 获取两个字符串中最大相同子串 “abcwerthehelloyuiodef” “cvhellobnm”
*
* 思路：
* 1，用短的字符串进行查找，依次递减。
* 2，
*/

public class 十二题 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String s1="abcwerthehelloyuiodef";
        String s2="cvhellobnm";
        String s=getSubstring(s1,s2);
        System.out.println(s);

    }
    public static String getSubstring(String s1,String s2)
    {
        String max="",min="";
        max=(s1.length()>s2.length())?s1:s2;
        min=(max==s1)?s2:s1;
        for(int x=0;x<min.length();x++)
        {
            for(int y=0,z=min.length()-x;z!=min.length()+1;y++,z++)//y是头角标，z是尾角标
            {
                String temp=min.substring(y, z);
                if(s1.contains(temp))
                {
                    return temp;
                }
            }

        }
        return "";
    }


}

5、 StringBuffer容器：
1） 是一个字符串缓冲区，是一个容器。
2） 特点：长度是可变的；可以字节操作多个数据类型；最终会通过toString方法变成字符串。

6、 常见方法：
1） 存储：
StringBuffer append():将指定数据作为参数添加到已有的数据的尾处。
StringBuffer insert(index,数据):可以将数据插入到指定的index位置。
2） 删除：
StringBuffer delete（start,end）:删除缓冲区中的数据，包含头，不包含尾
StringBuffer deleteCharAt(index):删除指定位置的字符
**注：清空缓冲区
t1.delete(0,t1.length());**
3） 获取：
char charAt(int index)
int indexOf(String str)
int lastIndexOf(String str)
int length();
String substring(int start,int end)
4） 修改
StringBuffer replace(start,end,string)//头角标，尾角标，要替换的内容
void setCharAt(int index,char ch)
5） 反转
StringBuffer reverse()
7、 StringBuilder容器
**JDK1.5版本之后出现了StringBuilder。
总结：建议以后开发使用StringBuilder**

StringBuffer和StringBuilder的区别：
1）StringBuffer是线程同步的
StringBuilder是线程不同步的
2）StringBuffer与StringBuilder方法不变，功能都一样，只是存在有锁没锁的问题，StringBuilder是为了提高效率。

8、对象包装器：
Java中的类把方法与数据连接在一起，构成了自包含式的处理单元，但java中不能定义基本类型，为了能将基本类型视为对象来处理，并能连接相关的方法，java为每个基本
类型都提供了包装类。

 基本类型   ----->   包装类
   byte             Byte
   char             Char
   short            Short
   int              Integer
  long              Long
  float             Float
  double            Double
  boolean           Boolean 

9、基本数据类型对象包装类的最常见作用：基本数据类型和字符串类型之间做转换。

10、基本类型—字符串
1）基本类型数值+””
2）用String类中的静态方法valueOf(基本类型数值)
3）基本类型.toString(基本类型数值)

字符串—基本类型
1） 使用包装类中的静态方法
xxx a=Xxx.parseXxx(String)

例：int i=Integer.parseInt(“123”);
double d= Double.parseDouble(“12.34”);
注：只有Character没有parse方法。

2） 如果字符串被Integer进行对象的封装，可使用另一个非静态方法：intValue();将一个Integer对象转成基本数据类型值。

例：Integer i=new Integer(“123”)
System.out.println(i.intValue());

十进制–其他进制
1） toBinaryString();//转成二进制
2） toHexString(); //转成八进制
3） toOctalString(); //转成十六进制

其他进制—十进制
parseInt(string,radix);// radix为指定进制的基数

例：int x=Integer.parseInt(“3c”,16);
//将十六进制的3c转换成十进制。

11**、装箱和拆箱（JDK1.5出现的新特性）**
1）、装箱：将基本数据类型包装为对应的包装类对象。

例：Integer  x=new Integer(4);
       自动装箱的写法：Integer x=4;

2）、拆箱：将包装类对象转换成对应的基本数据类型

例：Integer x=4;//进行自动装箱
           x=x+2;//x进行自动拆箱，变成int类型，和2进行加法运算，再将和进行装箱赋值给x

12、总结：
在使用自动装箱时要注意两点：
1） 防止没有初始化就使用变量所引起的空指针异常问题。

例：Integer i=null;
int j=i;

2） 注意数字类型装箱时的特殊变化

例1：Integer m=200;
Integer n=200;
Sop(“m==n”+(m==n));//返回结果为false
例2：Integer a=127;
Integer b=127;
Sop(“a==b”+(a==b));//返回结果为true
       分析：“==”也用于判断两个对象参考名称是否指向同一个对象。对于新特性，如果该数值已经存在，则不会再开辟新空间，即自动装箱时对于在byte范围（-128--127）之间的数值，它们被装箱为Integer对象后，会存在内存之中被重用。例1数值超出了byte范围，例2数值没有超出范围，所以，以上两个结果不同。

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