Java字符串String类操作方法整理

    最近利用晚上的一些空闲时间学习了Java的字符串部分，发现其与C语言、C++等面向过程语言在使用上出现的不同点，C语言仅仅提供了字符串类型的一个构造，相当于只给了开发者基本材料，让开发者自行去用材料造轮子;而Java给字符串提供了许多的可用方法，调用这些方法可以在一定程度上加快程序的开发效率，这也就相当于Java已经给开发人员提供好了轮子，只要用轮子去造车子便可，所以这就是面向对象思想与面向过程思想的其中一个区别吧。所以我喜欢Java的原因大概是Java可以随时随地new一个对象吧。。。

    但是也正因为这一特点，让初学者头秃的是在短时间内没有办法熟练掌握和应用这些方法，那我也觉得编程之路上没有捷径，所有的技术大神除了天赋与兴趣，那每天的事情就是敲代码敲代码敲代码。所以在学完String类的简单操作方法后，我打算在博客上先将这些方法进行分类和整理，暂时需要做的是理清这些方法应用于哪些情况，又该如何去调用这些方法，之后就每天对着这些方法慢慢敲慢慢敲敲到熟练为止，至于那些运用在项目中的复杂的骚操作，那就留给时间和头发吧。

    然后。。。就不给自己灌鸡汤了，正事儿要紧！！

    关于String类的基本操作，可分为以下几类：1、基本操作方法  2、字符串比较  3、字符串与其他数据类型之间的转换  4、字符与字符串的查找  5、字符串的截取与拆分  6、字符串的替换与修改

    我觉得在整理到下面的内容之前需要给自己提的醒是关于字符串的操作方法我们是不需要像其他操作一样手动导包的，其String和StringBuffer等类封装在java.lang包中，我们直接调用字符串方法即可！

    一、String基本操作方法

    首先说一下基本操作方法，字符串的基本操作方法中包含以下几种：(1)获取字符串长度length()  (2)获取字符串中的第i个字符charAt(i)  (3)获取指定位置的字符方法getChars(4个参数)

    1、 获取字符串长度方法length()

          格式：int length = str.length();

    2、获取字符串中的第i个字符方法charAt(i)

          格式：char ch = str.charAt(i);  //i为字符串的索引号，可得到字符串任意位置处的字符，保存到字符变量中

    3、获取指定位置的字符方法getChars(4个参数)

          格式：char array[] = new char[80];  //先要创建以一个容量足够大的char型数组，数组名为array

                      str.getChars(indexBegin,indexEnd,array,arrayBegin);

          解释一下括号中四个参数的指向意义：1、indexBegin：需要复制的字符串的开始索引

                                                                    2、 indexEnd:    需要复制的字符串的结束索引，indexEnd-1

                                                                    3、array:             前面定义的char型数组的数组名

                                                                    4、arrayBegin:数组array开始存储的位置索引号

          这样我们就可以将字符串中想要的范围内的字符都复制到字符数组中，将字符数组打印输出即可。

          与getChars()类似的方法有一个getBytes(),两者使用上基本相同，只是getBytes()方法创建的是byte类型的数组，而byte编码是默认字符集编码，它是用编码表示的字符。

下面就上代码简单演示一下三种方法的用法：

