TreeMap i Java

Java

Udover AbstractMap Class implementerer Javas TreeMap diskret kortgrænsefladen og NavigableMap. Afhængigt af hvilken konstruktør der bruges, sorteres kortet enten efter den naturlige rækkefølge af dets nøgler eller efter en komparator angivet på tidspunktet for oprettelse af kortet.

Dette er en effektiv metode til sortering og lagring af nøgleværdi-par. Uanset de angivne komparatorer, skal trækortets lagerrækkefølge være i overensstemmelse med ligeværdige, ligesom ethvert andet sorteret kort. Implementeringen af et trækort præsenteres som ikke-synkroniseret, fordi et kort skal synkroniseres eksternt, hvis det bruges af flere tråde samtidigt, og mindst én af trådene ændrer kortet grundlæggende.

Klasseerklæring for TreeMap

Lad os se på java.util.TreeMap-klasseerklæringen.

public class TreeMap<Key,Value> extends AbstractMap<Key,Value> implements NavigableMap<Key,Value>, Cloneable, Serializable

Klasseparametre for TreeMap

Lad os se på java.util.TreeMap-klassens parametre.

Dette korts slags nøgler er angivet med bogstavet K.
Typen af kortlagt værdi er V.

TreeMap-egenskaber

Følgende er nogle af trækortets nøglefunktioner:

Java Collections Framework inkluderer denne klasse.
Klassen udvider AbstractMap og implementerer kortgrænseflader såsom NavigableMap og SortedMap.
Fordi TreeMap (i modsætning til Map) ikke accepterer null-nøgler, opstår der en NullPointerException.
På den anden side kan flere null-værdier associeres med separate nøgler.
Indgangsparrene givet af denne klasses metoder og visninger er øjebliksbilleder af kortlægninger taget, da de blev oprettet.
Entry.setValue-metoden understøttes ikke.

Nu er det tid til at tale om Synchronized TreeMap. TreeMap-implementeringen er ikke synkroniseret. Dette betyder, at hvis flere tråde besøger et træsæt samtidigt og mindst én af opdateringerne af det, skal sættet synkroniseres eksternt. Collections.synchronizedSortedMap-metoden bruges almindeligvis til at opnå dette. Dette bør gøres på oprettelsestidspunktet for at undgå utilsigtet usynkroniseret adgang til sættet. Dette kan opnås ved at:

SortedMap m = Collections.synchronizedSortedMap(new TreeMap(...));

Du undrer dig sikkert over, hvordan TreeMap fungerer indeni.

Metoderne i et TreeMap returnerer en Iterator, der er fejlsikker til at få nøglesæt og værdier. ConcurrentModificationException vil blive kastet for enhver samtidig ændring. Datastrukturen i et TreeMap er et rød-sort træ. Hver node i træet har følgende egenskaber:

3 variables (key=Key, value=Value, boolean color=Color)
3 references  (Entry lft = Left, Entry rgt = Right, Entry parent = Parent)

TreeMap-konstruktører

Når vi opretter et TreeMap, skal vi først oprette et TreeMap-objekt. TreeMap-klassen indeholder flere konstruktører, der gør det muligt at oprette TreeMap. Konstruktørerne, der er tilgængelige i denne klasse, er som følger:

TreeMap()
TreeMap(Comparator comp)
TreeMap(Kort M)
TreeMap(Sorteret kort sm)

Lad os gennemgå hver enkelt individuelt, før vi implementerer hver konstruktør:

Den første konstruktør:TreeMap

Denne konstruktør opretter et tomt trækort, der vil blive sorteret efter nøglernes naturlige rækkefølge. Eksempel:

// Program for demonstrating the TreeMap using the Default Constructor

// Importing required classes
import java.util.*;
import java.util.concurrent.*;

// TreeMapImplementation is the Main class

public class Codeunderscored {

	// Method one showing the TreeMap constructor
	static void CodeFirstConstructor()
	{
		// Creation of an empty TreeMap
		TreeMap<Integer, String> treeMap
			= new TreeMap<Integer, String>();

		// Mapping string values to int keys
		// using put() method
		treeMap.put(1, "Code");
		treeMap.put(18, "Underscored");
		treeMap.put(16, "Coding");
		treeMap.put(34, "Java");
		treeMap.put(12, "Extravaganza");

		// how to print the TreeMap elements
		System.out.println(" The TreeMap is as follows: " + treeMap);
	}

