En uppsättning är helt enkelt en samling unika föremål. Unikt betyder att inga två objekt kan ha samma värde. Beroende på implementeringen av uppsättningen kan den beställas eller inte. Java-uppsättningen, som en abstrakt datatyp (ADT), har några nyckeloperationer (där T representerar vilken datatyp som helst, t.ex. int, String eller vilket klassobjekt som helst): Java-uppsättningen som gränssnitt - 1
  • boolean add(T item): returnerar sant om objektet har lagts till i setet, och falskt om objektet redan fanns i setet.
  • boolean remove(T item): returnerar sant om objektet har tagits bort från setet och falskt annars (om objektet inte fanns i setet).
  • boolean contains(T item): returnerar sant om objektet är i uppsättningen och falskt annars.
  • boolean isEmpty(): returnerar sant om uppsättningen är tom och annars falsk.
Uppsättningarna i Java har ganska självförklarande funktionssignaturer (som de borde). Om du lägger till två identiska objekt till en uppsättning, kommer bara det första tillagda objektet att finnas i uppsättningen. Alla efterföljande försök att lägga till samma objekt kommer att ignoreras om inte objektet först tas bort. En av de vanligaste setoperationerna är att kontrollera om ett föremål är inom en given uppsättning. Funktionen contains()ger en utmärkt körtid för detta: O(1) eller O(log n) tidskomplexitet beroende på om implementeringen som används är en HashSeteller enTreeSet, respektive. Så vad kan ett set användas till? Tja, om du någon gång behöver hålla reda på många distinkta objekt - såsom ID, namn eller andra unika identifierare - och ofta kontrollera om ett objekt finns i en sådan samling, är en uppsättning troligen ett bra val. Här är ett exempel på användningen av en uppsättning: Föreställ dig att du har en lista med Studentobjekt som representerar alla elever i en viss klass. Var och en Studentkan ha ett unikt namn (sträng) och betyg (int) för den här klassen. Om du ofta vill referera till en lista över alla A-elever (betyg >=90) skulle det vara tråkigt att gå igenom den här listan och kontrollera varje elevs betyg varje gång. Istället kan du använda en HashSetav strängar som håller reda på alla A-elever i klassen, som sådan:
  • Varje gång elevernas betyg uppdateras kan du helt enkelt kontrollera om elevens nya betyg är större än eller lika med 90 eller inte.
    • Om så är fallet, lägg till dem i uppsättningen A-elever som använderadd()
      • Om de redan var A-student ignoreras denna operation helt enkelt.
    • Om inte, ta sedan bort dem från uppsättningen av A-elever som använderremove()
      • Om de inte var en A-student vid det här laget ignoreras denna operation helt enkelt.
Med ett sådant system skulle du alltid ha en uppdaterad uppsättning av alla 'A'-elever i din klass. Om du ville kolla om det gick bra för Johnny Appleseed i din klass så kunde du enkelt göra det genom att ringa contains(“Johnny Appleseed”)på setet. Naturligtvis är detta bara ett exempel på ett användningsfall för en uppsättning, och detta specifika problem med att hålla reda på A-elever skulle kunna lösas på andra sätt.

Implementeringar: HashSet i Java och Java TreeSet Exempel

Både HashSeti Java och TreeSeti Java kommer i java.utils package. Du kan importera dem som sådana: 

// imports everything from Java's util package, including HashSet and TreeSet
import java.util.*;
eller 

import java.util.HashSet; // imports only the Java HashSet
import java.util.TreeSet; // imports only the Java TreeSet
Den viktigaste skillnaden mellan Java HashSetoch Java TreeSetär att den TreeSetär sorterad, medan den HashSetinte är det. Det är därför som TreeSethar O(log n) tidskomplexitet för nyckeloperationer, medan den HashSethar O(1) eller konstant tidskomplexitet; måste TreeSethålla ordning hela tiden. Förutom tangentuppsättningsoperationerna som nämnts tidigare, har både HashSetoch TreeSeti Java några andra användbara funktioner:
  • void clear(): rensar uppsättningen av alla objekt.
  • int size(): returnerar antalet objekt i uppsättningen.
  • Object clone(): returnerar en ytlig kopia av setet.
  • Iterator iterator(): returnerar en iterator till uppsättningen, med början vid det första objektet.
Du kan tänka dig att hitta användningsområden för dessa funktioner i exemplet "lista över A-studenter": du kan ringa size()om du vill se hur många A-elever du hade, eller clear()om du vill rensa listan i slutet av terminen. Du kan använda clone()för att skapa och behålla en klon av listan över A-elever vid en specifik tidpunkt, till exempel under halvtidsrapporter (på så sätt förblir klonen inte uppdaterad tillsammans med originalet).

Exempel på Java HashSet

Här är ett kort exempel på en HashSetav Strings som används i Java: 

import java.util.HashSet;
class HashSetDemo {
    public static void main(String[] args)
    {
	  // create a HashSet of Strings
        HashSet<String> hs = new HashSet<String>();
  
        // Add elements using the add() method
        hs.add("Collin");
	  hs.add("Bob");
 	  hs.add("Abigail");
  
        // Duplicates will ignored; this statement is useless
        hs.add("Collin");
  
        
        System.out.println(hs);
	  System.out.println("Bob is in the set (T/F): " + hs.contains("Bob"));
  System.out.println("Max is in the set (T/F): " + hs.contains("Max"));


    }
}
Utgång: -------- 

[Collin, Bob, Abigail]
Bob is in the set (T/F): true
Max is in the set (T/F): false

Java TreeSet exempel

Java-exempel kan hjälpa dig att förstå teorin. Här är det korta exemplet på ett TreeSetav Strings som används i Java: 

import java.util.TreeSet;
class TreeSetDemo {
    public static void main(String[] args)
    {
	  // create a TreeSet of Strings
        TreeSet<String> ts = new TreeSet<String>();
  
        // Add elements using the add() method.
        ts.add("Collin");
	  ts.add("Bob");
 	  ts.add("Abigail");
  
        // Duplicates will ignored; this statement is useless
        ts.add("Collin");
  
        // printing the set prints the names in alphabetical order!
        System.out.println(ts); 
	  
	  System.out.println("Bob is in the set (T/F): " + ts.contains("Bob"));
  System.out.println("Max is in the set (T/F): " + ts.contains("Max"));
  System.out.println("Size of the set: " + ts.size());
 	  ts.clear();
	  System.out.println("Size of the set after clear(): " + ts.size());
        

    }
}
Utgång: ------- 

[Abigail, Bob, Collin]
Bob is in the set (T/F): true
Max is in the set (T/F): false
Size of the set: 3
Size of the set after clear(): 0
Det är allt! Hoppas detta hjälpte 😊