在我们日常工作中经常遇到截取字符串的需求，这里重点介绍两种常见的截取字符串方法。

方法一：通过split()

此方法返回的是一个字符串数组类型。

1.只传一个参数：split(String regex)

将正则传入split()，根据给定正则表达式的匹配拆分此字符串。不过通过这种方式截取会有很大的性能损耗，因为分析正则非常耗时。

String str = "HelloWorld@qq.com";

String[] strs = str.split("@");

for(int i=0,i<strs.length;i++){

    System.out.println(strs[i].toString());

}


运行结果：

HelloWorld

qq.com

2.传入两个参数：split(String regex,int limit)


	
regex -- 正则表达式分隔符。
	
	

	
limit -- 分割的份数。
	
将正则和份数传入split()。根据给定正则表达式的匹配和想要分割的份数来拆分此字符串。

String str = "HelloWorld@qq@com";

String[] strs = str.split("@"，2);

for(int i=0,i<strs.length;i++){

    System.out.println(strs[i].toString());

}


运行结果：

HelloWorld

qq@com



方法二：通过subString()方法来进行字符串截取

1、只传一个参数：subString(int beginIndex)

将字符串从索引号为beginIndex开始截取，一直到字符串末尾。（注意索引值从0开始）；

String sb = "HelloWorld@qq.com";

String str = sb.substring(5);

System.out.println(str);


运行结果：

World@qq.com


2、传入两个参数：substring(int beginIndex, int endIndex)

从索引号beginIndex开始到索引号endIndex结束（返回结果包含索引为beginIndex的字符不包含索引endIndex的字符），如下所示：

String sb = "HelloWorld@qq.com";

String str = sb.substring(0, 5);

System.out.println(str);


运行结果：

Hello


3、根据某个字符截取字符串

这里根据”@”截取字符串（也可以是其他子字符串）

String sb = "HelloWorld@qq.com";

String str = sb.substring(0, sb.indexOf("@"));

System.out.println(str);


运行结果：

HelloWorld


分析：indexOf(String str)方法返回的是子字符串第一次出现在字符串的索引位置，上面的代码返回的是@前面的字符。

 

参考原文出处：https://blog.csdn.net/zjx2016/article/details/74557301

编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串，但要保证汉字不被截取半个.

如“我ABC”，4，应该截取“我AB”，

输入“我ABC汉DEF”，6，应该输出“我ABC”，而不是“我ABC+汉的半个”。

 

代码：

 

public class Test {

	public static void main(String[] args) throws Exception{
		String str = "落尘曦a的abc博客def";
		int num = trimGBK(str.getBytes("GBK"),8);
		System.out.println(str.substring(0,num) );
	}
	
	public static int  trimGBK(byte[] buf,int n){
		int num = 0;
		boolean bChineseFirstHalf = false;
		for(int i=0;i<n;i++)
		{
			if(buf[i]<0 && !bChineseFirstHalf){
				bChineseFirstHalf = true;
			}else{
				num++;
				bChineseFirstHalf = false;				
			}
		}
		return num;
	}
}

 

输出：

 

落尘曦a


 


substring(int beginIndex)

返回一个新的字符串，它是此字符串的一个子字符串。该子字符串始于指定索引处的字符，一直到此字符串末尾。

例如：

"unhappy".substring(2) returns "happy"

"Harbison".substring(3) returns "bison"

"emptiness".substring(9) returns "" (an empty string)

参数：

beginIndex - 开始处的索引（包括）。

返回：指定的子字符串。

抛出：IndexOutOfBoundsException - 如果 beginIndex 为负或大于此 String 对象的长度。

----------------------------------------------------------------------------------------------------------------------------------------------------------------
substring(int beginIndex, int endIndex)

返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的 beginIndex 处开始， endIndex:到指定的 endIndex-1处结束。

示例：

"hamburger".substring(3,8) returns "burge"

"smiles".substring(0,5) returns "smile"

参数：

beginIndex - 开始处的索引（包括）。

endindex 结尾处索引（不包括）。

返回：指定的子字符串。

抛出：IndexOutOfBoundsException - 如果 beginIndex 为负，或length大于字符串长度。

 

----------------------------------------------------------------------------------------------------------------------------------------------------------------
js示例

var str="Hello world!"

document.write(str.substring(1,3));

上面返回字符串:"el";

str.substring(1,2) //返回e

str.substring(1) //返回"ello world";

还有此函数中会出现奇怪的现象,当出现str.substring(5,0);

这又是怎么回事,不过返回的是"hello",

str.substring(5,1) //返回"ello",截去了第一位,返回余下的.

可见substring(start,end),可以有不同的说明,即start可以是要返回的长度,end是所要去掉的多少个字符(从首位开始).

在JS中,substr(start,length),用得较方便.

 

slice() 方法可通过指定的开始和结束位置，提取字符串的某个部分，并以新的字符串返回被提取的部分。

var str = "0123456789";
console.log("原始字符串：", str);
 
console.log("从索引为3的字符起一直到结束：", str.slice(3));  //3456789
console.log("从倒数第3个字符起一直到结束：", str.slice(-3));  //789
 
console.log("从开始一直到索引为5的前一个字符：", str.slice(0,5));  //01234
console.log("从开始一直到倒数第3个字符的前一个字符：", str.slice(0,-3));  //0123456
 
console.log("从索引为3的字符起到索引为5的前一个字符：", str.slice(3,5));  //34
console.log("从索引为3的字符起到倒数第3个字符的前一个字符：", str.slice(3,-3));  //3456

