Java，JavaScript、Oracle字符串常用操作对照

JAVA

/**
 * @Description:返回一个新的字符串，它是此字符串的一个子字符串。
 *              该子字符串从指定索引处的字符开始，直到此字符串末尾。
 * @param beginIndex - 起始索引（包括）。
 * @return 返回截取的子字符串
 * @exception IndexOutOfBoundsException - 如果 beginIndex 为负或大于此 String 对象的长度。
 */
public String substring(int beginIndex);

"abcde".substring(1); //bcde
"abcde".substring(-1);//java.lang.StringIndexOutOfBoundsException
"abcde".substring(6); //java.lang.StringIndexOutOfBoundsException

/**
 * @Description:返回一个新字符串，它是此字符串的一个子字符串。
 *              该子字符串从指定的 beginIndex 处开始，直到索引 endIndex - 1 处的字符。
 *              因此，该子字符串的长度为 endIndex-beginIndex。
 * @param beginIndex - 起始索引（包括）。
 * @param endIndex - 结束索引（不包括）。
 * @return 返回截取的子字符串
 * @exception IndexOutOfBoundsException - 如果 beginIndex 为负，
 *            或 endIndex 大于此 String 对象的长度，或 beginIndex 大于 endIndex。
 */
public String substring(int beginIndex, int endIndex);

"abcde".substring(0,2); //ab
"abcde".substring(0,5); //abcde 
"abcde".substring(-1,2);//IndexOutOfBoundsException
"abcde".substring(0,6); //IndexOutOfBoundsException
"abcde".substring(4,1); //IndexOutOfBoundsException

/**
 * @Description:返回指定子字符串在此字符串中第一次出现处的索引
 * @param str - 任意字符串。
 * @return 如果字符串参数作为一个子字符串在此对象中出现，则返回第一个这种子字符串的第一个字符的索引；
 *         如果它不作为一个子字符串出现，则返回 -1。
 */
public abstract int indexOf(String str);

"abcde".indexOf("bc"); //1
"abcde".indexOf("xy"); //-1
"abcde".indexOf("a"); //0
"abcde".indexOf(""); //0  将最左边的空字符串 "" 视为出现在索引值0处。-参见startWith()

/**
 * @Description:返回指定子字符串在此字符串中最右边出现处的索引。
 *              将最右边的空字符串 "" 视为出现在索引值 this.length() 处。
 * @param str - 要搜索的子字符串。
 * @return 如果字符串参数作为一个子字符串在此对象中出现一次或多次，则返回最后一个这种子字符串的第一个字符。
 *         如果它不作为一个子字符串出现，则返回 -1。
 */
public abstract int lastIndexOf(String str);

"abcdeb".lastIndexOf("b"); //5
"abcde".lastIndexOf("xy"); //-1
"abcde".lastIndexOf(""); //5  -参见startWith()

/**
 * @Description:测试此字符串是否以指定的前缀开始。
 * @param prefix - 前缀。
 * @return 如果参数表示的字符序列是此字符串表示的字符序列的前缀，则返回 true；否则返回 false。
 *         还要注意，如果参数是空字符串，或者等于此 String 对象（用 equals(Object) 方法确定），则返回 true。
 */
public boolean startsWith(String prefix);

"abcde".startsWith("a"); //true
"abcde".startsWith("");  //true
"abcde".startsWith("b"); //fasle

/**
 * @Description:测试此字符串从指定索引开始的子字符串是否以指定前缀开始。
 * @param prefix - 前缀。
 * @param toffset - 在此字符串中开始查找的位置。
 * @return 如果参数表示的字符序列是此对象从索引 toffset 处开始的子字符串前缀，则返回 true；否则返回 false。
 *         如果 toffset 为负或大于此 String 对象的长度，则结果为 false；否则结果与以下表达式的结果相同：
 *         this.substring(toffset).startsWith(prefix)
 */
public boolean startsWith(String prefix, int toffset);

"abcde".startsWith("b", 1); //true
"abcde".startsWith("b", 0); //false
"abcde".startsWith("b", 6); //false --toffset 大于此 String 对象的长度
"abcde".startsWith("b", -1); //false --toffset 为负

JavaScript

/**
 * @Description:用于提取字符串中介于两个指定下标之间的字符。
 * @param startIndex - 起始索引（包括）。
 * @param endIndex - 结束索引（不包括），可选，省略该参数，那么返回的子串会一直到字符串的结尾。
 * @return 返回截取的子字符串
 */
