看java——String类操作字符串

最新推荐文章于 2023-03-26 20:06:56 发布

恪愚

最新推荐文章于 2023-03-26 20:06:56 发布

阅读量348

点赞数 2

分类专栏： java入门与进阶 # java-码出高效文章标签： java

本文链接：https://blog.csdn.net/qq_43624878/article/details/88898825

版权

java入门与进阶同时被 2 个专栏收录

12 篇文章 0 订阅

订阅专栏

java-码出高效

8 篇文章 0 订阅

订阅专栏

前言：

先说一下面向过程与oop的区别吧：
拿c、c++、java来说，C/c++语言仅仅提供了字符串类型的一个构造，相当于只给了开发者基本材料，让开发者自行去用材料造轮子;而Java给字符串提供了许多的可用方法，调用这些方法可以在一定程度上加快程序的开发效率，这也就相当于Java已经给开发人员提供好了轮子，只要用轮子去造车子便可，这大概就是面向对象思想与面向过程思想的其中一个区别吧。

提醒：关于字符串的操作方法我们是不需要像其他操作一样手动导包的，其String和StringBuffer等类封装在java.lang包中，可直接调用字符串方法！

问题导入

今天看到一题，问：String类的操作特点。
。。。直接懵逼。
翻阅了资料，还动用了某度，猜得到答案：String的设计是一个典型的单一模式

String str1="AAAA"；
String str2="AAAA"；

这是生成两个对象吗？
不是。在内存中，这是同一个对象
所以
if(str1==str2){} 的结果应该是 true
如果要生成不同的对象，就必须

String str1=new String("AAAA")；
String str2=new String("AAAA")；

if(str1==str2){} 的结果应该是 false
用第一种做法虽然变量名变来变去，但内存中对象仍只有一个，这种方法可以有效地节省内存空间和提高运行效率。
由于String具有不变的性质。所以对一长串String中的每一个字符进行操作是比较浪费时间的，对String进行加减删除替换等工作比较耗时，所以后来Sun又推出来StringBuffer方法来做这些事情。
StringBuffer类似于一个char[],
所以对数组无素做遍历，删除，增加，修改，查找等工作是比较快速的，完成后再把StringBuffer可以转化成String
例：

String a="请输入帐号:";
String b="NNNN";
String c="请输入密码:";
String d="XXXX";
............

一般的做法 String result=a+b+c+d;
结果是正确的，但不是高效的代码！
改良的做法:

StringBuffer buffer=new StringBuffer();
buffer.append(a);
buffer.append(b);
buffer.append(c);
buffer.append(d);
String result=buffer.toString();

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编码是默认字符集编码，它是用编码表示的字符。

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

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);

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类提供的数据类型转换方法了。

切记一点：其他类型变为String型，格式：基型+""（空字符串（不是null））
如：

int num=100;
String str=num+"";
System.out.print(str+9);      //1
System.out.print(num+9);      //2

程序输出结果：1:1009；2:109
why？
因为任何基本类型与字符串使用“+”后都要变成字符串。

字符串查找

我们有时候需要在一段很长的字符串中查找我们需要的其中一部分字符串或者某个字符，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);
    }
}

替换、修改和查找

有时候我们需要对原字符串中的某些子字符串进行替换或修改，此时也需要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);
    }
}

这里就相当于给我自己，还有大家做了一个摘要吧，能够在忘时尽快找到（我基本上都快忘完了。。。），不过，熟练的话还需多敲。。。（无奈）

恪愚

关注

2
点赞
踩
5

收藏

觉得还不错? 一键收藏
打赏
1
评论
看java——String类操作字符串

前言：先说一下面向过程与oop的区别吧：拿c、c++、java来说，C/c++语言仅仅提供了字符串类型的一个构造，相当于只给了开发者基本材料，让开发者自行去用材料造轮子;而Java给字符串提供了许多的可用方法，调用这些方法可以在一定程度上加快程序的开发效率，这也就相当于Java已经给开发人员提供好了轮子，只要用轮子去造车子便可，这大概就是面向对象思想与面向过程思想的其中一个区别吧。提醒：关于...
复制链接

扫一扫