substr 函数：截取字符串
	
语法：SUBSTR(string，start， [length])

string：表示源字符串，即要截取的字符串。

start：开始位置，从1开始查找。如果start是负数，则从string字符串末尾开始算起。

length：可选项，表示截取字符串长度。

示例：

SELECT SUBSTR('Hello SQL!', 1) FROM dual     --截取所有字符串，返回'Hello SQL!'
SELECT SUBSTR('Hello SQL!', 2) FROM dual     --从第2个字符开始，截取到末尾。返回'ello SQL!'
SELECT SUBSTR('Hello SQL!', -4) FROM dual    --从倒数第4个字符开始，截取到末尾。返回'SQL!'
SELECT SUBSTR('Hello SQL!', 3, 6) FROM dual  --从第3个字符开始，截取6个字符。返回'llo SQ'
SELECT SUBSTR('Hello SQL!', -4, 3) FROM dual --从倒数第4个字符开始，截取3个字符。返回'SQL'


	
instr 函数：返回子字符串在源字符串中的位置
	
语法：INSTR(string，child_string，[start]，[show_time])

string：表示源字符串。

child_string：子字符串，即要查找的字符串。

start：可选项，开始位置，默认从1开始。如果为负数，则从右向左检索。

show_time：可选项，表示子字符串第几次出现在源字符串当中，默认第1次，负数则报错。

示例：

--表示从源字符串'city_company_staff'中第1个字符开始查找子字符串'_'第1次出现的位置
SELECT INSTR('city_company_staff', '_') FROM dual    --返回5

--表示从源字符串'city_company_staff'中第5个字符开始查找子字符串'_'第1次出现的位置
SELECT INSTR('city_company_staff', '_', 5) FROM dual    --返回5

--表示从源字符串'city_company_staff'中第5个字符开始查找子字符串'_'第1次出现的位置
SELECT INSTR('city_company_staff', '_', 5, 1) FROM dual    --返回5

--表示从源字符串'city_company_staff'中第3个字符开始查找子字符串'_'第2次出现的位置
SELECT INSTR('city_company_staff', '_', 3, 2) FROM dual    --返回13

--start参数为-1，从右向左检索，查找'_'字符串在源字符串中第1次出现的位置
SELECT INSTR('city_company_staff', '_', -1, 1) FROM dual    --返回13

--start参数为-6，从右向左检索，查找'_'字符串在源字符串中第2次出现的位置
SELECT INSTR('city_company_staff', '_', -6, 2) FROM dual    --返回5



	
substr 函数结合 instr 函数截取字符串
	
现有需求：数据查询处理需要对code进行"拆分"

code命名规则类似：城市_所属公司_员工职位_员工姓名

其中，城市、公司、职位、姓民字符串长度不固定，由于字符串长度不固定，只使用substr函数无法实现需求，需配合instr函数定位到字符'_'的位置，然后使用substr函数进行截取。详细见下面例子。

表数据如下：

SOURCE_CODE
		
BJ_BAIDU_CEO_LY
		
SH_BOKE_MANAGER_LWX
		
HRB_WM_CASHIER_OYZY
		
获取城市：

SELECT
	SUBSTR (SOURCE_CODE, 1, INSTR (SOURCE_CODE, '_', 1, 1) - 1) AS CITY
FROM
	TABLE_CODE_TEST

结果：



解释：此处截取源字符串SOURCE_CODE，从第1个字符开始，由于代表城市的code长度不固定，我们无法确定截取几个字符，所以使用instr函数判断第一个'_'字符的位置，进而确定每个SOURCE_CODE截取几个字符串。

那为什么减1呢？

是因为INSTR (SOURCE_CODE, '_', 1, 1)获取的是源字符串中'_'字符第一次出现的位置，再减1就得出了CITY字符个数。

获取公司：

SELECT
	SUBSTR (
		SOURCE_CODE, 
		INSTR (SOURCE_CODE, '_', 1, 1) + 1, 
		INSTR (SOURCE_CODE, '_', 1, 2) - INSTR (SOURCE_CODE, '_', 1, 1)-1
	) AS COMPANY
FROM
	TABLE_CODE_TEST

结果：



