Última iteração do loop for aprimorado em java

Existe uma maneira de determinar se o loop está repetindo pela última vez. Meu código é algo como isto:

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

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

Agora, o problema é que não quero acrescentar a vírgula na última iteração. Agora existe uma maneira de determinar se é a última iteração ou estou preso ao loop for ou usando um contador externo para acompanhar.

Outra alternativa é acrescentar a vírgula antes de acrescentar i, mas não na primeira iteração. (Por favor, não use "" + i, a propósito - você realmente não quer concatenação aqui, e o StringBuilder tem uma sobrecarga de acréscimo (int) perfeitamente boa.)

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

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

O bom disso é que ele funcionará com qualquer um Iterable- nem sempre é possível indexar as coisas. ("Adicione a vírgula e remova-a no final" é uma boa sugestão quando você está realmente usando o StringBuilder - mas não funciona para coisas como escrever em fluxos. É possivelmente a melhor abordagem para esse problema exato. )

Outra maneira de fazer isso:

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

Atualização: para Java 8, agora você tem Coletores

Pode ser mais fácil anexar sempre. E então, quando você terminar seu loop, remova o caractere final. Toneladas menos condicionais dessa maneira também.

Você pode usar StringBuilder's deleteCharAt(int index)com índice sendolength() - 1

Talvez você esteja usando a ferramenta errada para o trabalho.

Isso é mais manual do que você está fazendo, mas é, de certa forma, mais elegante, se não um pouco "antiquado"

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

Isso é quase uma repetição desta pergunta do StackOverflow . O que você deseja é StringUtils e chame o método join .

StringUtils.join(strArr, ',');

Outra solução (talvez a mais 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]);
        }
    }

mantenha-o simples e use um padrão para loop:

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

ou apenas use apache commons-lang StringUtils.join ()

Os loops explícitos sempre funcionam melhor do que os implícitos.

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

Você deve agrupar tudo em uma declaração if, caso esteja lidando com uma matriz de comprimento zero.

Se você o converter em um loop de índice clássico, sim.

Ou você pode simplesmente excluir a última vírgula depois que terminar. Igual a:

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

Eu, eu apenas uso StringUtils.join()do commons-lang .

Você precisa de um separador de classes .

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

A implementação da classe Separatoré direta. Ele agrupa uma sequência retornada em todas as chamadas, toString()exceto a primeira, que retorna uma sequência vazia.

Com base em java.util.AbstractCollection.toString (), sai cedo para evitar o delimitador.

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

É eficiente e elegante, mas não tão evidente quanto algumas das outras respostas.

Aqui está uma solução:

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

Procure a primeira iteração :)  

Como o kit de ferramentas mencionado, no Java 8, agora temos coletores . Aqui está a aparência do código:

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

Eu acho que faz exatamente o que você está procurando, e é um padrão que você pode usar para muitas outras coisas.

Mais uma opção.

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

Muitas das soluções descritas aqui são um pouco exageradas, IMHO, especialmente aquelas que dependem de bibliotecas externas. Existe um bom idioma limpo e claro para obter uma lista separada por vírgulas que eu sempre usei. Ele se baseia no operador condicional (?):

Editar : Solução original correta, mas não ideal de acordo com os comentários. Tentando uma 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]); 

Lá está você, em 4 linhas de código, incluindo a declaração da matriz e o StringBuilder.

Aqui está uma referência do SSCCE que eu executei (relacionada ao que eu tinha que implementar) com estes resultados:

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

No meu exemplo, pelo menos, pular a verificação a cada iteração não é visivelmente mais rápido, especialmente para volumes sãos de dados, mas é mais 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)");
  }
}

Outra abordagem é manter o comprimento da matriz (se disponível) armazenado em uma variável separada (mais eficiente do que verificar novamente o comprimento toda vez). Em seguida, você pode comparar seu índice com esse comprimento para determinar se deseja adicionar ou não a vírgula final.

EDIT: Outra consideração é ponderar o custo de desempenho da remoção de um caractere final (que pode causar uma cópia de cadeia) contra a verificação condicional de cada iteração.

Se você estiver transformando apenas uma matriz em uma matriz delimitada por vírgula, muitos idiomas terão uma função de junção exatamente para isso. Transforma uma matriz em uma string com um delimitador entre cada elemento.

Nesse caso, não há realmente necessidade de saber se é a última repetição. Existem muitas maneiras de resolver isso. Uma maneira seria:

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

Dois caminhos alternativos aqui:

1: Utilitários de String do Apache Commons

2: mantenha um booleano chamado first, definido como true. Em cada iteração, se firstfor falso, anexe sua vírgula; depois disso, defina firstcomo false.

Como é uma matriz fixa, seria mais fácil simplesmente evitar o aprimorado para ... Se o Object for uma coleção, um iterador seria mais 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(",");
   }
}