	// Method Two: The primary driver method
	public static void main(String[] args)
	{
		System.out.println("TreeMap using the "+ "TreeMap() constructor:\n");

		// Calling constructor
		CodeFirstConstructor();
	}
}

Den anden konstruktør:TreeMap(Comparator comp)

Denne konstruktør er ansvarlig for at skabe et tomt TreeMap-objekt med noder, der kræver en ekstern sorteringsrækkefølgespecifikation.

// Program for demonstrating TreeMap using the Comparator Constructor

//First, import the needed classes
import java.util.*;
import java.util.concurrent.*;

// Class 1: This is the helper class for CodeStudent
class CodeStudent {

	// CodeStudent's attributes
	int c_rollno;
	String c_name, c_address;

	// Constructor
	public CodeStudent(int c_rollno, String c_name, String c_address)
	{

		// This keyword refers to current object itself
		this.c_rollno = c_rollno;
		this.c_name = c_name;
		this.c_address = c_address;
	}

	// class's method for printing CodeStudent details
	public String toString()
	{
		return this.c_rollno + " " + this.c_name + " "
			+ this.c_address;
	}
}

// Class Two: This is the helper class for implementing a Comparator
class CodeSortByRoll implements Comparator<CodeStudent> {

	// responsible for sorting the student's roll number in ascending order
	public int compare(CodeStudent aVar, CodeStudent bVar)
	{
		return aVar.c_rollno - bVar.c_rollno;
	}
}

// Class Three: This is the Main class
public class Code {

	// here, we call the constructor inside main()
	static void CodeSecondConstructor()
	{
		// Creation of an empty TreeMap
		TreeMap<CodeStudent, Integer> treeMap
			= new TreeMap<CodeStudent, Integer>(
				new CodeSortByRoll());

		// Mapping string values to int keys
		treeMap.put(new CodeStudent(1, "Joy", "Manchester"), 2);
		treeMap.put(new CodeStudent(2, "Green", "LA"), 3);
		treeMap.put(new CodeStudent(3, "Tyson", "New York"), 1);

		// Print the TreeMap elements
		System.out.println(" The TreeMap is: " + treeMap);
	}

	// The driver;s main method
	public static void main(String[] args)
	{

		System.out.println("The TreeMap using "
						+ "TreeMap(Comparator)"
						+ " constructor:\n");
		CodeSecondConstructor();
	}
}

Den tredje konstruktør:TreeMap (Map M)

Denne konstruktør bruges til at udfylde et TreeMap med indgange fra et specificeret kort "M", som vil blive sorteret efter nøglernes naturlige rækkefølge.

Eksempel

// Program for illustrating the TreeMap through the Default Constructor

//First, Import the required classes
import java.util.*;
import java.util.concurrent.*;

// This is the Main class
public class CodeTreeMapImplementation {

	// Method 1: illustrates the constructor<Map>

	static void CodeThirdConstructor()
	{
		// Creation of an empty HashMap
		Map<Integer, String> hashMap
			= new HashMap<Integer, String>();

		// using the put() method to Map string values to respective int keys
		hashMap.put(8, "Code");
		hashMap.put(3, "Underscored");
		hashMap.put(7, "Coding");
		hashMap.put(11, "Challenge");
		hashMap.put(5, "2022");

		// Creation of the TreeMap by using the Map
		TreeMap<Integer, String> treeMap
			= new TreeMap<Integer, String>(hashMap);

		// Printing the TreeMap elements
		System.out.println("The TreeMap is: " + treeMap);
	}

	// Method 2: This is the driver's main method
	public static void main(String[] args)
	{

		System.out.println(" The TreeMap using the "
						+ "TreeMap(Map)"
						+ " constructor:\n");

		CodeThirdConstructor();
	}
}

Den fjerde konstruktør:TreeMap(SortedMap sm)

