जवाबों:
यदि आप डुप्लिकेट नहीं चाहते हैं Collection, तो आपको यह विचार करना चाहिए कि आप Collectionडुप्लिकेट का उपयोग क्यों कर रहे हैं । बार-बार तत्वों को निकालने का सबसे आसान तरीका यह है कि सामग्री को एक में जोड़ा जाए Set(जो डुप्लिकेट की अनुमति नहीं देगा) और फिर Setवापस इसमें जोड़ें ArrayList:
Set<String> set = new HashSet<>(yourList);
yourList.clear();
yourList.addAll(set);बेशक, यह तत्वों के क्रम को नष्ट कर देता है ArrayList।
public Set<Object> findDuplicates(List<Object> list) { Set<Object> items = new HashSet<Object>(); Set<Object> duplicates = new HashSet<Object>(); for (Object item : list) { if (items.contains(item)) { duplicates.add(item); } else { items.add(item); } } return duplicates; }
Listऔर Setकार्यान्वयन के प्रकारों के रूप में ArrayListऔर HashSetआपके उदाहरण में)।
new HashSet(al)इसे खाली करने और कॉल करने के लिए उपयोग करने के बजाय आप इसे साफ कर सकते हैं addAll।
Objectकई मूल्य हैं यदि उनमें से दो दोहराते हैं तो मैं उन्हें डुप्लिकेट मानता हूं (अन्य मूल्य अलग हो सकते हैं) और उपयोग Set?
हालांकि ArrayListएक HashSetप्रभावी ढंग से परिवर्तित डुप्लिकेट को हटाता है, अगर आपको प्रविष्टि क्रम को संरक्षित करने की आवश्यकता है, तो मैं आपको इस संस्करण का उपयोग करने का सुझाव दूंगा
// list is some List of Strings
Set<String> s = new LinkedHashSet<>(list);फिर, यदि आपको एक Listसंदर्भ वापस लेने की आवश्यकता है, तो आप फिर से रूपांतरण कंस्ट्रक्टर का उपयोग कर सकते हैं।
जावा 8 में:
List<String> deduped = list.stream().distinct().collect(Collectors.toList());कृपया ध्यान दें कि सूची सदस्यों के लिए हैशकोड-समान अनुबंध ठीक से काम करने के लिए फ़िल्टरिंग के लिए सम्मानित किया जाना चाहिए।
addAllहैं new TreeSet<String>(String.CASE_INSENSITIVE_ORDER)। जोड़ा गया पहला तत्व सेट में रहेगा, यदि आपकी सूची में "डॉग" और "डॉग" (उस क्रम में) TreeSetमें "डॉग" होगा। यदि आदेश संरक्षित किया जाना चाहिए, तो उत्तर में लाइन से पहले list.replaceAll(String::toUpperCase);।
मान लीजिए कि हमारे पास एक सूची है String:
List<String> strList = new ArrayList<>(5);
// insert up to five items to list. फिर हम कई तरीकों से डुप्लिकेट तत्वों को हटा सकते हैं।
List<String> deDupStringList = new ArrayList<>(new HashSet<>(strList));नोट: यदि हम प्रविष्टि क्रम को बनाए रखना चाहते हैं तो हमें इसके LinkedHashSetस्थान पर उपयोग करना होगाHashSet
List<String> deDupStringList2 = Lists.newArrayList(Sets.newHashSet(strList));List<String> deDupStringList3 = strList.stream().distinct().collect(Collectors.toList());नोट: मामले में हम एक में परिणाम एकत्र करना चाहते हैं विशिष्ट सूची कार्यान्वयन जैसे LinkedListफिर हम ऊपर के उदाहरण के रूप में संशोधित कर सकते हैं:
List<String> deDupStringList3 = strList.stream().distinct()
.collect(Collectors.toCollection(LinkedList::new));हम parallelStreamउपरोक्त कोड में भी उपयोग कर सकते हैं लेकिन यह अपेक्षित प्रदर्शन लाभ नहीं दे सकता है। अधिक के लिए इस प्रश्न की जाँच करें ।
parallel streamsहमेशा बेहतर प्रदर्शन दूंगा। लेकिन यह एक मिथक है। मुझे बाद में पता चला कि कुछ निश्चित परिदृश्य हैं जहां समानांतर धाराओं का उपयोग किया जाना चाहिए। इस परिदृश्य में समानांतर धाराएं कोई बेहतर प्रदर्शन नहीं देंगी। और हाँ समानांतर धाराएँ कुछ मामलों में वांछित परिणाम नहीं दे सकती हैं। List<String> deDupStringList3 = stringList.stream().map(String::toLowerCase).distinct().collect(Collectors.toList());इस मामले में उपयुक्त समाधान होना चाहिए
यदि आप डुप्लिकेट नहीं चाहते हैं, तो इसके बजाय सेट का उपयोग करेंList । एक को बदलने के Listलिए Setआप निम्नलिखित कोड का उपयोग कर सकते हैं:
// list is some List of Strings
Set<String> s = new HashSet<String>(list);यदि वास्तव में आवश्यक है तो आप उसी निर्माण का उपयोग कर सकते हैं ताकि Setपीठ को एक में परिवर्तित कर सकें List।
Setयहाँ इस्तेमाल नहीं किया जा सकता है।
आप इसे इस तरह भी कर सकते हैं, और ऑर्डर को संरक्षित कर सकते हैं:
// delete duplicates (if any) from 'myArrayList'
myArrayList = new ArrayList<String>(new LinkedHashSet<String>(myArrayList));जावा 8 स्ट्रीम एक सूची से डुप्लिकेट तत्वों को हटाने के लिए एक बहुत ही सरल तरीका प्रदान करते हैं। अलग विधि का उपयोग कर। यदि हमारे पास शहरों की एक सूची है और हम उस सूची से डुप्लिकेट को हटाना चाहते हैं, तो इसे एक ही पंक्ति में किया जा सकता है -
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());यहाँ एक तरीका है जो आपकी सूची क्रम को प्रभावित नहीं करता है:
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);
}एल 1 मूल सूची है, और एल 2 दोहराई जाने वाली वस्तुओं के बिना सूची है (सुनिश्चित करें कि आपके पास समानता है जो आप समानता के लिए खड़े होना चाहते हैं, उसी के अनुसार विधि है)
ArrayList<T>इसका उपयोग ArrayList2 के बजाय किया जाना चाहिए ) स्पष्ट इट्रेटर बनाने से इसका उपयोग करके बचा जा सकता है for (T current : l1) { ... }। यहां तक कि अगर आप Iteratorस्पष्ट रूप से उपयोग करना चाहते थे , iteradorतो गलत वर्तनी है।
HashSet या एक और arraylist का उपयोग किए बिना arraylist से डुप्लिकेट को निकालना संभव है ।
इस कोड को आज़माएं ..
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);आउटपुट है
Duplicates List [ABC, ABC, ABCD, ABCD, ABCE]
Distinct List [ABC, ABCD, ABCE]ImmutableSet.copyOf(lst).toList()।
indexOfपुनरावृत्त करता है lst।
एक विकल्प के रूप में अमरूदImmutableSet से भी है ( यहां प्रलेखन है):
ImmutableSet.copyOf(list);ImmutableSet.asList()विधि है, एक वापसी ImmutableList, यदि आपको इसे वापस एक की आवश्यकता है List।
इससे समस्या हल हो सकती है:
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;
}संभवत: थोड़ा ओवरकिल हो जाता है, लेकिन मैं इस तरह की अलग-थलग समस्या का आनंद लेता हूं। :)
यह कोड एक अस्थायी सेट (विशिष्ट जांच के लिए) का उपयोग करता है, लेकिन मूल सूची के अंदर सीधे तत्वों को हटा देता है। चूंकि ArrayList के अंदर एलिमेंट रिमूवल से भारी मात्रा में ऐरे को कॉपी किया जा सकता है, इसलिए रिम (int) -method से बचा जाता है।
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);
}
}जब हम इस पर हैं, यहाँ लिंक्डलिस्ट के लिए एक संस्करण है (एक बहुत अच्छा!):
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();
}
}
}सूची के लिए एकीकृत समाधान प्रस्तुत करने के लिए मार्कर इंटरफ़ेस का उपयोग करें:
public static <T> void removeDuplicates(List<T> list) {
if (list instanceof RandomAccess) {
// use first version here
} else {
// use other version here
}
}संपादित करें: मुझे लगता है कि जेनरिक-सामान वास्तव में यहाँ कोई मूल्य नहीं जोड़ते हैं .. ओह अच्छी तरह से। :)
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);
}यदि आप किसी तृतीय-पक्ष लाइब्रेरी का उपयोग करने के इच्छुक हैं, तो आप ग्रहण संग्रह (पूर्व में जीएस संग्रह) distinct()में विधि का उपयोग कर सकते हैं ।
ListIterable<Integer> integers = FastList.newListWith(1, 3, 1, 2, 2, 1);
Assert.assertEquals(
FastList.newListWith(1, 3, 2),
integers.distinct());distinct()किसी सेट में और फिर वापस सूची में परिवर्तित करने के बजाय उपयोग करने का लाभ यह है कि distinct()प्रत्येक सूची की पहली घटना को बरकरार रखते हुए, मूल सूची के आदेश को संरक्षित रखता है। यह एक सेट और एक सूची दोनों का उपयोग करके कार्यान्वित किया जाता है।
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;यदि आप अपनी मूल सूची को ग्रहण संग्रहों में परिवर्तित नहीं कर सकते हैं, तो आप समान API प्राप्त करने के लिए ListAdapter का उपयोग कर सकते हैं।
MutableList<Integer> distinct = ListAdapter.adapt(integers).distinct();नोट: मैं एक्लिप्स कलेक्शंस के लिए कमिट हूं।
कोड की यह तीन पंक्तियाँ ArrayList या किसी भी संग्रह से डुप्लिकेट किए गए तत्व को निकाल सकती हैं।
List<Entity> entities = repository.findByUserId(userId);
Set<Entity> s = new LinkedHashSet<Entity>(entities);
entities.clear();
entities.addAll(s);जब आप ArrayList भर रहे हों, तो प्रत्येक तत्व के लिए एक शर्त का उपयोग करें। उदाहरण के लिए:
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 + " ");
}हम एक सरणी {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10} प्राप्त करेंगे
यदि आप अपने ऑर्डर को संरक्षित करना चाहते हैं तो लिंक्डहैशसेट का उपयोग करना सबसे अच्छा है । क्योंकि यदि आप इस सूची को Iterating द्वारा एक सम्मिलित क्वेरी में पास करना चाहते हैं, तो आदेश संरक्षित किया जाएगा।
इसे इस्तेमाल करे
LinkedHashSet link=new LinkedHashSet();
List listOfValues=new ArrayList();
listOfValues.add(link);यह रूपांतरण तब बहुत सहायक होगा जब आप एक सूची नहीं बल्कि एक सेट लौटना चाहते हैं।
कोड:
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);नोट: निश्चित रूप से, मेमोरी ओवरहेड होगी।
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();LinkedHashSet ट्रिक करेगा।
String[] arr2 = {"5","1","2","3","3","4","1","2"};
Set<String> set = new LinkedHashSet<String>(Arrays.asList(arr2));
for(String s1 : set)
System.out.println(s1);
System.out.println( "------------------------" );
String[] arr3 = set.toArray(new String[0]);
for(int i = 0; i < arr3.length; i++)
System.out.println(arr3[i].toString());// आउटपुट: 5,1,2,3,4
List<String> result = new ArrayList<String>();
Set<String> set = new LinkedHashSet<String>();
String s = "ravi is a good!boy. But ravi is very nasty fellow.";
StringTokenizer st = new StringTokenizer(s, " ,. ,!");
while (st.hasMoreTokens()) {
result.add(st.nextToken());
}
System.out.println(result);
set.addAll(result);
result.clear();
result.addAll(set);
System.out.println(result);
output:
[ravi, is, a, good, boy, But, ravi, is, very, nasty, fellow]
[ravi, is, a, good, boy, But, very, nasty, fellow]इसका उपयोग आपकी कस्टम ऑब्जेक्ट सूची के लिए किया जाता है
public List<Contact> removeDuplicates(List<Contact> list) {
// Set set1 = new LinkedHashSet(list);
Set set = new TreeSet(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if (((Contact) o1).getId().equalsIgnoreCase(((Contact) o2).getId()) /*&&
((Contact)o1).getName().equalsIgnoreCase(((Contact)o2).getName())*/) {
return 0;
}
return 1;
}
});
set.addAll(list);
final List newList = new ArrayList(set);
return newList;
}आप अनुसरण में नेस्टेड लूप का उपयोग कर सकते हैं:
ArrayList<Class1> l1 = new ArrayList<Class1>();
ArrayList<Class1> l2 = new ArrayList<Class1>();
Iterator iterator1 = l1.iterator();
boolean repeated = false;
while (iterator1.hasNext())
{
Class1 c1 = (Class1) iterator1.next();
for (Class1 _c: l2) {
if(_c.getId() == c1.getId())
repeated = true;
}
if(!repeated)
l2.add(c1);
}सेट या हैशमैप जैसी किसी अन्य डेटा संरचना का उपयोग किए बिना यहां मेरा कोड है
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--;
}
}
} ArrayList<String> list = new ArrayList<String>();
HashSet<String> unique = new LinkedHashSet<String>();
HashSet<String> dup = new LinkedHashSet<String>();
boolean b = false;
list.add("Hello");
list.add("Hello");
list.add("how");
list.add("are");
list.add("u");
list.add("u");
for(Iterator iterator= list.iterator();iterator.hasNext();)
{
String value = (String)iterator.next();
System.out.println(value);
if(b==unique.add(value))
dup.add(value);
else
unique.add(value);
}
System.out.println(unique);
System.out.println(dup);यदि आप ArrayList से डुप्लिकेट निकालना चाहते हैं, तो नीचे दिए गए तर्क खोजें,
public static Object[] removeDuplicate(Object[] inputArray)
{
long startTime = System.nanoTime();
int totalSize = inputArray.length;
Object[] resultArray = new Object[totalSize];
int newSize = 0;
for(int i=0; i<totalSize; i++)
{
Object value = inputArray[i];
if(value == null)
{
continue;
}
for(int j=i+1; j<totalSize; j++)
{
if(value.equals(inputArray[j]))
{
inputArray[j] = null;
}
}
resultArray[newSize++] = value;
}
long endTime = System.nanoTime()-startTime;
System.out.println("Total Time-B:"+endTime);
return resultArray;
}