解释：截取源字符串，从（第一个'_'出现位置+1）开始，截取个数为：第2个'_'出现位置减去第1个'_'出现位置，此时还多了一个下划线'_'，再减去1即可得到代表公司字符串。

获取姓名：

SELECT
	SUBSTR (SOURCE_CODE, INSTR (SOURCE_CODE, '_', 1, 3) + 1) AS STF_NAME
FROM
	TABLE_CODE_TEST

结果：



解释：截取源字符串，从（'_'第3次出现位置+1）开始截取，截取到末尾。

 

示例：

       在源字符串“You may be out of my sight, but never out of my mind.”中查找“my”的个数。输出：匹配个数为2
三种方法：

       1.通过String的indexOf方法

       2. 通过正则表达式

       3. 通过String的split方法

其中第一种方法只能用于精确匹配，第二三种则可以模糊匹配（方法3的参数为正则表达式）。例如：若将child改为“.my.”，第一种方法失效。
方法1：通过String的indexOf方法
public int indexOf(int ch, int fromIndex) ：返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。如果不存在则返回 -1。
//方法1、通过String的indexOf(String str, int fromIndex)方法
	private void matchStringByIndexOf( String parent,String child )
	{
		int count = 0;
		int index = 0;
		while( ( index = parent.indexOf(child, index) ) != -1 )
		{
			index = index+child.length();
			count++;
		}
		System.out.println( "匹配个数为"+count );							  //结果输出
	}

方法2：通过正则表达式
类 Pattern ：正则表达式的编译表示形式。

       指定为字符串的正则表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建 Matcher 对象，依照正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一模式。

       因此，典型的调用顺序是

       Pattern p = Pattern.compile(“a*b”);

       Matcher m = p.matcher(“aaaaab”);

       boolean b = m.matches();
类 Matcher：通过调用模式的 matcher 方法从模式创建匹配器。创建匹配器后，可以使用它执行三种不同的匹配操作：

       matches 方法尝试将整个输入序列与该模式匹配。

       lookingAt 尝试将输入序列从头开始与该模式匹配。

       find 方法扫描输入序列以查找与该模式匹配的下一个子序列
//方法2、通过正则表达式
	private void matchStringByRegularExpression( String parent,String child )
	{
		
		int count = 0;
		Pattern p = Pattern.compile( child );
		Matcher m = p.matcher(parent);
		while( m.find() )
		{
			count++;
			System.out.println( "匹配项" + count+"：" + m.group() ); //group方法返回由以前匹配操作所匹配的输入子序列。
		}
		System.out.println( "匹配个数为"+count );							  //结果输出
	}

方法3：通过String的split方法
public String[] split(String regex)：根据给定正则表达式的匹配拆分此字符串。 该方法的作用就像是使用给定的表达式和限制参数 0 来调用两参数 split 方法。因此，所得数组中不包括结尾空字符串。
//方法3、通过split方法
	private void matchStringBySplit( String parent,String child )
	{
		String[] array = parent.split(child);
		System.out.println( "匹配个数为" + (array.length-1) );
	}

完整代码：
import java.util.Arrays;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 在字符串中查找匹配的子字符串
 * author：大能豆   QQ：1023507448
 * case ：
 * 源字符串：You may be out of my sight, but never out of my mind.
 * 要查找的子字符串：my
 * 输出：匹配个数为2
 */
public class MatchString {

    //方法1、通过String的indexOf(String str, int fromIndex)方法
    private void matchStringByIndexOf(String parent, String child) {
        int count = 0;
        int index = 0;
        while ((index = parent.indexOf(child, index)) != -1) {
            index = index + child.length();
            count++;
        }
        System.out.println("匹配个数为" + count);//结果输出
    }

    //方法2、通过正则表达式
    private void matchStringByRegularExpression(String parent, String child) {
        int count = 0;
        Pattern p = Pattern.compile(child);
        Matcher m = p.matcher(parent);
        while (m.find()) {
            count++;
            System.out.println("匹配项" + count + "：" + m.group()); //group方法返回由以前匹配操作所匹配的输入子序列。
        }
        System.out.println("匹配个数为" + count); //结果输出
    }