Denne konstruktør udfylder et TreeMap med elementerne fra det angivne sorterede kort, gemt i samme rækkefølge som det sorterede kort.

// Program for illustrating the TreeMap throughout the SortedMap Constructor

// First, Import the needed classes
import java.util.*;
import java.util.concurrent.*;


// TreeMapImplementation- Main class
public class Codeunderscored {

	// Method for showing TreeMap(SortedMap) constructor

	static void CodeFourthConstructor()
	{
		// Creating a SortedMap
		SortedMap<Integer, String> sortedMap
			= new ConcurrentSkipListMap<Integer, String>();

		// using the put() method for mapping values of type string to int keys
		
		sortedMap.put(8, "Code");
		sortedMap.put(3, "Underscored");
		sortedMap.put(7, "Coding");
		sortedMap.put(11, "Challenge");
		sortedMap.put(5, "2022");

		// Creation of the TreeMap using the SortedMap
		TreeMap<Integer, String> treeMap
			= new TreeMap<Integer, String>(sortedMap);

		// Printing of the elements of the TreeMap
		System.out.println("The TreeMap is: " + treeMap);
	}

	// Method 2: The driver's Main method
	public static void main(String[] args)
	{

		System.out.println("This is the TreeMap using the: "
						+ "TreeMap(SortedMap)"
						+ " constructor:\n");

		CodeFourthConstructor();
	}
}

TreeMap-klassens metoder

clear()

Metoden rydder kortet og fjerner alle tilknytninger fra trækortet.

klone()

En overfladisk kopi af dette TreeMap returneres med denne metode.

containsKey(Objektnøgle)

Hvis dette kort har en tilknytning til den medfølgende nøgle, returnerer den sand.

containsValue(Objektværdi)

Hvis dette kort er ansvarligt for at tilknytte en eller flere nøgler til den angivne værdi, returnerer det sandt.

entrySet()

Denne metode er ansvarlig for at returnere en fast visning af tilknytningerne på dette kort.

firstKey()

Returnerer det aktuelt sorterede korts første (laveste) nøgle.

get(Objektnøgle)

Returnerer den værdi, som dette kort knytter den medfølgende nøgle til.

headMap(Object key_value)

Metoden returnerer en visning af kortudsnittet, der er strengt mindre end parameteren nøgleværdi.

keySet()

Metoden returnerer en Set-repræsentation af trækortets nøgler.

lastKey()

Returnerer det aktuelt sorterede korts sidste (højeste) nøgle.

put(Objektnøgle, Objektværdi)

En kortlægning indsættes på et kort på denne måde.

putAll(Map map)

Alle kortlægninger fra det angivne kort kopieres til dette kort.

fjern(Objektnøgle)

Hvis dette TreeMap har en tilknytning til denne nøgle, fjernes det.

størrelse()

Antallet af nøgleværditilknytninger i dette kort returneres.

