Utilizing the Map Interface from the Collections Framework

Utilizing the Map Interface from the Collections Framework


by Ming Chou


We want to hear from you! Please send us your feedback.


1. Introduction
2. Map Interface
3. Map Implementations
3.1 java.util.HashTable Implementation
3.2 java.util.HashMap Implementation
3.3 java.util.TreeMap Implementation
4. Map Examples
4.1 HashMap Example
4.2 TreeMap Example
5. Conclusion

The following Technical Article may contain actual software programs in source code form. This source code is made available for developers to use as needed, pursuant to the terms and conditions of this license.


  1. 1. Introduction


    With the introduction of the Collections Framework in the Java[tm] 2 Platform, Standard Edition, several commonly used data structure interfaces were integrated into the Java[tm] 2 SDK to simplify the programmer's job, and to allow the programmer to focus on business requirements rather than building data objects. This new framework provides several useful tools and functionality to the user that do not require the user to know much about the details of the framework.

    Within the Java[tm] Collections Framework, there are two main interfaces, (1) the Collection interface, which includes the list and set interfaces, and (2) the Map interface. The main difference between the Collection and the Map interfaces is that a Collection stores a group of Objects, while Maps hold key/value pairs of data. In a Map Object, each key has at most one associated value. A perfect everyday example of when to use a Map would be to correlate a person's profile with their social security number. The social security number would be the key, while the profile would be the corresponding person's mapped "value".



    2. The Map Interface


    The following code snippet shows what the Map interface looks like:
    public interface java.util.Map {

    //Altering Methods
    public Object put(Object key, Object value); //gets Object with key/value mapping
    public Object remove(Object key); //removes Object with key
    public void putAll(java.util.Map); //put all Map elements into current Map
    public void clear(); //removes all mappings from current Map

    //Querying Methods
    public Object get(Object key); //gets Object with key
    public int size(); //returns number of Map elements
    public boolean isEmpty(); //check if Map is empty
    public boolean containsKey(Object); //Checks if map contains object as key
    public boolean containsValue(Object); //Checks if map contains object as value
    public boolean equals(Object); //compares specified Object with current Map

    //Viewing Methods
    public java.util.Set keySet(); //Gets keys
    public java.util.Collection values(); //Gets values
    public java.util.Set entrySet(); //Gets mappings

    public static interface java.util.Map.Entry { //a map-entry (single key/value pair)
    public Object getKey(); //returns current entry key
    public Object getValue(); //returns current entry value
    public Object setValue(Object value); //replaces current value with specified value
    public boolean equals(Object); //compares current object with specified object
    public int hashCode(); //returns hashcode with current map-entry
    }
    }

    The Map interface provides us with methods to accomplish three main functionalities:


    1. Map Altering

    2. Map Querying

    3. Map Viewing

    Map altering methods allow the user to alter the contents of the current Map. This includes the removal, updating, and insertion of key/value pairs.

    Map querying methods allow the user to retrieve key/value pairs from the Map. Not only are there methods to query the contents of Map elements, but there are also methods that can be used to query the entire Map Object.

    There are three different views which can be used to analyze Map key/value Objects. Since the keys in a map must be unique, the keyset() method retrieves a Set of the keys in the Map (A Set is a collection of unique data elements). The values() method returns a Collection of the value Objects (A Collection is a group of objects which allows the storage of duplicate objects). The entrySet() method returns a Set of Map.Entry mappings.

    The Map.Entry interface is the object used to store a single key/value pair. Within the Map.Entry, there are methods to store and retrieve individual key/value elements. The entrySet() method returns a Set of objects that implements the Map.Entry interface. Each element within the Set represents a single key/value pair in the Map.



    3. Map Implementations


    The following section will provide a brief overview of three commonly used map implementations:

    1. java.util.Hashtable
    2. java.util.HashMap
    3. java.util.TreeMap




    1. 3.1 java.util.Hashtable Implementation

      The Hashtable Object maps key objects to value objects. Methods are provided to enable a quick lookup of values based upon a key search. The Hashtable Object was introduced in Java 1.0 platform, while the HashMap Object which is introduced in the next section was introduced in the Java 1.2 platform platform. The additional methods the Hashtable implementation offers (not including those in the Map interface) are:
      public class java.util.Hashtable extends Dictionary implements Cloneable, Map, Serializable {

      //Hashtable constructors
      public Hashtable(); //construct a default Hashtable with default capacity and load of 0.75
      public Hashtable (int initialCapacity); //construct a Hashtable with passed capacity and default load of 0.75
      public Hashtable(int initialCapacity, float load); //construct Hashtable with passed capacity and load
      public Hashtable(Map); //construct Hashtable with passed mapping

      //Hashtable specific methods
      public boolean contains(Object); //checks if Object is in Hashtable
      public Enumeration elements(); //returns Enumeration of elements in Hashtable
      public Enumeration keys(); //returns Enumeration of keys in hashtable
      public Object clone(); //creates shallow copy of Hashtable(structure copied, but not key/values)
      public String toString(); //prints out key/value pairs of Hashtable elements
      protected void rehash(); //reorganizes all elements in Hashtable, and increases Hashtable capacity

      public Object get(Object); //get Value from passed in key
      public Object put(Object key, Object value); //insert key/value pair

      }

      A Hashtable is similar to a regular table where keys are mapped to values, but the Hashtable offers a quick way to retrieve data. When an element is inserted into the Hashtable, the name of the Object is hashed and the resulting integer value from the hash is used as the table index for that Object. The Object is then stored as the value of the cell the hash index is referring to. If another Object with the same name is stored into the Hashtable, the extra Objects are stored in a linked list following the original item.

      The initial capacity of the Hashtable dictates how many spaces are allocated for Objects in the Hashtable. As a Hashtable is a dynamic entity, constant resizing is required to efficiently allocate space for the Hashtable. The load factor indicates how full percentage wise the Hashtable is allowed to become before the Hashtable's capacity is automatically increased.

      Two things to note are that (1) Hashtable data is synchronized and (2) the null value is not allowed as a key or value in the Hashtable.


      3.2 java.util.HashMap Implementation

      The HashMap is very similar to the Hashtable, but was introduced recently starting with the Java 1.2 platform. There are two main differences between HashMap and Hashtable. First, the HashMap is not synchronized (making access faster), and second, the HashMap allows null values to be used as values or keys, which are disallowed in the Hashtable implementation. HashMap specific methods (not found in the Map interface) are:
      public class java.util.HashMap implements Map, Cloneable, java.io.Serializable {

      public HashMap(int initialCapacity, float load); //construct a default HashMap with default capacity and load of 0.75
      public HashMap(int initialCapacity); //construct a HashMap with passed capacity and default load of 0.75
      public HashMap(); //construct HashMap with passed capacity and load
      public Hashmap(Map); //construct HashMap with passed mapping

      public Object clone(); //constructs shallow copy of HashMap (keys/values not copied)

      public Object get(Object); //get Value from passed in key
      public Object put(Object key, Object value); //insert key/value pair



      }


      The HashMap, after being introduced in the Java 1.2 platform platform, has provided much better performance than the Hashtable. Though HashMap is not synchronized, it can be made synchronized. What happens if the HashMap is modified in a multi-threaded environment? The HashMap has a fail-fast iterator. Fail-fast means that the iterator is notified when the underlying collection changes, and essentially causes the fetching of the next element to fail by throwing ConcurrentModificationException.


      3.3 java.util.TreeMap Implementation

      The TreeMap implementation implements the Map interface but stores elements in a tree. The TreeMap has a little bit more overhead during operation than the HashMap, but because of the tree structure, it returns keys in sorted order. If there is no need to retrieve Map elements sorted by key, then the HashMap would be a more practical structure to use. The TreeMap implemented public members not included in the Map interface are:
      public class java.TreeMap implements SortedMap, Cloneable, java.io.Serializable {

      public TreeMap(); //new TreeMap
      public TreeMap(Comparator); //new TreeMap using Comparator
      public TreeMap(Map); //new TreeMap using Map
      public TreeMap(SortedMap); //new TreeMap using sortedMap

      public Comparator comparator();
      public Object firstKey(); //returns first Key
      public Object lastKey(); //returns last Key
      public Object clone(); //returns shallow copy of TreeMap

      public SortedMap headMap(Object); //returns SortedMap of all elements upto Object
      public SortedMap tailMap(Object); //returns SortedMap of all elements after Object
      public SortedMap subMap(Object, Object); //returns SortedMap of all elements between keys

      public Object get(Object); //get Value from passed in key
      public Object put(Object key, Object value); //insert key/value pair
      }



      The TreeMap is very useful when you need to store objects in some sort of order. For example, a phone book or storing the words in a dictionary would be ideal candidates for usage with a TreeMap. SortedMap is a subinterface of Map. TreeMap is the only implementation that utilizes the SortedMap interface.




    4. Examples


    In the following section, two examples will be presented, the first will show an example of a HashMap, while the second will utilize the TreeMap. Notice that the only difference in the code is present in one line only, when the calendar Map is instantiated, yet the outputs are completely different due to the difference in storage behavior of TreeMap and HashMap.



    1. 4.1 HashMap Example

      import java.util.*;

      public class ExampleHashMap {

      //calendar Map
      Map calendar = new HashMap();

      //constructor to add all elements into Map
      public ExampleHashMap(String d[], String i[]){
      for (int x=0; x<d.length; x++)
      calendar.put(d[x], i[x]);
      }


      //main method
      public static void main(String args[]) {

      //Data to be inserted into calendar
      String [] dates = {"10/31/01", "01/01/01", "03/05/01", "02/04/01"};
      String [] items = {"Halloween", "New Years", "Birthday", "Anniversary"};

      //create instance of class
      ExampleHashMap example = new ExampleHashMap(dates, items);

      //print out all key/value pairs in map
      System.out.println("map= " + example.calendar);

      //retrieve mappings into Set
      Set mappings = example.calendar.entrySet();

      System.out.println("object /t/t/tkey/t/tvalue");
      //iterate through mappings and print content
      for (Iterator i = mappings.iterator(); i.hasNext();) {
      Map.Entry me = (Map.Entry)i.next();
      Object ok = me.getKey();
      Object ov = me.getValue();
      System.out.print(me + "/t");
      System.out.print(ok + "/t");
      System.out.println(ov);
      }

      }


      }


      -Output of HashMap (each compiler will output results in different order):

      1. /tmp> java ExampleHashMap
        map= {01/01/01=New Years, 03/05/01=Birthday, 02/04/01=Anniversary, 10/31/01=Halloween}
        object key value
        01/01/01=New Years 01/01/01 New Years
        03/05/01=Birthday 03/05/01 Birthday
        02/04/01=Anniversary 02/04/01 Anniversary
        10/31/01=Halloween 10/31/01 Halloween


      Notice how the objects stored into the HashMap were not stored in chronological order, nor in alphabetical order. The output order actually depends upon which compiler is being used, and the machine settings. Halloween was actually the first object "put" into the HashMap, but was actually stored in the last mapping in the HashMap.


      4.2 TreeMap Example
      import java.util.*;

      public class ExampleTreeMap {

      //calendar Map
      Map calendar = new TreeMap();

      //constructor to add all elements into Map
      public ExampleTreeMap(String d[], String i[]){
      for (int x=0; x<d.length; x++)
      calendar.put(d[x], i[x]);
      }


      //main method
      public static void main(String args[]) {

      //Data to be inserted into calendar
      String [] dates = {"10/31/01", "01/01/01", "03/05/01", "02/04/01"};
      String [] items = {"Halloween", "New Years", "Birthday", "Anniversary"};

      //create instance of class
      ExampleTreeMap example = new ExampleTreeMap(dates, items);

      //print out all key/value pairs in map
      System.out.println("map= " + example.calendar);

      //retrieve mappings into Set
      Set mappings = example.calendar.entrySet();

      System.out.println("object /t/t/tkey/t/tvalue");
      //iterate through mappings and print content
      for (Iterator i = mappings.iterator(); i.hasNext();) {
      Map.Entry me = (Map.Entry)i.next();
      Object ok = me.getKey();
      Object ov = me.getValue();
      System.out.print(me + "/t");
      System.out.print(ok + "/t");
      System.out.println(ov);
      }

      }


      }



      -Output of TreeMap:

      1. /tmp> java ExampleTreeMap
        map= {01/01/01=New Years, 02/04/01=Anniversary, 03/05/01=Birthday, 10/31/01=Halloween}
        object key value
        01/01/01=New Years 01/01/01 New Years
        02/04/01=Anniversary 02/04/01 Anniversary
        03/05/01=Birthday 03/05/01 Birthday
        10/31/01=Halloween 10/31/01 Halloween


      Output from the TreeMap object is a little more predictable than the HashMap. Notice that Mappings were sorted in alphabetical order by the key value. Unlike the HashMap output, the TreeMap output would be more useful in a real world calendar application. One drawback of using the TreeMap data structure as mentioned earlier is that there is overhead when you "put" or "remove" elements from the TreeMap structure due to sorting, which can affect program performance.




    5. Conclusion


    The Map interface and the different implementations offered as part of the Collections package provide a convenient way to store key/value objects. The general rule when considering which implementation to utilize is to use TreeMap when element ordering is important, and use HashMap when elements do not need to be stored in any particular order. Using Hashtable is generally discouraged since HashMap provides all similar functionality, and generally runs quicker. HashMaps can also be made synchronized if you are using the HashMap in a multi-threaded environment.
  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
