遍歷 Java 中的字符串數組

Question

我有一些包含一些組件的字符串數組，這個數組有 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. 
}

我怎樣才能做到這一點？

Answer 1

您可以為數組元素的迭代執行增強的 for 循環（對於 java 5 及更高版本）：

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

Answer 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 。

Answer 3

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

這確保您不會為最后一個元素獲得ArrayIndexOutOfBoundsException （那里沒有“下一個”）。 另一種選擇是迭代到i < elements.length - 1 。 這取決於您的要求。

Answer 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];
}

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

Answer 6

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

Answer 7

您必須維護串行訪問數組的次數。像這樣使用

int lookUpTime=0;

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

lookUpTime++;

Answer 8

由於比較，這些算法都是不正確的：

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 is < 2: elements[0] 產生 "a"

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

然后退出循環，因為 2 不 < 2。

不正確的示例都過早退出循環，並且在這個簡單的兩個元素的情況下只使用第一個元素執行。

Answer 9

如果您正在尋找性能並且迭代順序不相關，則可以使用優化的反向循環進行迭代：

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

以這種方式，您將檢索一次數組的長度，然后遞減索引並在單個操作中與零進行比較。 與零比較是一種非常快速的操作，通常由許多架構優化（比與數組的長度相比更容易/更快）。

Answer 10

只要這個問題仍未得到解答，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
}

在四次迭代中打印左右對導致控制台中的行ab 、 b c 、 c d 、 de 。

如果輸入字符串數組的元素少於 2 個，會發生什么情況？ 只要這個 for 循環總是提取兩個兄弟節點，就不會打印出我們的內容。 少於 2 個元素的程序不會進入循環本身。

就您的代碼段而言，您不想丟棄提取的值，而是將它們添加到另一個變量，假設在 for 循環的 scope 之外，您希望將它們存儲在列表或數組中。 假設您想用+字符連接兄弟姐妹。

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 來處理索引，並使用 map 將它們處理為實際值。 只要您從稱為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]