在 Java 中遍历字符串数组

小开

String current = elements[i];
if (i != elements.length - 1) {
String next = elements[i+1];
}

这样可以确保最后一个元素不会得到 ArrayIndexOutOfBoundsException(这里没有“ next”)。另一种选择是迭代到 i < elements.length - 1。这取决于你的要求。

小开

String[] elements = { "a", "a", "a", "a" };


for( int i = 0; i < elements.length - 1; i++)
{
String element = elements[i];
String nextElement = elements[i+1];
}

注意，在这种情况下，elements.length是4，所以您需要从 [0,2]迭代以获得元素 0,1、 1,2和 2,3。

小开

String[] elements = { "a", "a","a","a" };


for( int i=0; i<elements.length-1; i++)
{
String s1 = elements[i];
String s2 = elements[i+1];
}

小开

您必须维护序列多少次访问该数组

int lookUpTime=0;


for(int i=lookUpTime;i<lookUpTime+2 && i<elements.length();i++)
{
// do something with elements[i]
}


lookUpTime++;

小开

我认为与其测试 i小于 elements.length - 1，不如测试 i + 1小于 elements.length。您并没有更改正在查看的数组的域(即忽略最后一个元素) ，而是在每次迭代中更改正在查看的最大元素。

String[] elements = { "a", "a","a","a" };


for(int i = 0; i + 1 < elements.length; i++) {
String first = elements[i];
String second = elements[i+1];
//do something with the two strings
}

小开

您可以对 array 的元素执行循环增强型(针对 java 5或更高版本)迭代:

String[] elements = {"a", "a", "a", "a"};
for (String s: elements) {
//Do your stuff here
System.out.println(s);
}

小开

这两种算法都不正确，因为它们之间存在比较:

For (int i = 0; i < elements.length-1; i + +)

或者

For (int i = 0; i + 1 < elements.length; i + +){

的确，数组元素的范围从 0到 length - 1，但是在这种情况下的比较应该是 less than or equal to。这些应该是:

For (int i = 0; i < elements.length; i + +){

或者

For (int i = 0; i < = elements.length-1; i + +){

或者

For (int i = 0; i + 1 < = elements.length; i + +){

数组 ["a", "b"] 将重复如下:

I = 0是 < 2: 元素[0]产生“ a”

I = 1是 < 2: 元素[1]产生“ b”

然后退出循环，因为2不是 < 2。

不正确的示例都过早地退出了循环，并且在这种两个元素的简单情况下只使用第一个元素执行。

小开

    String[] nameArray= {"John", "Paul", "Ringo", "George"};
int numberOfItems = nameArray.length;
for (int i=0; i<numberOfItems; i++)
{
String name = nameArray[i];
System.out.println("Hello " + name);
}

小开

如果您正在寻找性能，而迭代的顺序与此无关，那么您可以使用优化的反向循环进行迭代:

int elemLength = elements.length;
if(elemLength < 2){
// avoid ArrayIndexOutOfBoundsException ...
} else {
String elem1, elem2;
for(int i = elemLength -1; --i >= 0;) {
elem1 = elements[i];
elem2 = elements[i+1];
// do whatever you want with those two strings
}
}

通过这种方式，您只需检索一次数组的长度，然后在单个操作中递减索引并与零进行比较。比较零是一个非常快的操作，通常由许多架构进行优化(比较数组长度更容易/更快)。

小开

只要这个问题仍然没有解决 OP 的问题，并且 Java 经过多年的发展，我决定把我自己的问题。

为了清晰起见，让我们将输入 String 数组改为具有5个惟一的项。

String[] elements = {"a", "b", "c", "d", "e"};

您希望访问列表中的两个兄弟节点，每次迭代增加一个索引。

for (int i=0; i<elements.length-1; i++) {        // note the condition
String left = elements[i];
String right = elements[i+1];


System.out.println(left + " " + right);      // prints 4 lines
}

在四次迭代中打印左对和右对将导致在控制台中出现 a b、 b c、 c d、 d e行。

如果输入字符串数组少于2个元素，会发生什么情况？只要 for 循环提取的内容总是 两个兄弟节点，就不会打印出我们的内容。如果少于2个元素，程序就不会进入循环本身。

如果代码片段说不希望丢弃提取的值，而是将它们添加到另一个变量中，那么假设在 for 循环的范围之外，您希望将它们存储在列表或数组中。假设您想将兄弟字符与 +字符连接起来。

List<String> list = new ArrayList<>();
String[] array = new String[elements.length-1];  // note the defined size


for (int i=0; i<elements.length-1; i++) {
String left = elements[i];
String right = elements[i+1];


list.add(left + "+" + right);            // adds to the list
array[i] = left + "+" + right;           // adds to the array
}

打印列表和数组(Arrays.toString(array))的内容会导致:

[a+b, b+c, c+d, d+e]

爪哇8

对于 Java8，您可能会倾向于使用 StreamAPI 的优势，但是，它是用于处理来自源集合的单个元素的。没有这样的方法可以同时处理2个或更多的兄弟节点。

唯一的方法是使用 StreamAPI 来处理索引，并将它们映射到实际值。只要你从一个叫做 IntStream的基本 Stream 开始，你就需要使用 IntStream::mapToObj方法来得到装箱的 Stream<T>:

String[] array = IntStream.range(0, elements.length-1)
.mapToObj(i -> elements[i] + "+" + elements[i + 1])
.toArray(String[]::new);                              // [a+b, b+c, c+d, d+e]


List<String> list = IntStream.range(0, elements.length-1)
.mapToObj(i -> elements[i] + "+" + elements[i + 1])
.collect(Collectors.toList());                        // [a+b, b+c, c+d, d+e]