Ostatnia iteracja ulepszonej pętli for w Javie

Czy istnieje sposób, aby określić, czy pętla jest iterowana po raz ostatni. Mój kod wygląda mniej więcej tak:

int[] array = {1, 2, 3...};
StringBuilder builder = new StringBuilder();

for(int i : array)
{
    builder.append("" + i);
    if(!lastiteration)
        builder.append(",");
}

Chodzi o to, że nie chcę dodawać przecinka w ostatniej iteracji. Czy jest teraz sposób, aby określić, czy jest to ostatnia iteracja, czy też utknąłem w pętli for lub używając zewnętrznego licznika do śledzenia.

Inną alternatywą jest dołączenie przecinka przed dodaniem i, ale nie w pierwszej iteracji. (Nawiasem "" + imówiąc, proszę nie używać - tak naprawdę nie chcesz tutaj konkatenacji, a StringBuilder ma doskonale dobre przeciążenie append (int).)

int[] array = {1, 2, 3...};
StringBuilder builder = new StringBuilder();

for (int i : array) {
    if (builder.length() != 0) {
        builder.append(",");
    }
    builder.append(i);
}

Fajną rzeczą w tym jest to, że będzie działać z każdym Iterable- nie zawsze możesz indeksować rzeczy. („Dodaj przecinek, a następnie usuń go na końcu” to dobra sugestia, gdy naprawdę używasz StringBuilder - ale nie działa w przypadku takich rzeczy, jak pisanie do strumieni. Jest to jednak prawdopodobnie najlepsze podejście do tego konkretnego problemu. )

Inny sposób na zrobienie tego:

String delim = "";
for (int i : ints) {
    sb.append(delim).append(i);
    delim = ",";
}

Aktualizacja: dla Java 8 masz teraz Kolektory

Łatwiej będzie zawsze dołączać. A potem, kiedy skończysz z pętlą, po prostu usuń ostatni znak. W ten sposób też ton mniej warunkowych.

Można użyć StringBuilder„s deleteCharAt(int index)z indeksu samopoczucialength() - 1

Może używasz złego narzędzia do pracy.

To jest bardziej ręczne niż to, co robisz, ale jest w pewnym sensie bardziej eleganckie, jeśli nie trochę „oldschoolowe”

 StringBuffer buffer = new StringBuffer();
 Iterator iter = s.iterator();
 while (iter.hasNext()) {
      buffer.append(iter.next());
      if (iter.hasNext()) {
            buffer.append(delimiter);
      }
 }

To prawie powtórzenie tego pytania StackOverflow . To, czego chcesz, to StringUtils i wywołanie metody join .

StringUtils.join(strArr, ',');

Inne rozwiązanie (być może najbardziej wydajne)

    int[] array = {1, 2, 3};
    StringBuilder builder = new StringBuilder();

    if (array.length != 0) {
        builder.append(array[0]);
        for (int i = 1; i < array.length; i++ )
        {
            builder.append(",");
            builder.append(array[i]);
        }
    }

zachowaj prostotę i użyj standardu pętli:

for(int i = 0 ; i < array.length ; i ++ ){
    builder.append(array[i]);
    if( i != array.length - 1 ){
        builder.append(',');
    }
}

lub po prostu użyj apache commons-lang StringUtils.join ()

Jawne pętle zawsze działają lepiej niż niejawne.

builder.append( "" + array[0] );
for( int i = 1; i != array.length; i += 1 ) {
   builder.append( ", " + array[i] );
}

Powinieneś owinąć całość w instrukcję if, na wypadek gdybyś miał do czynienia z tablicą o zerowej długości.

Jeśli przekonwertujesz go na klasyczną pętlę indeksu, tak.

Lub możesz po prostu usunąć ostatni przecinek po zakończeniu. Tak jak to:

int[] array = {1, 2, 3...};
StringBuilder

builder = new StringBuilder();

for(int i : array)
{
    builder.append(i + ",");
}