stringObject.substring(startIndex [,endIndex]);

"abcde".substring(1) //bcde
"abcde".substring(5) //"" --start超出下标最大值，为""
"abcde".substring(-1) //abcde --start为负数，则从index=0开始截取
"abcde".str.substring(-9,2) //ab --start为负数，则从index=0开始截取
"abcde".substring(0,9) //abcde --下标截取范围包含实际下标
"abcde".substring(-1,9) //abcde --下标截取范围包含实际下标

/**
 * @Description:从起始索引号提取字符串中指定数目的字符。
 * @param startIndex - 起始索引（包括）。如果是负数，那么该参数声明从字符串的尾部开始算起的位置。
 *                     也就是说，-1 指字符串中最后一个字符
 * @param length - 子串中的字符数，可选，省略该参数，那么返回的子串会一直到字符串的结尾。
 * @return 返回截取的子字符串
 */
stringObject.substr(startIndex [,length])
"abcde".substr(1) //bcde
"abcde".substr(-1) //e
"abcde".substr(-9) //abcde start负值+len < 0，则从index=0开始截取
"abcde".substr(-9,3) //abc start负值+len < 0，则从index=0开始截取
"abcde".substr(1, -1) //""
"abcde".substr(-5,3) //abc

Oracle

/*  
 * @Description:截取字符串
 * @param string 源字符串  
 * @param position 检索位置(字符串位置从1开始，而不是从0开始)，
 *                 参数为正时，从左向右检索，参数为负时，从右向左检索 。 
 * @param length 要截取的长度，可选(缺省从position位开始截取至字符串结尾),
 *                         值小于1时返回空字符串  
 * @return 返回截取的字符串  
 */  
substr(string, position [,length]);  

SELECT SUBSTR('abcde', 1) FROM DUAL; --abcde
SELECT SUBSTR('abcde', 0) FROM DUAL; --abcde //0等同于1
SELECT SUBSTR('abcde', -2) FROM DUAL; --de
SELECT SUBSTR('abcde', 6) FROM DUAL; --"" //超出位置上限
SELECT SUBSTR('abcde', 4, 4) FROM DUAL; --de 
SELECT SUBSTR('abcde', -4, 3) FROM DUAL; --bcd
SELECT SUBSTR('abcde', 4, -1) FROM DUAL; --"" // length<0,放回空字符串

/*  
 * @Description:返回子字符串在源字符串中的位置(字符串位置从1开始，而不是从0开始)  
 * @param string 源字符串  
 * @param substring 目标字符串  
 * @param position 检索位置，可选(默认为1),值为正时，从左向右检索，值为负时，从右向左检索  
 * @param occurrence 检索目标字符串出现的次数，可选(默认为1),值只能为正整数，否则会报错  
 * @return 返回子字符串在源字符串中出现的位置（没找到返回0）  
 */  
instr(string, substring [,position [,occurrence]]);  

SELECT INSTR('abcde', 'a') FROM DUAL; --1
SELECT INSTR('abcde', 'f') FROM DUAL; --0 //查找不到返回0 
SELECT INSTR('abcde', 'a', 1) FROM DUAL; --1 //从位置1开始查找a (缺省默认)
SELECT INSTR('abcde', 'a', 2) FROM DUAL; --0 //从位置2开始查找a
SELECT INSTR('abcdea', 'a', 2, 1) FROM DUAL; --6 //从位置2开始查找a第一次出现的位置
SELECT INSTR('abcde', 'a', -3, 1) FROM DUAL; --1 //从倒数第三个位置倒序查找a第一次出现的位置
SELECT INSTR('abcde', 'e', -3, 1) FROM DUAL; --0 //从倒数第三个位置倒序查找e第一次出现的位置

--SUBSTR和INSTR结合使用
--<1> 截取日期“2018-05-10”中的年份
SELECT SUBSTR('2018-05-10', 1, INSTR('2018-05-10', '-')-1) FROM DUAL;  
--结果：2018
--<2> 截取日期“2018-05-10”中的月份                                
SELECT SUBSTR('2018-05-10', INSTR('2018-05-10', '-')+1, 
              INSTR('2018-05-10', '-', 1, 2) - INSTR('2018-05-10', '-')-1) FROM DUAL;  
--结果：05  
--<3> 截取日期“2018-05-10”中的日份                                
SELECT SUBSTR('2018-05-10', INSTR('2018-05-10', '-', 1, 2)+1) FROM DUAL;  
--结果：10