//String类基本操作方法
public class StringBasicOpeMethod {
    public static void main(String args[]){
        String str = "如何才能变得像棋哥一样优秀？算了吧，憋吹牛逼！"; //定义一个字符串
        System.out.println(str);  //输出字符串
        /***1、length()方法***/
        int length = str.length();//得到字符串长度
        System.out.println("字符串的长度为："+length);
        /***2、charAt()方法***/
        char ch = str.charAt(7);  //得到索引为7的字符
        System.out.println("字符串中的第8个字符为："+ch);
        /***3、getChars()方法***/
        char chardst[] = new char[80]; //定义容量为80的字符数组，用于存储从字符串中提取出的一串字符
        str.getChars(0,14,chardst,0);
        //System.out.println("字符数组中存放的内容为："+chardst);//错误，输出的是编码
        System.out.println(chardst); //**括号中不可带其他字符串
    }
}

 运行结果如下：

    

  二、字符串比较 

   我们知道，明确的数值之间可以很方便地进行比较，那么字符串该如何进行比较呢？字符串的比较是将两个字符串从左到右逐个字符逐个字符进行比较，比较的依据是当前字符的Uncode编码值，直到比较出两个不同字符的大小。

    字符串比较也分为两大类：一类是字符串大小的比较，这样的比较有三种结果，大于、等于以及小于；还有一类比较方法就是比较两个字符串是否相等，这样产生的比较结果无非就两种，ture和false。

    1、首先看一下第一种比较大小这类需求中的方法：

         (1)不忽略字符串大小写情况下字符串的大小比较方法compareTo(another str)

                   格式：int result = str1.compareTo(str2);

                输出三种比较结果：若该字符串的Unicode值<参数字符串的Unicode值，结果返回一负整数；若若该字符串的Unicode值=参数字符串的Unicode值，结果返回0；若该字符串的Unicode值>参数字符串的Unicode值，结果返回一正整数。

         (2)  忽略字符串大小写情况下字符串的大小比较方法compareTOIgnoreCase(another str)

                   格式：int result = str1.compareToIgnoreCase(str2);

                在忽略字符串大小写情况下，返回三种比较结果：输出三种比较结果：若该字符串的Unicode值<参数字符串的Unicode值，结果返回一负整数；若若该字符串的Unicode值=参数字符串的Unicode值，结果返回0；若该字符串的Unicode值>参数字符串的Unicode值，结果返回一正整数。

    2、然后看一下第二种判别两种字符串是否相等(相等情况下必须保证二者长度相等)需求中的方法：

            (1)不忽略字符串大小写情况下判别字符串相等的方法eaquals(another str)

                   格式：boolean result = str1.equals(str2);

                   当且仅当str1和str2的长度相等，且对应位置字符的Unicode编码完全相等，返回true,否则返回false

             (2)   忽略字符串大小写情况下判别字符串相等的方法equalsIgnoreCase(another str)

                    格式：boolean result = str1.equals(str2);

  demo如下：

public class StringCompareMethod {
    public static void main(String args[]){
        String str1 = "elapant";
        String str2 = "ELEPANT";  //定义两个字符串
        String str3 = "Apple";
        String str4 = "apple";
        /***1、compareTo方法***/
        //不忽略字符串字符大小写
        if(str1.compareTo(str2)>0){
            System.out.println(str1+">"+str2);
        }else if(str1.compareTo(str2) == 0){
            System.out.println(str1+"="+str2);
        }else{
            System.out.println(str1+"="+str2);
        }
        /***2、compareToIgnoreCase()方法***/
        //忽略字符串字符大小写
        if(str1.compareToIgnoreCase(str2)>0){
            System.out.println(str1+">"+str2);
        }else if(str1.compareToIgnoreCase(str2) == 0){
            System.out.println(str1+"="+str2);
        }else{
            System.out.println(str1+"<"+str2);
        }
        /***3、equals()方法***/
        //不忽略字符串字符大小写
        if(str3.equals(str4)){
            System.out.println(str3+"="+str4);
        }else{
            System.out.println(str3+"!="+str4);
        }
        /***4、equalsIgnoreCase()方法***/
        //忽略字符串字符大小写
        if(str3.equalsIgnoreCase(str4)){
            System.out.println(str3+"="+str4);
        }else{
            System.out.println(str3+"!="+str4);
        }
    }
}

运行结果如下：

 三、字符串与其他数据类型的转换

  有时候我们需要在字符串与其他数据类型之间做一个转换，例如将字符串数据变为整形数据，或者反过来将整形数据变为字符串类型数据，"20"是字符串，20就是整形数。我们都知道整形和浮点型之间可以利用强制类型转换和自动类型转换两种机制实现两者之间的转换，那么"20"和20这两种属于不同类型的数据就需要用到String类提供的数据类型转换方法了。

   由于数据类型较多，因而转换使用的方法也比较多，在此我就用一个表格罗列一下：

数据类型	字符串转换为其他数据类型的方法	其它数据类型转换为字符串的方法1	其他数据类型转换为字符串的方法2
boolean	Boolean.getBoolean(str)	String.valueOf([boolean] b)	Boolean.toString([boolean] b)
int	Integer.parseInt(str)	String.valueOf([int] i)	Int.toString([int] i)
long	Long.parseLong(str)	String.valueOf([long] l)	Long.toString([long] l)
float	Float.parseFloat(str)	String.valueOf([float] f)	Float.toString([float] f)
double	double.parseFloat(str)	String.valueOf([double] d)	Double.toString([double] d)
byte	Byte.parseByte(str)	String.valueOf([byte] bt)	Byte.toString([byte] bt)
char	str.charAt(i)	String.valueOf([char] c)	Character.toString([char] c)

简单测试的小demo如下：