if(builder.charAt((builder.length() - 1) == ','))
    builder.deleteCharAt(builder.length() - 1);

Ja, po prostu używam StringUtils.join()ze wspólnego języka .

Potrzebujesz separatora klas .

Separator s = new Separator(", ");
for(int i : array)
{
     builder.append(s).append(i);
}

Implementacja klasy Separatorjest prosta. Zawija ciąg, który jest zwracany przy każdym wywołaniu z toString()wyjątkiem pierwszego wywołania, które zwraca pusty łańcuch.

Oparty na java.util.AbstractCollection.toString (), kończy działanie wcześnie, aby uniknąć separatora.

StringBuffer buffer = new StringBuffer();
Iterator iter = s.iterator();
for (;;) {
  buffer.append(iter.next());
  if (! iter.hasNext())
    break;
  buffer.append(delimiter);
}

Jest skuteczny i elegancki, ale nie jest tak oczywisty, jak niektóre inne odpowiedzi.

Oto rozwiązanie:

int[] array = {1, 2, 3...};
StringBuilder builder = new StringBuilder();
bool firstiteration=true;

for(int i : array)
{
    if(!firstiteration)
        builder.append(",");

    builder.append("" + i);
    firstiteration=false;
}

Poszukaj pierwszej iteracji :)  

Jak wspomniano w zestawie narzędzi, w Javie 8 mamy teraz Kolektory . Oto jak wyglądałby kod:

String joined = array.stream().map(Object::toString).collect(Collectors.joining(", "));

Myślę, że robi dokładnie to, czego szukasz, i jest to wzór, którego możesz użyć do wielu innych rzeczy.

Jeszcze inna opcja.

StringBuilder builder = new StringBuilder();
for(int i : array)
    builder.append(',').append(i);
String text = builder.toString();
if (text.startsWith(",")) text=text.substring(1);

Wiele z opisanych tutaj rozwiązań jest nieco przesadzonych, IMHO, zwłaszcza te, które opierają się na bibliotekach zewnętrznych. Istnieje ładny, czysty i przejrzysty idiom do tworzenia listy oddzielonej przecinkami, którego zawsze używałem. Opiera się na operatorze warunkowym (?):

Edycja : Oryginalne rozwiązanie poprawne, ale według komentarzy nieoptymalne. Próbuję po raz drugi:

    int[] array = {1, 2, 3};
    StringBuilder builder = new StringBuilder();
    for (int i = 0 ;  i < array.length; i++)
           builder.append(i == 0 ? "" : ",").append(array[i]); 

Proszę bardzo, w 4 wierszach kodu, w tym deklaracja tablicy i StringBuilder.

Oto test porównawczy SSCCE, który przeprowadziłem (związany z tym, co musiałem zaimplementować) z następującymi wynikami:

elapsed time with checks at every iteration: 12055(ms)
elapsed time with deletion at the end: 11977(ms)

Przynajmniej na moim przykładzie pomijanie sprawdzania przy każdej iteracji nie jest zauważalnie szybsze, szczególnie w przypadku rozsądnych ilości danych, ale tak jest szybsze.

import java.util.ArrayList;
import java.util.List;


public class TestCommas {