LSTM (Long Short-Term Memory) is a type of recurrent neural network (RNN) architecture that is designed to overcome the vanishing gradient problem in traditional RNNs. It is particularly useful for processing sequential data such as time-series, natural language, and speech data. In PyTorch, the LSTM model is implemented in the torch.nn module. The LSTM class can be called with the required input and output dimensions, as well as the number of layers and hidden units in each layer. The forward method of the LSTM class takes the input sequence and returns the output sequence and the final hidden state of the LSTM. Here is an example of utilizing the LSTM model in PyTorch: ``` import torch import torch.nn as nn # Define LSTM model class LSTMModel(nn.Module): def __init__(self, input_dim, hidden_dim, num_layers, output_dim): super(LSTMModel, self).__init__() self.hidden_dim = hidden_dim self.num_layers = num_layers self.lstm = nn.LSTM(input_dim, hidden_dim, num_layers, batch_first=True) self.fc = nn.Linear(hidden_dim, output_dim) def forward(self, x): # Initialize hidden state and cell state h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_dim).requires_grad_() c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_dim).requires_grad_() # Forward pass through LSTM layer lstm_out, (h_n, c_n) = self.lstm(x, (h0.detach(), c0.detach())) # Flatten LSTM output to feed into fully connected layer lstm_out = lstm_out[:, -1, :] # Forward pass through fully connected layer out = self.fc(lstm_out) return out # Instantiate LSTM model input_dim = 10 hidden_dim = 20 num_layers = 2 output_dim = 1 model = LSTMModel(input_dim, hidden_dim, num_layers, output_dim) # Define loss function and optimizer criterion = nn.MSELoss() optimizer = torch.optim.Adam(model.parameters(), lr=0.01) # Train LSTM model for epoch in range(num_epochs): # Forward pass outputs = model(inputs) loss = criterion(outputs, targets) # Backward and optimize optimizer.zero_grad() loss.backward() optimizer.step() ``` In this example, we define an LSTM model with an input dimension of 10, a hidden dimension of 20, 2 layers, and an output dimension of 1. We then instantiate the model and define the loss function and optimizer. Finally, we train the model using the forward method to calculate the output and the loss.backward() method to calculate the gradients and update the weights.

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值