public class StringConvert {
    public static void main(String args[]){
        /***将字符串类型转换为其他数据类型***/
        boolean bool = Boolean.getBoolean("false"); //字符串类型转换为布尔类型
        int integer = Integer.parseInt("20");    //字符串类型转换为整形
        long LongInt = Long.parseLong("1024");   //字符串类型转换为长整形
        float f = Float.parseFloat("1.521");     //字符串类型转换为单精度浮点型
        double d = Double.parseDouble("1.52123");//字符串类型转换为双精度浮点型
        byte bt = Byte.parseByte("200");         //字符串类型转换为byte型
        char ch = "棋哥".charAt(0);
        /***将其他数据类型转换为字符串类型方法1***/
        String strb1 = String.valueOf(bool);    //将布尔类型转换为字符串类型
        String stri1 = String.valueOf(integer); //将整形转换为字符串类型
        String strl1 = String.valueOf(LongInt); //将长整型转换为字符串类型
        String strf1 = String.valueOf(f);       //将单精度浮点型转换为字符串类型
        String strd1 = String.valueOf(d);       //将double类型转换为字符串类型
        String strbt1 = String.valueOf(bt);     //将byte转换为字符串类型
        String strch1 = String.valueOf(ch);     //将字符型转换为字符串类型
    }
}

 整理完三个方法我觉得需要来个中场休息，比如。。。放张图片舒服一下。。。

 程序员牛逼！！！

 然后继续整理后面的三个方法。。。

 四、字符串查找

 我们有时候需要在一段很长的字符串中查找我们需要的其中一部分字符串或者某个字符，String类恰恰提供了相应的查找方法，这些方法返回的都是目标查找对象在字符串中的索引值，所以都是整形值。具体分类情况如下：

 字符串查找无非分为两类：查找字符串和查找单个字符，而查找又可分为查找对象在字符串中第一次出现的位置和最后一次出现的位置，再扩展一步，我们可以缩小查找范围，在指定范围之内查找其第一次或最后一次出现的位置。

  （1）查找字符出现的位置

           1、indexOf()方法

                格式：1、str.indexOf(ch);

                          2、str.indexOf(ch,fromIndex); //包含fromIndex位置

                格式1返回指定字符在字符串中第一次出现位置的索引  

                格式2返回指定索引位置之后第一次出现该字符的索引号

           2、lastIndexOf()方法

                格式：1、str.lastIndexOf(ch);

                          2、str.lastIndexOf(ch,fromIndex);

                格式1返回指定字符在字符串中最后一次出现位置的索引

                格式2返回指定索引位置之前最后一次出现该字符的索引号

   (2)   查找字符串出现的位置

          1、indexOf()方法  

               格式：1、str.indexOf(str);

                         2、str.indexOf(str,fromIndex);

               格式1返回指定子字符串在字符串中第一次出现位置的索引

               格式2返回指定索引位置之前第一次出现该子字符串的索引号

           2、lastIndexOf()方法

                格式：1、str.lastIndexOf(str);

                          2、str.lastIndexOf(str,fromIndex); 

                格式1返回指定子字符串在字符串中最后一次出现位置的索引

                格式2返回指定索引位置之前最后一次出现该子字符串的索引号

看代码：

//字符与字符串查找
public class StringSearchChar {
    public static void main(String args[]){
        String str = "How qi bocome handsome like qi ge"; //定义一个长字符串
        System.out.println("该字符串为："+str);
        /***1、indexOf()方法查找字符首个出现位置格式1,2***/
        int index1 = str.indexOf(" ");  //找到第一个空格所在的索引
        int index2 = str.indexOf(" ",4); //找到索引4以后的第一个空格所在索引
        System.out.println("第一个空格所在索引为："+index1);
        System.out.println("索引4以后的第一个空格所在索引为："+index2);
        System.out.println("*****************");
        /***2、lastIndexOf()方法查找字符最后出现位置格式1,2***/
        int index3 = str.lastIndexOf(" ");  //找到最后一个空格所在的索引
        int index4 = str.lastIndexOf(" ",10);//找到索引10以后的第一个空格所在索引
        System.out.println("最后一个空格所在索引为："+index3);
        System.out.println("索引10以前最后一个空格所在索引为："+index4);
        System.out.println("*****************");
        /***3、indexOf()方法查找子字符串第一次出现位置格式1,2***/
        int index5 = str.indexOf("qi"); //找到"qi"子字符串第一次出现位置的索引
        int index6 = str.indexOf("qi",5);//找到索引5以后子字符串"qi"第一个出现位置所在索引
        System.out.println("子字符串qi第一次出现位置的索引号为："+index5);
        System.out.println("索引5以后子字符串qi第一次出现位置的索引号为："+index6);
        System.out.println("*****************");
        /***4、lastIndexOf()方法查找子字符串最后一次出现位置格式1,2***/
        int index7 = str.lastIndexOf("qi");
        int index8 = str.lastIndexOf("qi",5);
        System.out.println("子字符串qi最后一次出现位置的索引号为："+index7);
        System.out.println("索引号5以后子字符串qi最后一次出现位置的索引号为："+index8);
    }
}

