I have two lists ( not java lists, you can say two columns)
For example
**List 1** **Lists 2** milan hafil dingo iga iga dingo elpha binga hafil mike meat dingo milan elpha meat iga neeta.peeta I'd like a method that returns how many elements are same. For this example it should be 3 and it should return me similar values of both list and different values too.
Should I use hashmap if yes then what method to get my result?
Please help
P.S: It is not a school assignment :) So if you just guide me it will be enough
510 Answers
EDIT
Here are two versions. One using ArrayList and other using HashSet
Compare them and create your own version from this, until you get what you need.
This should be enough to cover the:
P.S: It is not a school assignment :) So if you just guide me it will be enough
part of your question.
continuing with the original answer:
You may use a java.util.Collection and/or java.util.ArrayList for that.
The retainAll method does the following:
Retains only the elements in this collection that are contained in the specified collection
see this sample:
import java.util.Collection;
import java.util.ArrayList;
import java.util.Arrays;
public class Repeated { public static void main( String [] args ) { Collection listOne = new ArrayList(Arrays.asList("milan","dingo", "elpha", "hafil", "meat", "iga", "neeta.peeta")); Collection listTwo = new ArrayList(Arrays.asList("hafil", "iga", "binga", "mike", "dingo")); listOne.retainAll( listTwo ); System.out.println( listOne ); }
}EDIT
For the second part ( similar values ) you may use the removeAll method:
Removes all of this collection's elements that are also contained in the specified collection.
This second version gives you also the similar values and handles repeated ( by discarding them).
This time the Collection could be a Set instead of a List ( the difference is, the Set doesn't allow repeated values )
import java.util.Collection;
import java.util.HashSet;
import java.util.Arrays;
class Repeated { public static void main( String [] args ) { Collection<String> listOne = Arrays.asList("milan","iga", "dingo","iga", "elpha","iga", "hafil","iga", "meat","iga", "neeta.peeta","iga"); Collection<String> listTwo = Arrays.asList("hafil", "iga", "binga", "mike", "dingo","dingo","dingo"); Collection<String> similar = new HashSet<String>( listOne ); Collection<String> different = new HashSet<String>(); different.addAll( listOne ); different.addAll( listTwo ); similar.retainAll( listTwo ); different.removeAll( similar ); System.out.printf("One:%s%nTwo:%s%nSimilar:%s%nDifferent:%s%n", listOne, listTwo, similar, different); }
}Output:
$ java Repeated
One:[milan, iga, dingo, iga, elpha, iga, hafil, iga, meat, iga, neeta.peeta, iga]
Two:[hafil, iga, binga, mike, dingo, dingo, dingo]
Similar:[dingo, iga, hafil]
Different:[mike, binga, milan, meat, elpha, neeta.peeta]If it doesn't do exactly what you need, it gives you a good start so you can handle from here.
Question for the reader: How would you include all the repeated values?
10You can try intersection() and subtract() methods from CollectionUtils.
intersection() method gives you a collection containing common elements and the subtract() method gives you all the uncommon ones.
They should also take care of similar elements
1Are these really lists (ordered, with duplicates), or are they sets (unordered, no duplicates)?
Because if it's the latter, then you can use, say, a java.util.HashSet<E> and do this in expected linear time using the convenient retainAll.
List<String> list1 = Arrays.asList( "milan", "milan", "iga", "dingo", "milan" ); List<String> list2 = Arrays.asList( "hafil", "milan", "dingo", "meat" ); // intersection as set Set<String> intersect = new HashSet<String>(list1); intersect.retainAll(list2); System.out.println(intersect.size()); // prints "2" System.out.println(intersect); // prints "[milan, dingo]" // intersection/union as list List<String> intersectList = new ArrayList<String>(); intersectList.addAll(list1); intersectList.addAll(list2); intersectList.retainAll(intersect); System.out.println(intersectList); // prints "[milan, milan, dingo, milan, milan, dingo]" // original lists are structurally unmodified System.out.println(list1); // prints "[milan, milan, iga, dingo, milan]" System.out.println(list2); // prints "[hafil, milan, dingo, meat]"If you are looking for a handy way to test the equality of two collections, you can use org.apache.commons.collections.CollectionUtils.isEqualCollection, which compares two collections regardless of the ordering.
Of all the approaches, I find using org.apache.commons.collections.CollectionUtils#isEqualCollection is the best approach. Here are the reasons -
- I don't have to declare any additional list/set myself
- I am not mutating the input lists
- It's very efficient. It checks the equality in O(N) complexity.
If it's not possible to have apache.commons.collections as a dependency, I would recommend to implement the algorithm it follows to check equality of the list because of it's efficiency.
Using java 8 removeIf
public int getSimilarItems(){ List<String> one = Arrays.asList("milan", "dingo", "elpha", "hafil", "meat", "iga", "neeta.peeta"); List<String> two = new ArrayList<>(Arrays.asList("hafil", "iga", "binga", "mike", "dingo")); //Cannot remove directly from array backed collection int initial = two.size(); two.removeIf(one::contains); return initial - two.size();
}Simple solution :-
List<String> list = new ArrayList<String>(Arrays.asList("a", "b", "d", "c")); List<String> list2 = new ArrayList<String>(Arrays.asList("b", "f", "c")); list.retainAll(list2); list2.removeAll(list); System.out.println("similiar " + list); System.out.println("different " + list2);Output :-
similiar [b, c]
different [f]Assuming hash1 and hash2
List< String > sames = whatever
List< String > diffs = whatever
int count = 0;
for( String key : hash1.keySet() )
{ if( hash2.containsKey( key ) ) { sames.add( key ); } else { diffs.add( key ); }
}
//sames.size() contains the number of similar elements.I found a very basic example of List comparison at List CompareThis example verifies the size first and then checks the availability of the particular element of one list in another.
public static boolean compareList(List ls1, List ls2){ return ls1.containsAll(ls2) && ls1.size() == ls2.size() ? true :false; }
public static void main(String[] args) { ArrayList<String> one = new ArrayList<String>(); one.add("one"); one.add("two"); one.add("six"); ArrayList<String> two = new ArrayList<String>(); two.add("one"); two.add("six"); two.add("two"); System.out.println("Output1 :: " + compareList(one, two)); two.add("ten"); System.out.println("Output2 :: " + compareList(one, two)); }