substring 方法用于提取字符串中介于两个指定下标之间的字符。

var str = "0123456789";
console.log("原始字符串：", str);
 
console.log("从索引为3的字符起一直到结束：", str.substring(3));  //3456789
console.log("从索引为20的字符起一直到结束：", str.substring(20));  //
 
console.log("从索引为3的字符起到索引为5的前一个字符结束：", str.substring(3,5));  //34
console.log("start比end大会自动交换，结果同上：", str.substring(5,3));  //34
console.log("从索引为3的字符起到索引为20的前一个字符结束：", str.substring(3,20));  //3456789

 substr 方法用于返回一个从指定位置开始的指定长度的子字符串。

var str = "0123456789";
console.log("原始字符串：", str);
 
console.log("从索引为3的字符起一直到结束：", str.substr(3));  //3456789
console.log("从索引为20的字符起一直到结束：", str.substr(20));  //
 
console.log("从索引为3的字符起截取长度为5的字符串：", str.substr(3,5));  //34567
console.log("从索引为3的字符起截取长度为20的字符串：", str.substr(3,20));  //3456789

 indexOf返回字符串中匹配子串的第一个字符的下标。

var str = "JavaScript";
var i1 = str.indexOf("a"); //1
var i2 = str.indexOf("S"); //4
var i3 = str.indexOf("Script"); //4
var i4 = str.indexOf("k"); //-1
 
console.log("原始字符串：", str);
console.log("a的索引：", i1);
console.log("S的索引：",i2);
console.log("Script的索引：",i3);
console.log("k的索引：",i4);

lastIndexOf返回从右向左出现某个字符或字符串的首个字符索引值（与 indexOf 相反）

var str = "JavaScript";
var i1 = str.lastIndexOf("a"); //3
var i2 = str.lastIndexOf("S"); //4
var i3 = str.lastIndexOf("Script"); //4
var i4 = str.lastIndexOf("k"); //-1

 split使用一个指定的分隔符把一个字符串分割存储到数组。

var str = "jpg|bmp|gif|ico|png";
var arr= str.split("|");
console.log(arr); // ["jpg","bmp","gif","ico","png"]

 join使用一个指定的分隔符将一个数组合并为一个字符串。

var arr= new Array("jpg","bmp","gif","ico","png");
var str = arr.join("|");
console.log(str); //jpg|bmp|gif|ico|png

concat将两个数组连接在一起。

var arr1 = [1, 2, 3];
var arr2 = [4, 5, 6];
var arr3 = arr1.concat(arr2);
console.log(arr3); //[1, 2, 3, 4, 5, 6]

charAt返回指定位置的字符。字符串中第一个字符的下标是 0。

var str = "abcdefg";
var char = str.charAt(2);  
console.log(char); //c

 

                         字符串索引示意图



字符串切片也就是截取字符串，取子串

Python中字符串切片方法

字符串[开始索引：结束索引：步长]
切取字符串为开始索引到结束索引-1内的字符串
步长不指定时步长为1 字符串[开始索引:结束索引]

练习样例

# 1.截取2 - 5位置的字符
num_str_1 = num_str[2:6]
print(num_str_1)



# 2.截取2 - 末尾的字符
# 当开始索引和结束索引为开始和结束时可以省略不写
num_str_1 = num_str[2:]
print(num_str_1)
# 3.截取从开始 -5 位置的字符串
num_str_1 = num_str[0:6]
print(num_str_1)

 

截取2-末尾的字符用 num_str_1 = num_str[2:-1]呢？

结果是不对的

它切取得范围是第一个参数到第二个参数-1，如果用 num_str_1 = num_str[2:-1]，它的切片范围是索引2到-2的位置

即结果为2345678

# 4.截取完整的字符串
num_str_1 = num_str[:]
print(num_str_1)

 

# 5.从开始位置，每隔一个字符截取字符串
num_str_1 = num_str[::2]
print(num_str_1)



# 6.从索引1开始，每隔一个取一个
num_str_1 = num_str[1::2]
print(num_str_1)

 

# 7.截取2 - 末尾-1 的字符串
num_str_1 = num_str[2:-1]
print(num_str_1)



# 8.截取字符串末尾两个字符
num_str_1 = num_str[-2:]
print(num_str_1)

 

# 9.字符串的逆序
num_str_1 = num_str[::-1]
print(num_str_1)
num_str_1 = num_str[-1::-1]
print(num_str_1)
# 那么我们试试用负数的索引可以取到字符串的什么值
print(num_str[-1])

 

1. 问题描述 

在处理字符串的过程中有很多情况下会遇到需要截取字符串的情况，这个时候使用Java中提供的substring方法来截取就非常方便了

2. 其中比较经常使用到的方法有两个：

① public String substring(int beginIndex)

这个方法截取的字符串是从索引beginIndex开始的，到整个字符串的末尾，例如：字符串String s = "abcdef";

调用s.substring(2)表示从字符串的索引2开始截取到整个字符串结束，截取的字符串为cdef

② public String  substring(int beginIndex, int endIndex)

这个方法截取的字符串从beginIndex开始，到字符串索引的endIndex - 1结束，即截取的字符串不包括endIndex这个索引对应的字符，所以endIndex的最大值为整个字符串的长度，所以使用这个方法的时候需要特别注意容易发生字符串截取越界的问题

3. 下面是具体的代码：

import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String s = sc.nextLine();
		System.out.println(s.substring(0, 2));
		System.out.println(s.substring(2));
		sc.close();
	}
}


从控制台输入：saahdfasgfdga