por - separar una cadena de numeros en java

Eliminar cadenas duplicadas en la cadena de cadenas

Question

Estoy creando un programa basado en el procesamiento de cadenas en Java en el que necesito eliminar cadenas duplicadas de una matriz de cadenas. En este programa, el tamaño de todas las cadenas es el mismo.

La "matriz", que es una cadena de cadenas, contiene una serie de cadenas en las que dos cadenas se parecen. Entonces, usando el código de abajo, la cadena duplicada debe eliminarse pero no se elimina.

¿Cómo eliminar las cadenas duplicadas?

Estoy usando el siguiente código.

    for(int s=0;s<array.length-1;s++)
    {
        for(int m=0;m<array.length;m++)
        {
                for(int n=0;n<array[m].length();n++)
                {   
                    if(array[s].charAt(n)==array[m].charAt(n))
                    {
                      continue;
                    }
                    else 
                break;
        } 
        if(n==array[m].length())
        {
            ArrayUtils.removeElement(array, array[s]);
        }
    }

Answer 1

¿Por qué no eliminó la mayoría del bucle interno en favor de String.equals(String) ?

En la primera iteración está comparando la matriz [0] con la matriz [0] que son iguales, y se eliminaría. Luego comparará la matriz original [1] con todos los demás elementos de la matriz, y si son iguales, está eliminando la matriz [1] (no la otra).

Hay algunos problemas, si hay algunas cadenas duplicadas, está eliminando la primera, lo que reducirá el tamaño de la matriz sin reducir r , por lo que se omiten algunas de las cadenas de la matriz.

Usaría una estructura de datos que obliga a la unicidad, como un conjunto.

¿Qué pasará si tienes 3 cadenas iguales en tu matriz? No estoy seguro de qué pasará.

Creo que se encontraría con algunas ArrayIndexOutOfBoundsException s.

Answer 2

A menos que esto sea [homework] usaría un Set

String[] array =
Set<String> uniqueWords = new HashSet<String>(Arrays.asList(array));

Answer 3

Creo que la condición if al final debería ser if (n == (array [m] .length () - 1))

Habiendo dicho eso, parece que estás intentando implementar lo que hace el método String.equals () en tu bucle más interno.

Answer 4

Eliminar entero entero duplicado: esta es la respuesta perfecta /// Haris ///

public static void duplicateRemove(int[] arr) {
    int temp = 0;

    for (int i = 0; i < arr.length; i++) {
        for (int j = 0; j < arr.length; j++) {
            if (arr[i] < arr[j]) {
                temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }

    int count;
    for (int j = 0; j < arr.length;) {
        count = 1;
        for (int i = j + 1; i < arr.length; i++) {
            if (arr[i] == arr[j]) {
                count++;
            } else
                break;

        }
        System.out.println(arr[j] + " is :  " + count);
        j += count;
    }

}

Answer 5

Esto funcionara

array = new HashSet<String>(Arrays.asList(array)).toArray(new String[0]);

o simplemente use un HashSet lugar de una matriz.

Answer 6

La solución propuesta no mantiene el orden de los elementos. Si usa Java 8 o superior y desea mantener el orden, puede usar las secuencias de la siguiente manera:

array = Arrays.stream(array).distinct().toArray(String[]::new);

Ejemplo completo: https://www.javacodeexamples.com/java-string-array-remove-duplicates-example/849

Answer 7

import java.util.*;
public class Stringarray {

    public static void main(String args[]){

        String[] name = {"aim","rajesh","raju","aim"};

    Set<String> myset  = new HashSet<String>();
    Collections.addAll(myset,name);

       System.out.println(myset);
    }
}

Answer 8

     String[] arr = {"w10","w20","w10","w30","w20","w40","w50","w50"};
     List<String> arrList = new ArrayList<String>();
     int cnt= 0;
       //List<String> arrList = Arrays.asList(arr);
       List<String> lenList = new ArrayList<String>();
          for(int i=0;i<arr.length;i++){
        for(int j=i+1;j<arr.length;j++){
           if(arr[i].equals(arr[j])){
             cnt+=1;
           }                
        }
        if(cnt<1){
          arrList.add(arr[i]);
        }
          cnt=0;
        }

for(int k=0;k<arrList.size();k++){
            System.out.println("Array without Duplicates: "+arrList.get(k));
        }

Answer 9

Set<String> set = new HashSet<String>();
Collections.addAll(set, array);

o comienza con

for(int s=0;s<array.length-1;s++)
{
    for(int m=s + 1;m<array.length;m++)
    {

                if(array[s] != null && array[s].equals(array[m]))
                {
                  // array = ArrayUtils.removeElement(array, array[s]); --m;??
                  array[m] = null; // Mark for deletion later on
                }
    } 
}

Answer 10

• ¿Por qué no usas String.equals() para la comparación en lugar de iterar a través de los caracteres en las cadenas manualmente?
• Su lógica es realmente defectuosa: para la array[s] == "12345" y la array[m] == "123" afirmaría que son iguales
• además, en su bucle interno for(int m=0;m<array.length;m++) m también será igual a s en algún punto, por lo que comparará una cadena con ella misma

Estas notas asumen que es necesario implementar la lógica de eliminación con su propio código, ya que no se le permite usar la biblioteca de clases. Si este no es el caso, como otros lo notaron, usar un HashSet es el enfoque más simple.