Última iteración de mejorado para loop en java

¿Hay alguna manera de determinar si el ciclo está iterando por última vez? Mi código se parece a esto:

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

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

Ahora la cosa es que no quiero agregar la coma en la última iteración. Ahora hay una manera de determinar si es la última iteración o si estoy atascado con el bucle for o usando un contador externo para realizar un seguimiento.

Otra alternativa es agregar la coma antes de agregar i, pero no en la primera iteración. (Por "" + icierto, no lo use , por cierto, realmente no desea la concatenación aquí, y StringBuilder tiene una sobrecarga append (int) perfectamente buena).

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

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

Lo bueno de esto es que funcionará con cualquiera Iterable: no siempre puede indexar las cosas. (El "agregar la coma y luego eliminarlo al final" es una buena sugerencia cuando realmente está utilizando StringBuilder, pero no funciona para cosas como escribir en secuencias. Sin embargo, es posiblemente el mejor enfoque para este problema exacto. )

Otra forma de hacer esto:

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

Actualización: para Java 8, ahora tiene recopiladores

Puede ser más fácil agregar siempre. Y luego, cuando haya terminado con su ciclo, simplemente elimine el carácter final. Toneladas menos condicionales de esa manera también.

Puedes usar StringBuilder's deleteCharAt(int index)con index siendolength() - 1

Tal vez está utilizando la herramienta incorrecta para el trabajo.

Esto es más manual que lo que estás haciendo, pero es de una manera más elegante, si no un poco "vieja escuela"

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

Esto es casi una repetición de esta pregunta de StackOverflow . Lo que quieres es StringUtils y llamar al método de unión .

StringUtils.join(strArr, ',');

Otra solución (quizás la más eficiente)

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

manténgalo simple y use un estándar para loop:

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

o simplemente use apache commons-lang StringUtils.join ()

Los bucles explícitos siempre funcionan mejor que los implícitos.

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

Debería envolver todo en una declaración if solo en caso de que esté tratando con una matriz de longitud cero.

Si lo convierte en un bucle de índice clásico, sí.

O simplemente puede eliminar la última coma después de que esté hecha. Al igual que:

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

Yo, solo lo uso StringUtils.join()de commons-lang .

Necesita un separador de clase .

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

La implementación de la clase Separatores sencilla. Envuelve una cadena que se devuelve en cada llamada, toString()excepto en la primera llamada, que devuelve una cadena vacía.

Basado en java.util.AbstractCollection.toString (), sale temprano para evitar el delimitador.

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

Es eficiente y elegante, pero no tan evidente como algunas de las otras respuestas.

Aquí hay una solución:

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

Busque la primera iteración :)  

Como se mencionó en el kit de herramientas, en Java 8 ahora tenemos recopiladores . Así es como se vería el código:

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

Creo que eso hace exactamente lo que estás buscando, y es un patrón que puedes usar para muchas otras cosas.

Otra opción más.

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

Muchas de las soluciones descritas aquí son un poco exageradas, en mi humilde opinión, especialmente aquellas que dependen de bibliotecas externas. Hay un buen lenguaje limpio y claro para lograr una lista separada por comas que siempre he usado. Se basa en el operador condicional (?):

Editar : Solución original correcta, pero no óptima según los comentarios. Intentando por segunda vez:

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

Ahí tienes, en 4 líneas de código, incluida la declaración de la matriz y el StringBuilder.

Aquí hay un punto de referencia SSCCE que ejecuté (relacionado con lo que tuve que implementar) con estos resultados:

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

Al menos en mi ejemplo, omitir el control en cada iteración no es notablemente más rápido, especialmente para volúmenes de datos sanos, pero es más rápido.

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

Otro enfoque es tener la longitud de la matriz (si está disponible) almacenada en una variable separada (más eficiente que volver a verificar la longitud cada vez). Luego puede comparar su índice con esa longitud para determinar si agregar o no la coma final.

EDITAR: Otra consideración es sopesar el costo de rendimiento de eliminar un carácter final (que puede causar una copia de cadena) en contra de que se verifique un condicional en cada iteración.

Si solo está convirtiendo una matriz en una matriz delimitada por comas, muchos idiomas tienen una función de unión para exactamente esto. Convierte una matriz en una cadena con un delimitador entre cada elemento.

En este caso, realmente no hay necesidad de saber si es la última repetición. Hay muchas formas en que podemos resolver esto. Una forma sería:

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

Dos caminos alternativos aquí:

1: Utilidades de cadena de Apache Commons

2: Mantenga un booleano llamado first, establecido en verdadero. En cada iteración, si firstes falsa, agregue su coma; después de eso, establecer firsten falso.

Dado que es una matriz fija, sería más fácil simplemente evitar la mejora para ... Si el Objeto es una colección, un iterador sería más fácil.

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(",");
   }
}