    //方法3、通过split方法，但此方法需考虑子字符串是否是在末尾，若在末尾则不需要-1
    private void matchStringBySplit(String parent, String child) {
        String[] array = parent.split(child);
        System.out.println("匹配个数为" + (array.length - 1));
    }

    public static void main(String[] args) {
        MatchString ms = new MatchString();
        String parent = "You may be out of my sight, but never out of my mind.";
        String child = "my";

        System.out.println("------通过indexOf-------");
        ms.matchStringByIndexOf(parent, child);  //调用方法1

        System.out.println("------通过正则表达式-------");
        ms.matchStringByRegularExpression(parent, child);  //调用方法2

        System.out.println("------通过split方法-------");
        ms.matchStringBySplit(parent, child);  //调用方法3

        String test = "abcdbdasda";
        String[] as = test.split("a");
        System.out.println(Arrays.toString(as));
    }

}

python中的strip()可以去除头尾指定字符

ss = '我的电话是18827038663，也是微信号，\n 请加入，谢谢\n\n\n'
print(ss.strip('\n'))

结果：

我的电话是18827038663，也是微信号，
 请加入，谢谢

可以看到只能删除头尾指定字符。

想要去除中间字符，可以使用replace()函数

ss = '我的电话是18827038663，也是微信号，\n 请加入，谢谢\n\n\n'
print(ss.replace('\n', ''))

结果：

我的电话是18827038663，也是微信号， 请加入，谢谢

note:

1. strip(str)

基本用法：ss.strip(rmStr)

ss.strip()参数为空时，默认去除ss字符串中头尾\r, \t, \n, 空格等字符；参数为某个字符时，可以去掉头尾指定字符噢，例如：

输入：

ss = '我的电话是18827038663，也是微信号，请加入，谢谢啦啦嗯'
print(ss.strip('嗯啦'))

运行结果：

我的电话是18827038663，也是微信号，请加入，谢谢

需要注意strip是按字符级别匹配的，只要头尾出现字符集中的字符，就会被strip掉，而不是整段字符匹配的。

ss.lstrip()删除ss字符串开头处的指定字符，ss.rstrip()删除ss结尾处的指定字符

2. replace(old, new[, max])

基本用法：ss.replace(old, new[, max])

old是原字符串中的字符，new是需要替换为的新字符串，max是最大匹配次数，匹配时从左到右最多max次。一般情况下不设置max的值，默认全部替换。

输入：

ss = 'old old string'
ret = ss.replace('old', 'new', 1)
print(ret)

输出：

new old string

 

 

字符串截取:
1 取字符串的前i个字符
   str=str.substring(0,i);

2 去掉字符串的前i个字符
  str=str.substring(i); 

3 从右边开始取i个字符
  str=str.substring(str.length()-i); 
  str=str.substring(str.length()-i,str.length()); 

4 从右边开始去掉i个字符
  str=str.substring(0,str.Length-i);

5 如果字符串中有"abc"则替换成"ABC"
 str=str.replace("abc","ABC");

案例:
public class Test { 
    public static void main(String[] args) {
        String str = "abcde12345MNBVC*()&%";
        
        //截取字符串前5位
        String substring1= str.substring(0,5);
        
        //截掉字符串前5位
        String substring2 = str.substring(5);
        
        //截取字符串后5位
        String substring3 = str.substring(str.length()-5);
        String substring4 = str.substring(str.length()-5,str.length());
        
        //截掉字符串后5位
        String substring5 = str.substring(0,str.length()-5);
        
         //截去字符串从第6位到第9位的字符串(从0 开始)
       	String substring6 = str.substring(6,10);
		
		//将字符串abcde 替换成ABCDE
        String string6 =str.replace("abcde","ABCDE");
        
        System.out.println(substring1);
        System.out.println(substring2);
        System.out.println(substring3);
        System.out.println(substring4);
        System.out.println(substring5);
        System.out.println(substring6);
        System.out.println(string6);
        
    }
}


结果:
abcde
12345MNBVC*()&%
*()&%
*()&%
abcde12345MNBVC
2345
ABCDE12345MNBVC*()&%


总结:




字符串
语法




截掉前 i 个字符串
str.substring(i)


截取从 i 到 j 个字符串(字符串从0开始数, 包括 i 不包括 j )
str.substring(i,j)