Il codice è difficile da leggere e non è molto efficiente. Il parametro "dest" è confuso: viene passato come parametro, quindi viene cancellato e vengono aggiunti i risultati. Qual è il punto di essere un parametro? Perché non semplicemente restituire una nuova collezione? L'unico vantaggio che posso vedere è che il chiamante può determinare il tipo di raccolta. È necessario?
penso che questo codice può essere più chiaro e probabilmente più efficace scritto come segue:
public static Set<String> createSet(Collection<String> source) {
Set<String> destination = new HashSet<String>(source) {
private static final long serialVersionUID = 1L;
public boolean add(String o) {
if ("".equals(o)) {
return false;
}
return super.add(o);
}
};
return destination;
}
Un altro modo è quello di creare un tipo di set:
public class NonEmptyStringSet extends HashSet<String> {
private static final long serialVersionUID = 1L;
public NonEmptyStringSet() {
super();
}
public NonEmptyStringSet(Collection<String> source) {
super(source);
}
public boolean add(String o) {
if ("".equals(o)) {
return false;
}
return super.add(o);
}
}
Usage:
createSet(source);
new NonEmptyStringSet(source);
Il ritorno del set è più performante perché non è necessario prima creare un set temporaneo e quindi un annuncio d tutti alla collezione dest.
Il vantaggio del tipo NonEmptyStringSet è che è possibile continuare ad aggiungere stringhe e mantenere il controllo della stringa vuota.
Edit1:
Rimozione del "if (src.containsAll (distillata)) return;" codice introduce un "errore" quando si chiama il metodo con sorgente == dest; Il risultato è che fonte sarà vuoto Esempio:.
Collection<String> source = new ArrayList<String>();
source.add("abc");
copyStringCollectionAndRemoveDuplicates(source, source);
System.out.println(source);
EDIT2:
Ho fatto un piccolo benchmark che mostra che la mia implementazione è circa il 30% più veloce di una versione semplificata della tua implementazione iniziale Questo benchmark è un caso ottimale per la tua implementazione iniziale perché il gruppo di destinazione è vuoto, quindi non deve cancellarlo Inoltre, non prenderemo che la mia implementazione utilizzi HashSet invece di LinkedHashSet, il che rende la mia implementazione un po 'più veloce.
Codice
Benchmark:
public class SimpleBenchmark {
public static void main(String[] args) {
Collection<String> source = Arrays.asList("abc", "def", "", "def", "",
"jsfldsjdlf", "jlkdsf", "dsfjljka", "sdfa", "abc", "dsljkf", "dsjfl",
"js52fldsjdlf", "jladsf", "dsfjdfgljka", "sdf123a", "adfgbc", "dslj452kf", "dsjfafl",
"js21ldsjdlf", "jlkdsvbxf", "dsfjljk342a", "sdfdsa", "abxc", "dsljkfsf", "dsjflasd4");
int runCount = 1000000;
long start1 = System.currentTimeMillis();
for (int i = 0; i < runCount; i++) {
copyStringCollectionAndRemoveDuplicates(source, new ArrayList<String>());
}
long time1 = (System.currentTimeMillis() - start1);
System.out.println("Time 1: " + time1);
long start2 = System.currentTimeMillis();
for (int i = 0; i < runCount; i++) {
new NonEmptyStringSet(source);
}
long time2 = (System.currentTimeMillis() - start2);
System.out.println("Time 2: " + time2);
long difference = time1 - time2;
double percentage = (double)time2/(double) time1;
System.out.println("Difference: " + difference + " percentage: " + percentage);
}
public static class NonEmptyStringSet extends HashSet<String> {
private static final long serialVersionUID = 1L;
public NonEmptyStringSet() {
}
public NonEmptyStringSet(Collection<String> source) {
super(source);
}
@Override
public boolean add(String o) {
if ("".equals(o)) {
return false;
}
return super.add(o);
}
}
public static void copyStringCollectionAndRemoveDuplicates(
Collection<String> src, Collection<String> dest) {
Set<String> uniqueSet = new LinkedHashSet<String>(src.size());
for (String f : src)
if (!"".equals(f))
uniqueSet.add(f);
dest.addAll(uniqueSet);
}
}
Solo un commento minore, non correlato alla tua domanda: target e des hanno significati simili. Dal momento che stai copiando una stringa non vuota da destinazione a destinazione, forse può essere rinominata in src? –