遍历Java中的字符串数组

Posted 2023-02-25

【中文标题】遍历Java中的字符串数组

【英文标题】：Iterate through string array in Java

【发布时间】：2011-10-06 04:00:52

【问题描述】：

我有一些包含一些组件的字符串数组，这个数组有 5 个组件，并且它有时会发生变化。我想做的是遍历该数组并获取第一个组件和该组件旁边的组件。所以第一次我会得到第一个组件和第 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. 

我怎样才能做到这一点？

【参考方案1】：

您可以使用enhanced for loop（适用于 java 5 及更高版本）对数组元素进行迭代：

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

【讨论】：

如何获得其中的迭代次数？还是我需要通过声明一个变量并计算迭代次数来手动完成？

我认为您需要添加其他变量来存储此信息

另请注意，此高级 for 循环适用于 Java 1.5 及更高版本。我知道 1.4 及以下版本是古老的，但大多数人尝试这个并得到错误，在某些情况下他们不会检查他们使用的 java 版本。

我可能遗漏了一些东西，但我不明白当它没有回答问题时，这个答案是如何获得这么多赞成票的......（除非你只阅读主题）。

这种迭代格式是否可以获取键索引？

【参考方案2】：

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。

【参考方案3】：

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

这确保您不会为最后一个元素获得ArrayIndexOutOfBoundsException（那里没有“下一个”）。另一种选择是迭代到i < elements.length - 1。这取决于您的要求。

【参考方案4】：

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

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

    String s1 = elements[i];
    String s2 = elements[i+1];

【参考方案5】：

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

【参考方案6】：

你必须维护序列你访问数组的次数。像这样使用

int lookUpTime=0;

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

lookUpTime++;

【参考方案7】：

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

【讨论】：

虽然此代码可能会回答问题，但提供有关此代码为何和/或如何回答问题的额外上下文可提高其长期价值。

【参考方案8】：

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

for(int i = 0; i

或

for(int i = 0; i + 1

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

for(int i = 0; i

或

for(int i = 0; i

或

for(int i = 0; i + 1

数组["a", "b"] 将迭代为：

i = 0 is

i = 1 is

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

在这个简单的两个元素的例子中，错误的例子都会提前退出循环，并且只使用第一个元素执行。

【参考方案9】：

只要这个问题仍未得到解答，OP 的问题和 Java 多年来一直在发展，我就决定提出自己的问题。

为了清楚起见，让我们将输入字符串数组更改为具有 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 个元素的程序不会进入循环本身。

只要您的 sn-p 说您不想丢弃提取的值，而是将它们添加到另一个变量，假设在 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 来处理索引并将它们映射到实际值。只要你从一个名为IntStream 的原始流开始，你就需要使用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]

【参考方案10】：

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

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
  

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