在 Java 中遍历字符串字符的一些方法是:
使用 StringTokenizer?将字符串转换为 char[] 并对其进行迭代。
什么是最简单/最好/最正确的迭代方式?
我使用 for 循环来迭代字符串并使用 charAt()
来获取每个字符来检查它。由于 String 是使用数组实现的,因此 charAt()
方法是一个常数时间操作。
String s = "...stuff...";
for (int i = 0; i < s.length(); i++){
char c = s.charAt(i);
//Process char
}
这就是我会做的。这对我来说似乎是最简单的。
就正确性而言,我不相信这里存在。这完全取决于您的个人风格。
两种选择
for(int i = 0, n = s.length() ; i < n ; i++) {
char c = s.charAt(i);
}
或者
for(char c : s.toCharArray()) {
// process c
}
第一个可能更快,然后第二个可能更具可读性。
请注意,如果您正在处理 BMP (Unicode Basic Multilingual Plane) 之外的字符,即 u0000-uFFFF 范围之外的 code points,则此处描述的大多数其他技术都会失效。这只会很少发生,因为在此之外的代码点大多分配给死语言。但除此之外还有一些有用的字符,例如一些用于数学符号的代码点,以及一些用于编码中文专有名称的代码点。
在这种情况下,您的代码将是:
String str = "....";
int offset = 0, strLen = str.length();
while (offset < strLen) {
int curChar = str.codePointAt(offset);
offset += Character.charCount(curChar);
// do something with curChar
}
Character.charCount(int)
方法需要 Java 5+。
来源:http://mindprod.com/jgloss/codepoint.html
在 Java 8 中,我们可以将其解决为:
String str = "xyz";
str.chars().forEachOrdered(i -> System.out.print((char)i));
str.codePoints().forEachOrdered(i -> System.out.print((char)i));
chars() 方法返回 doc 中提到的 IntStream
:
返回一个 int 流,对该序列中的 char 值进行零扩展。任何映射到代理代码点的字符都会未经解释地传递。如果在读取流时序列发生突变,则结果未定义。
方法 codePoints()
还根据文档返回 IntStream
:
从该序列返回代码点值流。序列中遇到的任何代理对都会像 Character.toCodePoint 一样组合,并将结果传递给流。任何其他代码单元,包括普通 BMP 字符、不成对的代理和未定义的代码单元,都被零扩展为 int 值,然后将其传递给流。
char 和代码点有何不同? 如this文章中所述:
Unicode 3.1 添加了补充字符,使字符总数超过了单个 16 位字符可以区分的 2^16 = 65536 个字符。因此,char 值不再具有与 Unicode 中基本语义单元的一对一映射。 JDK 5 已更新以支持更大的字符值集。一些新的补充字符不是更改 char 类型的定义,而是由两个 char 值的代理对表示。为了减少命名混淆,将使用代码点来指代代表特定 Unicode 字符的数字,包括补充字符。
最后为什么是 forEachOrdered
而不是 forEach
?
forEach
的行为是明确的非确定性的,因为 forEachOrdered
对该流的每个元素执行操作,如果流具有已定义的遭遇顺序,则按照 流的遭遇顺序。所以 forEach
不保证订单会被保留。另请查看此 question 了解更多信息。
对于字符、代码点、字形和字形之间的区别,请检查此 question。
我同意 StringTokenizer 在这里是矫枉过正的。实际上我尝试了上面的建议并花时间。
我的测试相当简单:创建一个包含大约一百万个字符的 StringBuilder,将其转换为字符串,并在转换为 char 数组 / 使用 CharacterIterator 千次之后使用 charAt() 遍历它们(当然要确保对字符串做一些事情,这样编译器就不能优化整个循环:-))。
我的 2.6 GHz Powerbook(这是一个 mac :-))和 JDK 1.5 上的结果:
测试 1:charAt + String --> 3138 毫秒
测试 2:字符串转换为数组 --> 9568 毫秒
测试 3:StringBuilder charAt --> 3536msec
测试 4:CharacterIterator 和 String --> 12151msec
由于结果明显不同,最直接的方法似乎也是最快的方法。有趣的是,StringBuilder 的 charAt() 似乎比 String 的慢一点。
顺便说一句,我建议不要使用 CharacterIterator,因为我认为它滥用 '\uFFFF' 字符作为“迭代结束”是一个非常糟糕的黑客行为。在大型项目中,总会有两个人出于两种不同的目的使用相同的 hack,并且代码会非常神秘地崩溃。
这是其中一项测试:
int count = 1000;
...
System.out.println("Test 1: charAt + String");
long t = System.currentTimeMillis();
int sum=0;
for (int i=0; i<count; i++) {
int len = str.length();
for (int j=0; j<len; j++) {
if (str.charAt(j) == 'b')
sum = sum + 1;
}
}
t = System.currentTimeMillis()-t;
System.out.println("result: "+ sum + " after " + t + "msec");
为此有一些专门的课程:
import java.text.*;
final CharacterIterator it = new StringCharacterIterator(s);
for(char c = it.first(); c != CharacterIterator.DONE; c = it.next()) {
// process c
...
}
char
提供的更多空间。 Java char
包含 16 位,最多可以容纳 U+FFFF 的 Unicode 字符,但 Unicode 指定最多 U+10FFFF 的字符。使用 16 位对 Unicode 进行编码会产生可变长度的字符编码。此页面上的大多数答案都假定 Java 编码是恒定长度编码,这是错误的。
如果您的类路径中有 Guava,则以下是一个非常易读的替代方案。对于这种情况,Guava 甚至有一个相当明智的自定义 List 实现,所以这不应该是低效的。
for(char c : Lists.charactersOf(yourString)) {
// Do whatever you want
}
更新:正如@Alex 所指出的,对于 Java 8,还有 CharSequence#chars
可以使用。甚至类型是 IntStream,所以它可以映射到如下字符:
yourString.chars()
.mapToObj(c -> Character.valueOf((char) c))
.forEach(c -> System.out.println(c)); // Or whatever you want
如果您需要遍历 String
的代码点(请参阅此 answer),一种更短/更易读的方法是使用 Java 8 中添加的 CharSequence#codePoints
方法:
for(int c : string.codePoints().toArray()){
...
}
或直接使用流而不是 for 循环:
string.codePoints().forEach(c -> ...);
如果您想要字符流,还有 CharSequence#chars
(尽管它是 IntStream
,因为没有 CharStream
)。
如果您需要性能,那么您必须在您的环境中进行测试。没有其他办法了。
这里示例代码:
int tmp = 0;
String s = new String(new byte[64*1024]);
{
long st = System.nanoTime();
for(int i = 0, n = s.length(); i < n; i++) {
tmp += s.charAt(i);
}
st = System.nanoTime() - st;
System.out.println("1 " + st);
}
{
long st = System.nanoTime();
char[] ch = s.toCharArray();
for(int i = 0, n = ch.length; i < n; i++) {
tmp += ch[i];
}
st = System.nanoTime() - st;
System.out.println("2 " + st);
}
{
long st = System.nanoTime();
for(char c : s.toCharArray()) {
tmp += c;
}
st = System.nanoTime() - st;
System.out.println("3 " + st);
}
System.out.println("" + tmp);
在 Java online 我得到:
1 10349420
2 526130
3 484200
0
在 Android x86 API 17 上,我得到:
1 9122107
2 13486911
3 12700778
0
我不会使用 StringTokenizer
,因为它是 JDK 中遗留的类之一。
javadoc 说:
StringTokenizer 是一个遗留类,出于兼容性原因保留,但不鼓励在新代码中使用它。建议任何寻求此功能的人改用 String 的 split 方法或 java.util.regex 包。
public class Main {
public static void main(String[] args) {
String myStr = "Hello";
String myStr2 = "World";
for (int i = 0; i < myStr.length(); i++) {
char result = myStr.charAt(i);
System.out.println(result);
}
for (int i = 0; i < myStr2.length(); i++) {
char result = myStr2.charAt(i);
System.out.print(result);
}
}
}
输出:
H
e
l
l
o
World
请参阅The Java Tutorials: Strings。
public class StringDemo {
public static void main(String[] args) {
String palindrome = "Dot saw I was Tod";
int len = palindrome.length();
char[] tempCharArray = new char[len];
char[] charArray = new char[len];
// put original string in an array of chars
for (int i = 0; i < len; i++) {
tempCharArray[i] = palindrome.charAt(i);
}
// reverse array of chars
for (int j = 0; j < len; j++) {
charArray[j] = tempCharArray[len - 1 - j];
}
String reversePalindrome = new String(charArray);
System.out.println(reversePalindrome);
}
}
将长度放入 int len
并使用 for
循环。
StringTokenizer 完全不适合将字符串分解为单个字符的任务。使用 String#split()
,您可以使用不匹配的正则表达式轻松做到这一点,例如:
String[] theChars = str.split("|");
但是 StringTokenizer 不使用正则表达式,并且没有可以指定的分隔符字符串将匹配字符之间的空。您可以使用一个可爱的小技巧来完成同样的事情:使用字符串本身作为分隔符字符串(使其中的每个字符成为分隔符)并让它返回分隔符:
StringTokenizer st = new StringTokenizer(str, str, true);
但是,我仅出于消除它们的目的而提及这些选项。这两种技术都将原始字符串分解为单字符字符串而不是 char 原语,并且都涉及对象创建和字符串操作形式的大量开销。将其与在 for 循环中调用 charAt() 进行比较,这几乎不会产生任何开销。
详细说明 this answer 和 this answer。
上面的答案指出了这里许多不按代码点值迭代的解决方案的问题——它们对任何 surrogate chars 都会有问题。 Java 文档还概述了问题 here(请参阅“Unicode 字符表示”)。无论如何,这里有一些代码使用补充 Unicode 集中的一些实际代理字符,并将它们 back 转换为字符串。请注意, .toChars() 返回一个字符数组:如果您正在处理代理项,则必须有两个字符。此代码适用于 any Unicode 字符。
String supplementary = "Some Supplementary: 𠜎𠜱𠝹𠱓";
supplementary.codePoints().forEach(cp ->
System.out.print(new String(Character.toChars(cp))));
此示例代码将为您提供帮助!
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;
public class Solution {
public static void main(String[] args) {
HashMap<String, Integer> map = new HashMap<String, Integer>();
map.put("a", 10);
map.put("b", 30);
map.put("c", 50);
map.put("d", 40);
map.put("e", 20);
System.out.println(map);
Map sortedMap = sortByValue(map);
System.out.println(sortedMap);
}
public static Map sortByValue(Map unsortedMap) {
Map sortedMap = new TreeMap(new ValueComparator(unsortedMap));
sortedMap.putAll(unsortedMap);
return sortedMap;
}
}
class ValueComparator implements Comparator {
Map map;
public ValueComparator(Map map) {
this.map = map;
}
public int compare(Object keyA, Object keyB) {
Comparable valueA = (Comparable) map.get(keyA);
Comparable valueB = (Comparable) map.get(keyB);
return valueB.compareTo(valueA);
}
}
所以通常有两种方法可以遍历java中的字符串,这已经被这个线程中的多人回答了,只需添加我的版本首先是使用
String s = sc.next() // assuming scanner class is defined above
for(int i=0; i<s.length(); i++){
s.charAt(i) // This being the first way and is a constant time operation will hardly add any overhead
}
char[] str = new char[10];
str = s.toCharArray() // this is another way of doing so and it takes O(n) amount of time for copying contents from your string class to the character array
如果性能受到威胁,那么我建议在恒定时间内使用第一个,如果不是,那么考虑到 java 中字符串类的不变性,使用第二个会让你的工作更容易。
String.charAt(int)
的代码只是在做value[index]
。我认为您将chatAt()
与其他给您代码点的东西混淆了。