Home / Questions / 175951
Accepted
Orici
Asked: 2020-06-27 09:05:39 +0800 CST 2020-06-27 09:05:39 +0800 CST

Java - Filter repetitions in an array of strings keeping the order

  • 772

I am working with Java 8.

I need, having an array of strings whose content I do not know and in which there may or may not be repetitions, to obtain that content, without repetitions and without altering the original order. For example, if I had:

String[] strs = {"orange", "apple", "apple", "banana", "grape", "apple", "lemon"};

Should get:

{"orange", "apple", "banana", "grape", "lemon"};

I currently use the following method to filter repeats, but it tends to mess things up:

/**
 * Filters repeated strings in the array
 *
 * @param  arrStr
 * @return
 */
public static String[] filterRepeatedStr(String[] arrStr) {

    List<String> arr = Arrays.asList(arrStr);
    Set<String> hs   = new HashSet();
    hs.addAll(arr);

    return hs.toArray(new String[hs.size()]);
}
java

3 Answers

  1. Best Answer

    The problem is the use of HashSet, the option is the use of LinkedHashSet, since it LinkedHashSetstores elements based on insertion order:

       String[] strs = {"orange", "apple", "apple", "banana", "grape", "apple", "lemon"};

     List<String> arr = Arrays.asList(strs);
    Set<String> hs   = new LinkedHashSet ();
    hs.addAll(arr);

    As a result you would get:

       {orange, apple, banana, grape, lemon}

    Something important to comment on is that using HashSetit has better performance but it does not guarantee any order in the elements, on the other hand LinkedHashSetit does, but performance is sacrificed.

    • 0

  2. By using Stream it is made simple.

    public class FiltrarRepeticiones {
    public static void main(String[] args) {
        String[] strs = {"orange", "apple", "apple", "banana", "grape", "apple", "lemon"};
        List<String> list = Arrays.asList(strs);
        Stream<String> listaNueva = list.stream().distinct();
        listaNueva.forEach(fruta -> System.out.println(fruta));   
    } 
}

    Result: orange apple banana grape lemon

    I update. So you could work with functional interfaces . I'm going to give an example with the UnaryOperator interface , which receives a type and returns a value of the same type.

    public interface UnaryOperator<T> extends Function<T,T>

    Ex: 

    public class UnaryOperatorTest {
    public static void main(String[] args) {
        List<String> listaStr = 
                Arrays.asList("orange", "apple", "apple", "banana", "grape", "apple", "lemon");

        List<String> listStrAct = operadorUnaryStr(cadena -> cadena.toUpperCase(), listaStr);
        listStrAct.stream().distinct().forEach(str -> System.out.print(str+" "));

    }

    public static List<String> operadorUnaryStr(
                UnaryOperator<String> unaryOpt, List<String> lista){
        List<String> listaActualizada = new ArrayList<>();
        lista.forEach(str -> listaActualizada.add(unaryOpt.apply(str)));
        return listaActualizada;  
    }

}

    And we would obtain as a result... ORANGE APPLE BANANA GRAPE LEMON

    • 0

  3. With Streams you can remove repeated values ​​and have an array again without creating other collections. In addition, the Arrays library greatly facilitates the work of manipulating arrays.

    String[] strs = {"orange", "apple", "apple", "banana", "grape","apple","lemon"};
String[] str = Arrays.stream(strs)
            .distinct()
            .toArray(String[]::new);

System.out.println(Arrays.toString(str));
    • 0