Java中利用String类进行文本处理

最新推荐文章于 2021-11-06 22:53:03 发布

BiggerLee

最新推荐文章于 2021-11-06 22:53:03 发布

阅读量1.6k

点赞数 2

分类专栏： Java基础

本文链接：https://blog.csdn.net/lixingtao0520/article/details/78128656

版权

Java基础专栏收录该内容

14 篇文章 1 订阅

订阅专栏

最近对文本字符串处理比较多，现总结下String处理字符串的方法，以及Java是如何利用String类的方法进行文本处理的。

1、读取文本内容到字符串。

StringBuffer codeBuffer = new StringBuffer();
//存放文本内容的文件地址
String filePath = "xxxx";
//打开文件
BufferedReader conFile = null;
try {
conFile = new BufferedReader(new InputStreamReader(
new FileInputStream(filePath), "gbk"));
} catch (FileNotFoundException e) {
throw new RuntimeException("未发现此文件位置");
}
String hasread = null;
while((hasread = conFile.readLine()) != null) {
codeBuffer.append(hasread);
}
conFile.close();

String code = codeBuffer.toString();

2、replaceAll(String regex，String replacement)方法，将符合正则表达式regex的字符串均用replacement替换。例如处理文本时，因为空格符的随意性，有时候会对文本字符串处理带来困难。此时，就可以将多个空格转化为一个空格，方便处理：

//replaceAll的第一个参数为正则表达式，\s表示：匹配任何不可见字符，包括空格、制表符、换页符等等
str=str.replaceAll("\\s+"," ");

3、split(String regex)方法。split方法根据正则表达式regex分隔目标字符串。处理文本时，可以先将文本字符串中多个空格替换为单个空格，之后对文本字符串进行split(" ")，得到字符串数组。文本字符串转化为字符串数组后，好处是可以对文本中的词组进行准确定位。

//split方法的参数为正则表达式。
对于split方法注意一下几点：
如果用“.”作为分隔的话,必须是String.split("\\.")；
如果用“|”作为分隔的话,必须是String.split("\\|")；
因为"."和"|"是转义字符，必须加"\\"
String strArray = str.split(" ");

举例：利用字符串处理SQL语句。输出SQL中用到的表

package com.xtli.controller.String;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
/*
 * String处理SQL语句 by xtli
 */
public class getTableInSQL {
     public static void main(String[] args) throws IOException {
          
          StringBuffer SQLBuffer = new StringBuffer();
          String filePath = "D:\\SQL.txt";
          //打开文件
          BufferedReader  SQLFile = null;
          try {
              SQLFile = new BufferedReader(new InputStreamReader(
                        new FileInputStream(filePath), "utf8"));
          } catch (FileNotFoundException e) {
              throw new RuntimeException("未发现此文件位置");
          }
          String hasread = null;
          while((hasread = SQLFile.readLine()) != null) {
              SQLBuffer.append(hasread);        
          }
          SQLFile.close();         
          String SQL = SQLBuffer.toString();    
          List<String> tableList = new ArrayList<String>();
          //替换多个空格
          SQL=SQL.replaceAll("\\s+"," ");
          String[] SQLArr = SQL.split(" ");
          
          for(int i = 1; i < SQLArr.length; i++) {
              String tableStr = SQLArr[i-1];
              if("FROM".equals(tableStr.toUpperCase()) || "JOIN".equals(tableStr.toUpperCase())) {
                   tableList.add(SQLArr[i]);
              }
          }          
          for(String table: tableList) {
              System.out.println(table);
          }        
     }
}

SQL.txt内容为：

select * from tableA a
left join tableB b
on a.id = b.aid
left join tableC c
on b.id = c.bid

输出以下结果：

tableA
tableB
tableC

4、substring()方法。String提供了两个substring重载方法。

方法	返回值
substring(beginIndex, endIndex)	截取beginIndex至endIndex-1之间的字符串，返回新字符串
substring(beginIndex)	截取beginIndex至目标字符串末尾的字符串，返回新字符串

String没有提供delete方法，可以使用subString方法自定义实现删除。

//删除str中位置从startIndex到endIndex的字符串，返回删除后的新串
public static String deleteStr(int startIndex, int endIndex, String str) {
          String deletedStrBefore = str.substring(0, startIndex);
          String deleteStrAfter = str.substring(endIndex+1, str.length());
        return deletedStrBefore + deleteStrAfter;
 }

5、indexOf方法。

String提供了四个indexOf重载方法，如下。

方法	返回值
indexOf(String str)	str 字符串在目标字符串中第一次出现的位置
indexOf(String str, int fromIndex)	str字符串从fromIndex位置开始，第一次出现的位置
indexOf(int ch)	ch字符在目标字符串中第一次出现的位置
indexOf(int ch, int fromIndex)	ch字符从fromIndex位置开始，第一次出现的位置

举例：获取文本字符串中第一次引号和第二次引号之间的字符串。

/*
* 返回第一次引号和第二次引号之间的内容
*/
public static void main(String[] args) {
   String str = "小明说,\"我放学回家了。\"";
   //1 双引号第一次出现的位置
   int leftQuota = str.indexOf("\"");
   //2 双引号第二次出现的位置,与第一次引号匹配
   int rightQuota = str.indexOf("\"", leftQuota + 1);
   String talkContext = str.substring(leftQuota + 1, rightQuota);
   System.out.println(talkContext);
}