结果截图如下：

 五、截取与拆分

 这类方法是截取出一个长字符串中的一个子字符串或将字符串按照正则表达式的要求全部拆分保存到一个字符串数组中。具体方法如下所示：

 (1) 截取方法

      1、substring()方法    

            格式1：String result = str.substring(index)；

            格式2：String result = str.substring(beginIndex,EndIndex)；//实际索引号[beginIndex,EndIndex-1]

            结果：截取出范围内的字符串

（2）拆分方法

       1、split()方法

            格式1 ：String strArray[] = str.split(正则表达式);// 拆分的结果保存到字符串数组中

            格式2：String strArray[] = str.split(正则表达式，limit);

代码示例如下：

//字符串截取与拆分
public class StringCutAndSplit {
    public static void main(String args[]){
        String str = "How to cut and split strings"; //定义字符串
        System.out.println("字符串为："+str);
        int length = str.length(); //获取字符串长度，保存到变量中
        System.out.println("字符串长度为："+length);
        /***1、substring()方法截取出第一个单词和最后一个单词***/
        //首先配合indexOf()和lastIndexOf()方法找到第一个单词和最后一个单词前后空格的索引号
        //第一个单词的左范围索引为0，最后一个单词的右范围索引为length-1
        int firstIndex = str.indexOf(' '); //找到第一个空格所在位置
        int lastIndex = str.lastIndexOf(' '); //找到最后一个空格所在位置
        System.out.println("第一个空格的索引号为："+firstIndex);
        System.out.println("最后一个空格的索引号为："+lastIndex);
        //利用substring()方法根据第一个和最后一个单词的索引范围截取出第一个和最后一个单词
        String firstWord = str.substring(0,firstIndex); //截取出第一个单词
        String lastWord = str.substring(lastIndex+1,length);//截取出最后一个单词
        System.out.println("第一个单词为："+firstWord);
        System.out.println("最后一个单词为："+lastWord);
        /***1、split()方法拆分出所有单词***/
        String stringArray[] = str.split(" ");  //根据空格要求拆分出所有单词保存到字符串数组中
        System.out.println("拆分之后的各个词汇为："); //输出提示信息
        for(int i = 0;i<stringArray.length;i++){
            System.out.print(stringArray[i]+"\t");
        }
    }
}

代码执行结果如下：

六、替换或修改

终于到最后一类方法了，开心！！有时候我们需要对原字符串中的某些子字符串进行替换或修改，此时也需要String类提供的一些简单快捷好用的方法啦

（1）concat()方法合并字符串

         格式：String result = str1.concat(str2);   //将str1和str2合并

  (2)  toLowerCase()方法 将字符全部转化为小写

         格式:  String result = str.toLowerCase();

  (3)  toUpperCase()方法 将字符全部转化为大写

         格式：String result = str.toUpperCase();          

  (4)replaceAll()、replaceFirst()方法：需要匹配正则表达式         

代码如下：

//字符串替换与修改
public class StringFindandReplace {
    public static void main(String args[]){
        String str1 = "vbasic";
        String str2 = "Vbasic";
        System.out.println("str1 = "+str1);
        System.out.println("str2 = "+str2);
        /***1、concat()方法将两字符串合并***/
        String str3 = str1.concat(str2);
        System.out.println("str1和str2合并后的字符串为："+str3);
        /***2、toLowerCase()方法将str1字符全部转换为小写***/
        String str4 = str1.toLowerCase();
        System.out.println("str1的字符全部转换为小写："+str4);
        /***3、toUpperCase()方法将str2字符全部转换为大写***/
        String str5 = str2.toUpperCase();
        System.out.println("str2的字符全部转换为大写："+str5);
        /***4、实现字符串的替换，原字符串内容不变***/
        String str6 = str1.replaceFirst("(?i)VBASIC","C++");
        String str7 = str2.replaceFirst("(?-i)VBASIC","C++");
        System.out.println("替换后的str1："+str6);
        System.out.println("替换后的str2:"+str7);
    }
}

代码运行结果截图：

结束语

       肝了两个晚上总算是把String类中的一些基本操作方法给整理完了，我觉得做一件事从一开始的激情到后来慢慢的潦草再到最后的坚持干完，努力追求进步的过程其实真的挺寂寞的，但是有什么办法呢？选择好的道路总会有开心与苦涩，坚持走下去吧，大不了用Java new()一个对象陪你一起走下去嘛，明天终于可以偷偷溜回家过五一啦，嘿嘿！！