Ik wil de operaties Union, Intersect, Difference en Reverse in Java implementeren.
Eerst heb ik 2 instanties van ArrayList<Integer>
a = [0,2,4,5,6,8,10]
b = [5,6,7,8,9,10]
een unie b moet c = [0,2,4,5,6,7,8,9,10]
een snijpunt b moet c = [5,8,10]
return teruggeven
een verschil b zou c = [0,2,4]
moeten opleveren
omgekeerde a = [10,8,6,5,4,2,0]
Zoiets.
Hoe implementeer je die methode in Java?
Update: ik moet beginnen met deze sjabloon:
package IntSet;
import java.util.ArrayList;
import java.util.Collection;
public class IntSet {
private ArrayList<Integer> intset;
public IntSet(){
intset = new ArrayList<Integer>();
}
public void insert(int x){
intset.add(x);
}
public void remove(int x){
//implement here
intset.indexOf(x);
}
public boolean member(int x){
//implement here
return true;
}
public IntSet intersect(IntSet a){
//implement here
return a;
}
public IntSet union(IntSet a){
//implement here
return a;
}
public IntSet difference(IntSet a){
//implement here
IntSet b = new IntSet();
return b;
}
Antwoord 1, autoriteit 100%
Ten eerste zijn de bewerkingen die u beschrijft (behalve omgekeerd) setbewerkingen, geen lijstbewerkingen, dus gebruik HashSet of (als u een bestelling nodig hebt) TreeSet.
Set<Integer> a = new TreeSet<Integer>(Arrays.asList(new Integer[]{0,2,4,5,6,8,10}));
Set<Integer> b = new TreeSet<Integer>(Arrays.asList(new Integer[]{5,6,7,8,9,10}));
//union
Set<Integer> c = new TreeSet<Integer>(a);
c.addAll(b);
System.out.println(c);
//intersection
Set<Integer> d = new TreeSet<Integer>(a);
d.retainAll(b);
System.out.println(d);
//difference
Set<Integer> e = new TreeSet<Integer>(a);
e.removeAll(b);
System.out.println(e);
//reverse
List<Integer> list = new ArrayList<Integer>(a);
java.util.Collections.reverse(list);
System.out.println(list);
Antwoord 2, autoriteit 57%
//Union
List<Integer> c = new ArrayList<Integer>(a.size() + b.size());
addNoDups(c,a);
addNoDups(c,b);
private void addNoDups(List<Integer> toAddTo,List<Integer> iterateOver) {
for(Integer num:iterateOver){
if(toAddTo.indexOf(num) == -1) {
toAddTo.add(num);
}
}
}
//intersection
List<Integer> c = new ArrayList<Integer> (a.size() > b.size() ?a.size():b.size());
c.addAll(a);
c.retainAll(b);
//difference a-b
List<Integer> c = new ArrayList<Integer> (a.size());
c.addAll(a);
c.removeAll(b);
Antwoord 3, autoriteit 38%
Als je Sets gebruikt (zoals je zou moeten, voor al deze behalve omgekeerde zijn Set-bewerkingen), Guavabiedt deze bewerkingen in zijn Setsklasse.
Set<Integer> union = Sets.union(set1, set2);
Set<Integer> intersection = Sets.intersection(set1, set2);
Set<Integer> difference = Sets.difference(set1, set2);
Al deze leveren niet-aanpasbare weergaven op, ondersteund door de originele sets.
Zie Guave Explained-> Verzamelingshulpprogramma’s-> Sets
Als lijsten zijn wat je hebt, kun je ze converteren naar een set door de kopieerconstructor te gebruiken die aanwezig is in alle standaardverzamelingen:
List<X> list = new ArrayList<>();
// fill up list here
Set<X> set = new HashSet<>(list);
Antwoord 4, autoriteit 11%
Veel antwoorden vertellen je dat je bibliotheken moet gebruiken die het werk voor je doen. Hoewel dit de juiste oplossing is voor de echte wereld, moet je er rekening mee houden dat je huiswerk maakt en dat je leraar waarschijnlijk wil dat je begrijpt hoe de functies zijn geschreven, niet alleen hoe je bibliotheken kunt vinden om het werk voor je te doen.
Dat gezegd hebbende, je hebt een goed begin met de code die je hebt laten zien. Laten we het probleem stap voor stap bekijken.
Weet u ten eerste waar de Java-documentatie zich bevindt? http://download.oracle.com/javase/1.4.2/docs /api/dit is van cruciaal belang, want zo kom je erachter welke functies wat doen. Hier is de link naar Java 1.4. Ik heb niet gezien welke versie je gebruikt, maar Java is achterwaarts compatibel, dus dit zou voldoende moeten zijn.
Zoek in de documenten het item ArrayList.
Nu we de API-documenten hebben, moeten we uw vraag opsplitsen. je hebt code gepost, dus ik zal het functie per functie behandelen.
insert() : moet je een geordende lijst hebben, of maakt de volgorde niet uit? Of bent u er zeker van dat de waarden op volgorde aan u worden verstrekt? Heb je al sorteeralgoritmen geleerd?
remove() : deze functie werkt niet. bekijk de ArrayList API en zie hoe u een item uit de lijst verwijdert. Gebruik die methode.
member() : uw lidmethode werkt niet. U moet elk item in de lijst controleren en bepalen of het huidige lid overeenkomt met het functieargument. Heb je iets geleerd over for-loops?
intersect() : ok, vertel me in het Engels wat intersect moet doen. Gebruik de beschrijving van de leraar niet als je het kunt helpen – gebruik je eigen woorden (let op voor anderen, dit is een oefening voor de OP om te leren programmeren, dus ga het alsjeblieft niet voor hem beantwoorden)
difference() : nogmaals, vertel me in het Engels wat het moet doen.
reverse() : nogmaals, geef me de Engelse beschrijving van wat dit zou moeten doen.
Zodra je Engelse beschrijvingen hebt, beschrijf je een algoritme dat het werk kan doen. schrijf het nog niet in Java. schrijf gewoon een algoritme, in het Engels, waarin je beschrijft hoe je het werk handmatig zou doen, met pen en papier.
probeer nu het algoritme om te zetten in Java-code.
Antwoord 5, autoriteit 5%
Ik laat het hier gewoon bij. Er is een nieuwe manier met java-8en streams
List<Integer> listA = Arrays.asList(0, 2, 4, 5, 6, 8, 10);
List<Integer> listB = Arrays.asList(5, 6, 7, 8, 9, 10);
List<Integer> intersection = listA.stream()
.filter(listB::contains)
.collect(Collectors.toList());
List<Integer> union = Stream.concat(listA.stream(), listB.stream())
.distinct().sorted()
.collect(Collectors.toList());
List<Integer> aDiffB = listA.stream()
.filter(i -> !listB.contains(i))
.collect(Collectors.toList());
System.out.println(intersection); // [5, 6, 8, 10]
System.out.println(union); // [0, 2, 4, 5, 6, 7, 8, 9, 10]
System.out.println(aDiffB); // [0, 2, 4]
Antwoord 6, autoriteit 4%
Dit fragment zal de samenvoeging van twee collecties vinden met behulp van de apache commons CollectionUtils.union-methode
Collection<String> totalFriends = CollectionUtils.union(yourFriends, myFriends);
Antwoord 7
De methoden addAll, retainAllen removeAllzijn de methoden die het meest worden gebruikt om union, intersecten differencein Java. Met Streams in Java 8+ heb je wat meer opties voor intersecten differencemet behulp van filterzoals aangegeven in een eerder antwoord.
Als je openstaat voor het gebruik van een bibliotheek van derden, werkt de volgende code met primitieve collecties die Eclipse Collectionswanneer versie 11.0 van de bibliotheek wordt uitgebracht.
@Test
public void unionIntersectDifferenceReverse()
{
IntList list1 = IntLists.immutable.with(0, 2, 4, 5, 6, 8, 10);
IntList list2 = IntLists.immutable.with(5, 6, 7, 8, 9, 10);
MutableIntSet set1 = list1.toSet();
MutableIntSet set2 = list2.toSet();
IntSet union = set1.union(set2);
IntSet intersection = set1.intersect(set2);
IntSet difference = set1.difference(set2);
IntList reversed = list1.toReversed();
Assert.assertEquals(IntSets.mutable.with(0, 2, 4, 5, 6, 7, 8, 9, 10), union);
Assert.assertEquals(IntSets.mutable.with(5, 6, 8, 10), intersection);
Assert.assertEquals(IntSets.mutable.with(0, 2, 4), difference);
Assert.assertEquals(IntLists.mutable.with(10, 8, 6, 5, 4, 2, 0), reversed);
}
Deze functionaliteit is recent bijgedragen aan primitieve Sets in Eclipse-collecties. De gekoppelde blog beschrijft hoe deze methoden worden geïmplementeerd op primitieve sets.
De volgende code gebruikt objectverzamelingen met omkaderde gehele getallen. Deze code werkt met Eclipse Collections-releases die vandaag beschikbaar zijn.
@Test
public void unionIntersectDifferenceReverseWithBoxedIntegers()
{
ImmutableList<Integer> list1 = Lists.immutable.with(0, 2, 4, 5, 6, 8, 10);
ImmutableList<Integer> list2 = Lists.immutable.with(5, 6, 7, 8, 9, 10);
MutableSet<Integer> set1 = list1.toSet();
MutableSet<Integer> set2 = list2.toSet();
MutableSet<Integer> union = set1.union(set2);
MutableSet<Integer> intersection = set1.intersect(set2);
MutableSet<Integer> difference = set1.difference(set2);
ImmutableList reversed = list1.toReversed();
Assert.assertEquals(Sets.mutable.with(0, 2, 4, 5, 6, 7, 8, 9, 10), union);
Assert.assertEquals(Sets.mutable.with(5, 6, 8, 10), intersection);
Assert.assertEquals(Sets.mutable.with(0, 2, 4), difference);
Assert.assertEquals(Lists.mutable.with(10, 8, 6, 5, 4, 2, 0), reversed);
}
Opmerking: ik ben een toegewijde voor Eclipse Collections.