Saya memiliki sebuah ArrayList<String>
, dan saya ingin menghapus berulang string dari itu. Bagaimana saya bisa melakukan ini?
Jika anda don't ingin duplikat dalam Koleksi
, anda harus mempertimbangkan mengapa anda're menggunakan Koleksi
yang memungkinkan duplikat. Cara termudah untuk menghapus elemen yang berulang-ulang adalah untuk menambahkan isi ke Set
(yang tidak akan memungkinkan duplikat) dan kemudian tambahkan Set
kembali ke ArrayList
:
Set<String> set = new HashSet<>(yourList);
yourList.clear();
yourList.addAll(set);
Tentu saja, ini menghancurkan urutan unsur-unsur dalam ArrayList
.
Meskipun mengkonversi ArrayList
ke HashSet
efektif menghilangkan duplikasi, jika anda perlu untuk melestarikan penyisipan order, I'd agak menyarankan anda untuk menggunakan varian ini
// list is some List of Strings
Set<String> s = new LinkedHashSet<>(list);
Kemudian, jika anda perlu untuk mendapatkan kembali sebuah Daftar
referensi, anda dapat menggunakan lagi konversi konstruktor.
Di Jawa 8:
List<String> deduped = list.stream().distinct().collect(Collectors.toList());
Harap dicatat bahwa kode hash-sama dengan kontrak untuk daftar anggota harus dihormati untuk penyaringan untuk bekerja dengan baik.
Misalkan kita memiliki daftar String
seperti:
List<String> strList = new ArrayList<>(5);
// insert up to five items to list.
Kemudian kita bisa menghapus duplikat elemen dalam beberapa cara.
List<String> deDupStringList = new ArrayList<>(new HashSet<>(strList));
LinkedHashSet
di tempat HashSet
Menggunakan Jambu BijiList<String> deDupStringList2 = Lists.newArrayList(Sets.newHashSet(strList));
List<String> deDupStringList3 = strList.stream().distinct().collect(Collectors.toList());
Catatan: jika kita ingin mengumpulkan hasilnya di a daftar spesifik pelaksanaan misal LinkedList
kemudian kita dapat memodifikasi contoh di atas sebagai:
List<String> deDupStringList3 = strList.stream().distinct()
.collect(Collectors.toCollection(LinkedList::new));
Kita dapat menggunakan parallelStream
juga dalam kode di atas tetapi tidak dapat memberikan diharapkan kinerja manfaat. Check this pertanyaan untuk lebih lanjut.
Jika anda don't ingin duplikat, gunakan Set bukan Daftar
. Untuk mengkonversi Daftar
untuk Mengatur
anda dapat menggunakan kode berikut:
// list is some List of Strings
Set<String> s = new HashSet<String>(list);
Jika benar-benar diperlukan, anda dapat menggunakan konstruksi yang sama untuk mengkonversi Set
kembali ke Daftar
.
Berikut ini's cara yang doesn't mempengaruhi anda klik disini untuk memesan:
ArrayList l1 = new ArrayList();
ArrayList l2 = new ArrayList();
Iterator iterator = l1.iterator();
while (iterator.hasNext()) {
YourClass o = (YourClass) iterator.next();
if(!l2.contains(o)) l2.add(o);
}
l1 adalah daftar asli, dan l2 adalah daftar tanpa diulang item (Pastikan YourClass telah sama dengan metode yang sesuai dengan apa yang anda inginkan untuk berdiri untuk kesetaraan)
Jawa 8 sungai memberikan cara yang sangat sederhana untuk menghapus duplikat elemen dari daftar. Menggunakan metode yang berbeda. Jika kita memiliki daftar kota-kota dan kita ingin menghapus duplikat dari daftar itu dapat dilakukan dalam satu jalur -
List<String> cityList = new ArrayList<>();
cityList.add("Delhi");
cityList.add("Mumbai");
cityList.add("Bangalore");
cityList.add("Chennai");
cityList.add("Kolkata");
cityList.add("Mumbai");
cityList = cityList.stream().distinct().collect(Collectors.toList());
Bagaimana untuk menghapus duplikat unsur-unsur dari arraylist
Ada juga ImmutableSet
dari Jambu sebagai pilihan (di sini adalah dokumentasi):
ImmutableSet.copyOf(list);
Hal ini dimungkinkan untuk menghapus duplikat dari arraylist tanpa menggunakan HashSet atau satu lagi arraylist.
Coba kode ini..
ArrayList<String> lst = new ArrayList<String>();
lst.add("ABC");
lst.add("ABC");
lst.add("ABCD");
lst.add("ABCD");
lst.add("ABCE");
System.out.println("Duplicates List "+lst);
Object[] st = lst.toArray();
for (Object s : st) {
if (lst.indexOf(s) != lst.lastIndexOf(s)) {
lst.remove(lst.lastIndexOf(s));
}
}
System.out.println("Distinct List "+lst);
Output adalah
Duplicates List [ABC, ABC, ABCD, ABCD, ABCE]
Distinct List [ABC, ABCD, ABCE]
ini dapat memecahkan masalah:
private List<SomeClass> clearListFromDuplicateFirstName(List<SomeClass> list1) {
Map<String, SomeClass> cleanMap = new LinkedHashMap<String, SomeClass>();
for (int i = 0; i < list1.size(); i++) {
cleanMap.put(list1.get(i).getFirstName(), list1.get(i));
}
List<SomeClass> list = new ArrayList<SomeClass>(cleanMap.values());
return list;
}
Mungkin sedikit berlebihan, tapi aku menikmati jenis masalah terisolasi. :)
Kode ini menggunakan Seperangkat sementara (untuk keunikan check) tapi menghilangkan unsur-unsur yang secara langsung di dalam daftar asli. Karena penghapusan elemen dalam ArrayList dapat menginduksi sejumlah besar array menyalin, menghapus(int)-metode dihindari.
public static <T> void removeDuplicates(ArrayList<T> list) {
int size = list.size();
int out = 0;
{
final Set<T> encountered = new HashSet<T>();
for (int in = 0; in < size; in++) {
final T t = list.get(in);
final boolean first = encountered.add(t);
if (first) {
list.set(out++, t);
}
}
}
while (out < size) {
list.remove(--size);
}
}
Sementara kita're pada itu, di sini's versi untuk LinkedList (banyak lebih baik!):
public static <T> void removeDuplicates(LinkedList<T> list) {
final Set<T> encountered = new HashSet<T>();
for (Iterator<T> iter = list.iterator(); iter.hasNext(); ) {
final T t = iter.next();
final boolean first = encountered.add(t);
if (!first) {
iter.remove();
}
}
}
Gunakan penanda antarmuka untuk hadir sebuah solusi terpadu untuk Daftar:
public static <T> void removeDuplicates(List<T> list) {
if (list instanceof RandomAccess) {
// use first version here
} else {
// use other version here
}
}
EDIT: saya kira generik-hal yang doesn't benar-benar menambah nilai apapun di sini.. Oh well. :)
public static void main(String[] args){
ArrayList<Object> al = new ArrayList<Object>();
al.add("abc");
al.add('a');
al.add('b');
al.add('a');
al.add("abc");
al.add(10.3);
al.add('c');
al.add(10);
al.add("abc");
al.add(10);
System.out.println("Before Duplicate Remove:"+al);
for(int i=0;i<al.size();i++){
for(int j=i+1;j<al.size();j++){
if(al.get(i).equals(al.get(j))){
al.remove(j);
j--;
}
}
}
System.out.println("After Removing duplicate:"+al);
}
Jika anda're bersedia untuk menggunakan pihak ketiga perpustakaan, anda dapat menggunakan metode yang berbeda()` di Eclipse Koleksi (sebelumnya GS Koleksi).
ListIterable<Integer> integers = FastList.newListWith(1, 3, 1, 2, 2, 1);
Assert.assertEquals(
FastList.newListWith(1, 3, 2),
integers.distinct());
Keuntungan menggunakan yang berbeda()
bukan mengkonversi satu Set dan kemudian kembali ke Daftar yang berbeda()
mempertahankan urutan asli Daftar, penahan kejadian pertama dari masing-masing elemen. It's dilaksanakan dengan menggunakan satu Set dan Daftar.
MutableSet<T> seenSoFar = UnifiedSet.newSet();
int size = list.size();
for (int i = 0; i < size; i++)
{
T item = list.get(i);
if (seenSoFar.add(item))
{
targetCollection.add(item);
}
}
return targetCollection;
Jika anda tidak dapat mengkonversi asli anda Daftar menjadi Gerhana Koleksi jenis, anda dapat menggunakan ListAdapter untuk mendapatkan API.
MutableList<Integer> distinct = ListAdapter.adapt(integers).distinct();
Catatan: saya terima untuk Eclipse Koleksi.
Ini tiga baris kode dapat menghapus duplikasi elemen dari ArrayList atau koleksi.
List<Entity> entities = repository.findByUserId(userId);
Set<Entity> s = new LinkedHashSet<Entity>(entities);
entities.clear();
entities.addAll(s);
Kode:
List<String> duplicatList = new ArrayList<String>();
duplicatList = Arrays.asList("AA","BB","CC","DD","DD","EE","AA","FF");
//above AA and DD are duplicate
Set<String> uniqueList = new HashSet<String>(duplicatList);
duplicatList = new ArrayList<String>(uniqueList); //let GC will doing free memory
System.out.println("Removed Duplicate : "+duplicatList);
Catatan: Pasti, akan ada memori overhead.
Ketika anda mengisi ArrayList, menggunakan kondisi untuk masing-masing elemen. Misalnya:
ArrayList< Integer > al = new ArrayList< Integer >();
// fill 1
for ( int i = 0; i <= 5; i++ )
if ( !al.contains( i ) )
al.add( i );
// fill 2
for (int i = 0; i <= 10; i++ )
if ( !al.contains( i ) )
al.add( i );
for( Integer i: al )
{
System.out.print( i + " ");
}
Kita akan mendapatkan sebuah array {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
Jika anda ingin menyimpan Pesanan anda maka itu adalah yang terbaik untuk menggunakan LinkedHashSet. Karena jika anda ingin lulus Daftar ini untuk Menyisipkan Query dengan Iterasi itu, pesanan akan dipertahankan.
Coba ini
LinkedHashSet link=new LinkedHashSet();
List listOfValues=new ArrayList();
listOfValues.add(link);
Konversi ini akan sangat membantu ketika anda ingin kembali Daftar tapi tidak satu Set.
ArrayList<String> city=new ArrayList<String>();
city.add("rajkot");
city.add("gondal");
city.add("rajkot");
city.add("gova");
city.add("baroda");
city.add("morbi");
city.add("gova");
HashSet<String> hashSet = new HashSet<String>();
hashSet.addAll(city);
city.clear();
city.addAll(hashSet);
Toast.makeText(getActivity(),"" + city.toString(),Toast.LENGTH_SHORT).show();
Berikut adalah kode tanpa menggunakan struktur data lain seperti set atau hashmap
for (int i = 0; i < Models.size(); i++){
for (int j = i + 1; j < Models.size(); j++) {
if (Models.get(i).getName().equals(Models.get(j).getName())) {
Models.remove(j);
j--;
}
}
}