  public static String GetUrlsIn(int aProjectID, List<String> aUrls, boolean aPreferChecks)
  {

    if (aPreferChecks) {

      StringBuffer sql = new StringBuffer("select * from mytable_" + aProjectID + " WHERE hash IN ");

      StringBuffer inHashes = new StringBuffer("(");
      StringBuffer inURLs = new StringBuffer("(");

      if (aUrls.size() > 0)
      {

      for (String url : aUrls)
      {

        if (inHashes.length() > 0) {
        inHashes.append(",");
        inURLs.append(",");
        }

        inHashes.append(url.hashCode());

        inURLs.append("\"").append(url.replace("\"", "\\\"")).append("\"");//.append(",");

      }

      }

      inHashes.append(")");
      inURLs.append(")");

      return sql.append(inHashes).append(" AND url IN ").append(inURLs).toString();
    }

    else {

      StringBuffer sql = new StringBuffer("select * from mytable" + aProjectID + " WHERE hash IN ");

      StringBuffer inHashes = new StringBuffer("(");
      StringBuffer inURLs = new StringBuffer("(");

      if (aUrls.size() > 0)
      {

      for (String url : aUrls)
      {
        inHashes.append(url.hashCode()).append(","); 

        inURLs.append("\"").append(url.replace("\"", "\\\"")).append("\"").append(",");
      }

      }

      inHashes.deleteCharAt(inHashes.length()-1);
      inURLs.deleteCharAt(inURLs.length()-1);

      inHashes.append(")");
      inURLs.append(")");

      return sql.append(inHashes).append(" AND url IN ").append(inURLs).toString();
    }

  }

  public static void main(String[] args) { 
        List<String> urls = new ArrayList<String>();

    for (int i = 0; i < 10000; i++) {
      urls.add("http://www.google.com/" + System.currentTimeMillis());
      urls.add("http://www.yahoo.com/" + System.currentTimeMillis());
      urls.add("http://www.bing.com/" + System.currentTimeMillis());
    }


    long startTime = System.currentTimeMillis();
    for (int i = 0; i < 300; i++) {
      GetUrlsIn(5, urls, true);
    }
    long endTime = System.currentTimeMillis();
    System.out.println("elapsed time with checks at every iteration: " + (endTime-startTime) + "(ms)");

    startTime = System.currentTimeMillis();
    for (int i = 0; i < 300; i++) {
      GetUrlsIn(5, urls, false);
    }
    endTime = System.currentTimeMillis();
    System.out.println("elapsed time with deletion at the end: " + (endTime-startTime) + "(ms)");
  }
}

Innym podejściem jest przechowywanie długości tablicy (jeśli jest dostępna) w oddzielnej zmiennej (bardziej wydajne niż ponowne sprawdzanie długości za każdym razem). Następnie możesz porównać swój indeks z tą długością, aby określić, czy dodać ostatni przecinek.

EDYCJA: Inną kwestią jest rozważenie kosztu wydajności usunięcia ostatniego znaku (który może spowodować kopię ciągu) z koniecznością sprawdzania warunku w każdej iteracji.

Jeśli zamieniasz tablicę tylko w tablicę rozdzielaną przecinkami, wiele języków ma właśnie do tego funkcję łączenia. Zamienia tablicę w ciąg z ogranicznikiem między każdym elementem.

W tym przypadku naprawdę nie ma potrzeby wiedzieć, czy jest to ostatnie powtórzenie. Jest wiele sposobów rozwiązania tego problemu. Jednym ze sposobów byłoby:

String del = null;
for(int i : array)
{
    if (del != null)
       builder.append(del);
    else
       del = ",";
    builder.append(i);
}

Tutaj dwie alternatywne ścieżki:

1: Narzędzia ciągów znaków Apache Commons

2: Zachowaj wywołanie logiczne first, ustaw na true. W każdej iteracji, jeśli firstjest fałszywe, dołącz przecinek; po tym ustaw firstna false.

Ponieważ jest to stała tablica, łatwiej byłoby po prostu uniknąć ulepszonego for ... Jeśli obiekt jest zbiorem, iterator byłby łatwiejszy.

int nums[] = getNumbersArray();
StringBuilder builder = new StringBuilder();

// non enhanced version
for(int i = 0; i < nums.length; i++){
   builder.append(nums[i]);
   if(i < nums.length - 1){
       builder.append(",");
   }   
}

//using iterator
Iterator<int> numIter = Arrays.asList(nums).iterator();

while(numIter.hasNext()){
   int num = numIter.next();
   builder.append(num);
   if(numIter.hasNext()){
      builder.append(",");
   }
}