subMap((K startKey, K endKey)

Metoden returnerer kortdelen med nøgler fra startKey til endKey, inklusive og eksklusive.

værdier()

Denne metode har til opgave at returnere en samlingsvisning af værdierne i dette kort.

Følgende programmer viser dig, hvordan du opretter, indsætter og navigerer gennem TreeMap-implementeringen.

Eksempel:Program til illustration af operationerne i TreeMap

// TreeMap operations include: Creation, insertion,  searching, and traversal

//First,  importing the necessary classes
import java.util.*;
import java.util.concurrent.*;

// This is the class's main implementation of the TreeMap
public class Codeunderscored {

	// Declaration of a TreeMap
	static TreeMap<Integer, String> treeMap;

	// Method One: Creation of a TreeMap
	static void CodeCreate()
	{

		// Creating an empty TreeMap
		treeMap = new TreeMap<Integer, String>();

		// Display message only
		System.out.println("TreeMap has been created successfully");
	}

	// Method Two: Inserting values in the TreeMap
	static void CodeInsert()
	{

		// using put() method to map values of string type to int keys
		treeMap.put(8, "Code");
		treeMap.put(3, "Underscored");
		treeMap.put(7, "Coding");
		treeMap.put(11, "Challenge");
		treeMap.put(5, "2022");


		// Display message only
		System.out.println("\nPrinting the Elements successfully"
						+ " after initial insert to the TreeMap");
	}

	// Method three: / searching for a key in the givenTreeMap
	static void CodeSearch(int key)
	{

		// looking for the key
		System.out.println("\nThis is the key \"" + key
						+ "\" present? "
						+ treeMap.containsKey(key));
	}

	// Method Four: searching for value in the provided TreeMap
	static void CodeSearch(String value)
	{

		// Checking for the value
		System.out.println("\nThis is the value \"" + value
						+ "\" present? "
						+ treeMap.containsValue(value));
	}

	// Method Five: displaying elements in the provided TreeMap
	static void CodeDisplay()
	{

		// showing the TreeMap
		System.out.println("\nShowing the TreeMap:");
		System.out.println("The TreeMap is: " + trerMap);
	}

	// Method Six: traversing through the TreeMap
	static void CodeTraverse()
	{

		// showing message explicitly
		System.out.println("\nTreeMap Traversal:");

		for (Map.Entry<Integer, String> eVar :
			treeMap.entrySet())
			System.out.println(eVar.getKey() + " "
							+ eVar.getValue());
	}

	// Method 7: This is the driver's Main method
	public static void main(String[] args)
	{

		// Calling the above-defined methods inside the main()

		// Creation of a TreeMap
		CodeCreate();

		// Insertion of values in the TreeMap
		CodeInsert();

		// searching for key "2022" in the provided TreeMap
		CodeSearch(2022);

		// Searching for the value "Coding" in the TreeMap
		CodeSearch("Coding");

		// Displaying the TreeMap's elements
		CodeDisplay();

		// TreeMap Traversal
		CodeTraverse();
	}
}

Brug af TreeMap til at udføre forskellige operationer

Det er nu muligt at begrænse den slags objekter, der kan placeres i TreeMap takket være fremkomsten af Generics i Java 1.5. Lad os se på at bruge TreeMap til at udføre nogle få almindelige handlinger.

Operation One:Tilføjelse af elementer

Metoden put() kan tilføje et element til TreeMap. I TreeMap er indsættelsesrækkefølgen dog ikke bevaret. Internt sammenlignes og sorteres nøglerne i stigende rækkefølge for hvert element. De almindelige metoder til at tilføje elementer omfatter:

put() - Sætter den angivne nøgle/værdi-tilknytning (indtastning) i kortet.
PutAll() - Sætter alle indgange fra et specificeret kort på dette kort.
PutIfAbsent() – Hvis den leverede nøgle ikke er til stede i kortet, tilføjer putIfAbsent() den angivne nøgle/værditilknytning til kortet.

// Program for demonstrating the addition of Elements  in TreeMap through the put() Method

// First, import the necessary classes
import java.util.*;

// This is the Main class
class Codeunderscored {

	// This is the driver's Main method
	public static void main(String args[])
	{
		// Initialization of a given TreeMap by  default
		TreeMap treeMap = new TreeMap();

		// using the put() method to Insert  elements in TreeMap
		treeMap.put(3, "Code");
		treeMap.put(2, "Underscored");
		treeMap.put(1, "Coding");

		// Initializing  a TreeMap through use of Generics
		TreeMap<Integer, String>  treeMapTwo
			= new TreeMap<Integer, String>();

		// using the method, "put()" to insert elements in the TreeMap given
		treeMapTwo.put(new Integer(3), "Code");
		treeMapTwo.put(new Integer(2), "Underscored");
		treeMapTwo.put(new Integer(1), "Coding");

		// Printing the elements of both TreeMaps

		// Tree Map One
		System.out.println(treeMap);
		// Tree Map Two
		System.out.println(treeMapTwo);
	}
}


import java.util.TreeMap;

class CodeAdd {

    public static void main(String[] args) {

        //Making an even-numbered TreeMap
        TreeMap<String, Integer> treeMap = new TreeMap<>();

        // Making use of the put() method
        treeMap.put("Eight", 8);
        treeMap.put("Twelve", 12);

        // making use of the putIfAbsent() ethod
        treeMap.putIfAbsent("Six", 6);
        System.out.println("TreeMap of even numbers: " + treeMap);

        //Making a number TreeMap
        TreeMap<String, Integer> numbers = new TreeMap<>();
        treeMap.put("One", 1);

        // Using the putAll() method
        numbers.putAll(treeMap);
        System.out.println("TreeMap of of the given numbers: " + treeMap);
    }
}

Operation Two:TreeMap Element Access

Brug af værdier(), keySet() og entrySet()

entrySet() – returnerer en samling af alle nøgle/værdi-tilknytninger (entry) for en trækortnøgle.
keySet()- returnerer en samling af alle nøglerne i et trækort.
værdier() – leverer en samling af et trækorts kort.

import java.util.TreeMap;

class CodeElementAccess {

    public static void main(String[] args) {
        TreeMap<String, Integer> treeMap = new TreeMap<>();

        treeMap.put("Eleven", 11);
        treeMap.put("Twelve", 12);
        treeMap.put("Thirteen", 13);

        System.out.println("The TreeMap is: " + treeMap);

        // utilizing the entrySet() method
        System.out.println("The Key/Value mappings include: " + treeMap.entrySet());

        // utilizing the keySet() method
        System.out.println("The Keys include: " + treeMap.keySet());

        // utilizing the values() method
        System.out.println("The Values Include: " + treeMap.values());
    }
}

Brug af funktionerne get() og getOrDefault()

get() – Returnerer den værdi, der svarer til den leverede nøgle. Hvis nøglen ikke kan hentes, returneres null.
getOrDefault() – Henter standardværdien for den angivne nøgle. Hvis nøglen ikke kan findes, returneres standardværdien.

For eksempel,

import java.util.TreeMap;

class CodeElementAccessTwo {

    public static void main(String[] args) {

        TreeMap<String, Integer> treeMap = new TreeMap<>();
        treeMap.put("Eleven", 11);
        treeMap.put("Twelve", 12);
        treeMap.put("Thirteen", 13);
        System.out.println("The TreeMap is: " + treeMap);

        // Using get()
        int valOne = numbers.get("Twelve");
        System.out.println("Using get(): " + valOne);

        // Using getOrDefault()
        int valTwo = numbers.getOrDefault("Ten", 10);
        System.out.println("Using getOrDefault(): " + valTwo);
    }
}

Metoden getOrDefault() kan ikke finde nøglen Ten i dette tilfælde. Som et resultat returneres standardtallet 10.

Operation tre:Ændring af elementer

Hvis vi ønsker at opdatere et element, efter at det er blevet tilføjet, kan vi gøre det ved at bruge put()-metoden til at tilføje det igen. Fordi nøglerne bruges til at indeksere elementerne i træoversigten, kan værdien af nøglen ændres ved blot at tilføje den opdaterede værdi for den nøgle, vi ønsker at ændre.

// program for Illustrating how to Updat TreeMap elements using the put() Method

// First, import the needed classes
import java.util.*;

// This is the Main class
class CodeUnderscored {

	// Main driver method
	public static void main(String args[])
	{
		// use Generics in the initialization of a TreeMap
		TreeMap<Integer, String> treeMap
			= new TreeMap<Integer, String>();

		// Inserting the elements in Map
		// using put() method
		treeMap.put(3, "Code");
		treeMap.put(2, "Code");
		treeMap.put(1, "Code");

		// Printing of all the current elements in the map
		System.out.println(treeMap);

		// Insertion of  the element at the specified place corresponding to the key given
		treeMap.put(2, "Underscored");

		// Now, print the Maps' updated elements
		System.out.println(treeMap);
	}
}

Operation fire:Elementfjernelse

Metoden remove() kan slette et element fra trækortet. Hvis nøgleværdien er til stede i kortet, fjerner denne metode tilknytningen for nøglen fra trækortet.

Eksempel

// Program for Illustrating Elements' Removal in the TreeMap using the method remove()

// First, importing the necessary classes
import java.util.*;

// This is the Main class
class CodeUnderscored {

	// This is the driver's Main method
	public static void main(String args[])
	{
	
		// Employ Generics to initialize a TreeMap
		TreeMap<Integer, String> treeMap
			= new TreeMap<Integer, String>();

		// Inserting the elements
		// using put() method
		treeMap.put(3, "Code");
		treeMap.put(2, "Underscored");
		treeMap.put(1, "Coding");
		treeMap.put(4, "2022");

		// All the Map elements require printing
		System.out.println(treeMap);

		// Removal of the element that corresponds to the provided key
		treeMap.remove(2);

		// The updated TreeMap can now be Printed
		System.out.println(treeMap);
	}
}

Operation Five:Iteration gennem TreeMap

Der er flere metoder til at gentage kortet. Den mest kendte metode er at bruge en for-hver-løkke til at få nøglerne. GetValue()-metoden er udpeget til at bestemme nøglens værdi.

Eksempel

//  Program for Illustrating  Iteration over the TreeMap

// First, import the necessary classes
import java.util.*;

// This is the Main class
class CodeUnderscored {

	// This is the driver's Main method
	public static void main(String args[])
	{
		// Employ Generics to initialize a TreeMap
		TreeMap<Integer, String> treeMap
			= new TreeMap<Integer, String>();
		// use the method, put(), to insert the element's
		treeMap.put(3, "Code");
		treeMap.put(2, "Underscored");
		treeMap.put(1, "Coding");

		// Use the entrySet() Method in a for-each loop traversal of the Map
		for (Map.Entry mapElement : treeMap.entrySet()) {

			int keyVar = (int)mapElement.getKey();

			//  locating the value
			String valueVar = (String)mapElement.getValue();

			// Printing the keyVar and valueVar
			System.out.println(keyVar + " : " + valueVar);
		}
	}
}

Komparator for TreeMaps

Trækortelementer er arrangeret organisk i alle ovenstående tilfælde (i stigende rækkefølge). Vi kan dog ændre rækkefølgen af tasterne. Vi bliver nødt til at lave vores komparatorklasse afhængigt af, hvordan et trækorts nøgler er arrangeret. For eksempel,

import java.util.TreeMap;
import java.util.Comparator;

class CodeCompartor {

    public static void main(String[] args) {

        // Using a custom comparator to create a treemap
        TreeMap<String, Integer> treeMap = new TreeMap<>(new CustomComparator());

        treeMap.put("Eleventh", 11);
        treeMap.put("Twelveth",12);
        treeMap.put("Thirteenth", 13);
        treeMap.put("Fourteenth", 14);
        System.out.println("TreeMap: " + treeMap);
    }

    // Constructing a comparator class
    public static class CodeComparator implements Comparator<String> {

        @Override
        public int compare(String numberOne, String numberTwo) {
            int valVar =  numberOne.compareTo(numberTwo);

            // reversing the order of elements
            if ( valVar > 0) {
                return -1;
            }
            else if ( valVar < 0) {
                return 1;
            }
            else {
                return 0;
            }
        }
    }
}

Eksempel:Java TreeMap

import java.util.*;  

class CodeTreeMap1{  

  public static void main(String args[]){  
    TreeMap<Integer,String> treeMap=new TreeMap<Integer,String>();    
    treeMap.put(02,"Green");    
    treeMap.put(05,"Joy");    
    treeMap.put(07,"Bright");    
    treeMap.put(09,"Lucy");    

    for(Map.Entry m:treeMap.entrySet()){    
      System.out.println(m.getKey()+" "+m.getValue());    
    }    
  }  
}

Eksempel:Java TreeMap remove()

import java.util.*;  
public class CodeTreeMap {  

  public static void main(String args[]) {  

    TreeMap<Integer,String> treeMap=new TreeMap<Integer,String>();    
    treeMap.put(02,"Green");    
    treeMap.put(05,"Joy");    
    treeMap.put(07,"Bright");    
    treeMap.put(09,"Lucy");    

    System.out.println(" Results prior to invoking the remove() method");  
    for(Map.Entry m:treeMap.entrySet())  
    {  
      System.out.println(m.getKey()+" "+m.getValue());      
    }  
    map.remove(02);      
    System.out.println("Results proceeding the invoking  of the remove() method");  
    for(Map.Entry m:treeMap.entrySet())  
    {  
      System.out.println(m.getKey()+" "+m.getValue());      
    }  
  }  
}

Eksempel:Java TreeMap NavigableMap

import java.util.*;  
class CodeTreeMap{  

  public static void main(String args[]){  
    NavigableMap<Integer,String> treeMap=new TreeMap<Integer,String>();    



    treeMap.put(02,"Green");    
    treeMap.put(05,"Joy");    
    treeMap.put(07,"Bright");    
    treeMap.put(09,"Lucy");      

    //Keeps the descending order  
    System.out.println("descendingMap: "+treeMap.descendingMap());  

    //Key-value pairs having keys that are less than or equal to the specified key are returned.
    System.out.println("headMap: "+treeMap.headMap(02,true));  

    //Returns key-value pairs with keys equal to or greater than the supplied key.
    System.out.println("tailMap: "+treeMap.tailMap(02,true));  

    //responsible for returning the count of key-value pairs between the provided keys.
    System.out.println("subMap: "+treeMap.subMap(09, false, 02, true));   
  }  
}

Eksempel:Java TreeMap SortedMap

import java.util.*;

class CodeTreeMap{  

  public static void main(String args[]){  

    SortedMap<Integer,String> treeMap=new TreeMap<Integer,String>();    

    treeMap.put(02,"Green");    
    treeMap.put(05,"Joy");    
    treeMap.put(07,"Bright");    
    treeMap.put(09,"Lucy");

    //Key-value pairs with keys smaller than the specified key are returned.
    System.out.println("The headMap is: "+map.headMap(02));  

    //Returns key-value pairs with keys equal to or greater than the supplied key.
    System.out.println("The tailMap is: "+map.tailMap(02));  

    //responsible for returning the count of key-value pairs between the provided keys.
    System.out.println("The subMap is: "+map.subMap(09, 02));    
  }  
}

Eksempel:Java TreeMap Laptop

import java.util.*;    

class Laptop {    
  int id;    
  String name,author,publisher;    
  int quantity;    
  public Laptop(int id, String name, String model, String manufacturer, int quantity) {    
    this.id = id;    
    this.name = name;    
    this.model = model;    
    this.manufacturer = manufacturer;    
    this.quantity = quantity;    
  }    
}    
public class CodeMap {    

  public static void main(String[] args) {    
    //Creating map of Laptops    
    Map<Integer,Laptop> treeMap=new TreeMap<Integer,Laptop>();    

    //Creating Laptops    
    Laptop laptopOne=new Laptop(1,"Lenovo Yoga","LN90THY","Lenovo",20);    
    Laptop laptopTwo=new Laptop(2,"HP Probook","P8976T","HP",5);    
    Laptop laptopThree=new Laptop(3,"Toshiba Slim","T999T","Toshiba",2);

    //Adding Laptops to map   
    treeMap.put(2,laptopTwo);  
    treeMap.put(1,laptopOne);  
    treeMap.put(3,laptopThree);  

    //Traversing map  
    for(Map.Entry<Integer, Laptop> entry:treeMap.entrySet()){    
      int key=entry.getKey();  
      Laptop bVar=entry.getValue();  

      System.out.println(key+" Details:");  
      System.out.println(bVar .id+" "+bVar.name+" "+bVar.model+" "+bVar.manufacturer+" "+b.quantity);   
    }    
  }    
}

Konklusion

Ved hjælp af eksempler har vi lært om Java TreeMap-klassen og dens handlinger i denne artikel. Trædatastrukturen er implementeret af Java Collections framework's TreeMap-klasse. Yderligere er NavigableMap-grænsefladen implementeret.

TreeMap-klassen bruger et træ til at implementere kortgrænsefladen. Et TreeMap er en effektiv måde at gemme nøgle/værdi-par i sorteret rækkefølge og hente dem hurtigt. Det er værd at bemærke, at i modsætning til et hash-kort, sikrer et trækort, at emnerne er ordnet i stigende nøglerækkefølge. Derudover implementerer Java TreeMap-klassen en rød-sort træmodel. Det letter lagringen af nøgleværdi-par i sorteret rækkefølge hurtigt.