执行结果

我放学回家了。

除了indexOf方法外，String还提供了lastIndexOf方法，同样有四个重载方法

方法	返回值
lastIndexOf(String str)	str 字符串在目标字符串中最后一次出现的位置
lastIndexOf(String str, int fromIndex)	str字符串在（0，fromIndex）之间，最后一次出现的位置
lastIndexOf(int ch)	ch字符在目标字符串中最后一次出现的位置
lastIndexOf(int ch, int fromIndex)	ch字符在（0，fromIndex）之间，最后一次出现的位置

/*
* 返回第一次引号和第二次引号之间的内容
*/
public static void main(String[] args) {
     String str = "小明说,\"我放学回家了。\"";
     int rightQuota = str.lastIndexOf("\"");
     int leftQuota = str.lastIndexOf("\"", rightQuota-1);
          
     String talkContext = str.substring(leftQuota + 1,rightQuota);
     System.out.println(talkContext);
}

返回和上例同样的结果。

6、charAt(int index)方法，返回指定index位置的字符值，用于判断指定位置的字符。startsWith(String prefix) 方法，判断目标字符串是否以prefix为前缀，用于字符串前缀判断。

7、利用栈，获取指定一对字符之间的文本。栈是一种先进后出的线性存储结构，Java提供了Stack类描述此种数据结构。有时候处理文本时，可能需要获取某对字符之间的内容，就可以利用Stack来处理。

举例：如果现在要求得到如下方法中的代码，该怎么做呢？

public static void main(String[] args) {
          try {
              String str = "小明说,\"我放学回家了。\"";
              int rightQuota = str.lastIndexOf("\"");
              int leftQuota = str.lastIndexOf("\"", rightQuota - 1);
              String talkContext = str.substring(leftQuota + 1,rightQuota);
              System.out.println(talkContext);
          } catch(Exception e) {
              System.out.println("异常啦");
          }
     }

通过分析此段代码，发现只要获取第一个“{”和最后一个“}”中的文本即可，因为代码中的“{”和“}”均是成对出现的，所以我们用栈来解决此问题。代码如下：

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Stack;
/*
 * 获取"{"和"}"之间的文本 by xtli
 */
public class StackTest {
     
     public static void main(String[] args) throws IOException {
          StringBuffer codeBuffer = new StringBuffer();
          String filePath = "D:\\javaCode.txt";//此文件存放代码内容
          //打开文件
          BufferedReader  conFile = null;
          try {
              conFile = new BufferedReader(new InputStreamReader(
                        new FileInputStream(filePath), "gbk"));
          } catch (FileNotFoundException e) {
              throw new RuntimeException("未发现此文件位置");
          }
          String hasread = null;
          while((hasread = conFile.readLine()) != null) {
              codeBuffer.append(hasread);       
          }
          conFile.close();
          
          String code = codeBuffer.toString();
          System.out.println(getMethodStr(code));
     }
     
     /*
      * 获取给定字符串中第一对‘{’中的内容
      */
     public static String getMethodStr(String contextMethStr){
          //获取第一个'{'的位置
          int firstLeftBracket = contextMethStr.indexOf('{');
          // 获取和第一个‘{’匹配的‘}’的位置
          int firstRightBracket = getMarriedRightBracket(contextMethStr, firstLeftBracket);
          // 截取"{"与"}"之间的字符串,并根据","生成字符串数组
          if (firstRightBracket == -1 || firstRightBracket <= firstLeftBracket) {
              return null;
          }
          return contextMethStr.substring(firstLeftBracket+1, firstRightBracket);
     }
     
     /*
      * 获取str中，和"{"位置匹配的第一个“}”
      */
     public static int getMarriedRightBracket(String str, int leftBracket) {
          int rightBrackerIndex= -1;
                   
          if('{' != str.charAt(leftBracket)) {//leftBracket的位置不是“{”
              return -1;
          }
          //存储"{""}"的栈
          Stack<Character> bracketStack = new Stack<Character>();
          // 1 将第一个"{"推入栈中
          bracketStack.push(str.charAt(leftBracket));
          char[] strChar = str.toCharArray();
          // 2 循环判断strChar,如果是"{"则入栈，如果是"}"则出栈，当栈空时，证明已找到匹配的"}"
          for(int i = leftBracket + 1; i < strChar.length; i++) {
              if('{' == str.charAt(i)) {
                   bracketStack.push(str.charAt(i));
              }
              if('}' == str.charAt(i)) {
                   bracketStack.pop();
                   if (bracketStack.isEmpty()) {
                        rightBrackerIndex = i;
                        break;
                   }
              }
          }
          // 3 栈空，则说明找到与"{"配对的"}",否则未找到
          if (bracketStack.isEmpty()) {
              return rightBrackerIndex;
          } else {
              return -1;
          }
     }
}

执行后，返回如下结果

try {
              String str = "小明说,\"我放学回家了。\"";
              int rightQuota = str.lastIndexOf("\"");
              int leftQuota = str.lastIndexOf("\"", rightQuota - 1);
              String talkContext = str.substring(leftQuota + 1,rightQuota);
              System.out.println(talkContext);
          } catch(Exception e) {
              System.out.println("异常啦");
          }

未完待续。。。