遍历Java中的字符串数组

我有一些组件的String数组，此数组有5个组件，有时会有所不同。我想做的是遍历该数组，并获得第一个组件和该组件旁边的组件。因此，我第一次获得组件编号1和2，第二次获得编号2和3，第三次获得3和4 ...依此类推，直到找到最后一个组件。

这是我走了多远：

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

for( int i = 0; i <= elements.length - 1; i++)
{
    // get element number 0 and 1 and put it in a variable, 
    // and the next time get element      1 and 2 and put this in another variable. 
}

我该怎么做？

您可以对数组元素进行迭代的增强型for循环（适用于Java 5及更高版本）：

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

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 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 s1 = elements[i];
    String s2 = elements[i+1];
}

我会争论，而不是测试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
}

您必须维护串行访问阵列的次数。

int lookUpTime=0;

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

lookUpTime++;

    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);
    }

由于比较，这些算法都不正确：

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：elements [0]产生“ a”

i = 1 <2：elements [1]产生“ b”

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

错误的示例既会过早退出循环，也只会在有两个元素的这种简单情况下才使用第一个元素执行。

只要这个问题仍然无法解决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]

Java 8

从Java 8开始，您可能会想利用Stream API的优势，但是，它是为处理源集合中的各个元素而设计的。没有这样的方法可同时处理2个或更多同级节点。

唯一的方法是使用Stream API代替处理索引并将它们映射到实际值。只要从一个称为Stream的原始Stream开始，IntStream就需要使用IntStream::mapToObjmethod进行装箱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]

如果您正在寻找性能并且迭代顺序不相关，则可以使用优化的反向循环进行迭代：

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
  }
}

这样，您只需一次检索数组的长度，然后递减索引并在单个操作中与零进行比较。与零进行比较是一个非常快的操作，通常会通过许多体系结构进行优化（比与阵列的长度相比更容易/更快）。