Java Program to Implement SimpleBindings API

0 0 3 minutes read

SimpleBindings is an implementation of bindings that are supported by HashMap or any other map which is specified by the programmer.

Constructors of SimpleBindings API:

SimpleBindings(): It is a default constructor that uses a HashMap to store the values.
SimpleBindings(Map<String, object> m): Overloaded constructor uses an existing HashMap to store the values.

Syntax:

public class SimpleBindings extends Object implements Bindings

Implementation of SimpleBindings API :

Java

// Java Program to Implement SimpleBindings API
 
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import javax.script.SimpleBindings;
 
public class SimpleBindingsAPIExample {
   
    // reference of SimpleBindings class
    private SimpleBindings simpleBindings;
 
    // Default constructor will use a HashMap
    public SimpleBindingsAPIExample()
    {
        // object creating of SimpleBindings class
        simpleBindings = new SimpleBindings();
    }
 
    // Overloaded constructor uses an existing HashMap to
    // store the values
    public SimpleBindingsAPIExample(Map<String, Object> map)
    {
        simpleBindings = new SimpleBindings(map);
    }
 
    // Clear all the values from the map
    public void clear() { simpleBindings.clear(); }
 
    // Returns true if the map contains value for the
    // specified key
    public boolean containsKey(Object key)
    {
        return simpleBindings.containsKey(key);
    }
 
    // Return true if the map contains values as specified
    public boolean containsValue(Object value)
    {
        return simpleBindings.containsValue(value);
    }
 
    // Returns the set of values contained in the map
    public Set<Map.Entry<String, Object> > entrySet()
    {
        return simpleBindings.entrySet();
    }
 
    // Returns the values if specified key is exist in the
    // map else will return null
    public Object get(Object key)
    {
        return simpleBindings.get(key);
    }
 
    // Returns whether the map is empty or not
    public boolean isEmpty()
    {
        return simpleBindings.isEmpty();
    }
 
    // Returns a set of the keys
    public Set<String> keySet()
    {
        return simpleBindings.keySet();
    }
 
    // Insert the specified value associated with the
    // specified key
    public Object put(String key, Object value)
    {
        return simpleBindings.put(key, value);
    }
 
    // Copy all the values from another map into this map
    public void putAll(Map<? extends String, ? extends Object> map)
    {
        simpleBindings.putAll(map);
    }
 
    // Removes the value associated with the specified key
    public Object remove(Object key)
    {
        return simpleBindings.remove(key);
    }
 
    // Return the number of key-value pairs exist in the map
    public int size() { return simpleBindings.size(); }
 
    // Returns a collection of the values contained in map
    public Collection<Object> values()
    {
        return simpleBindings.values();
    }
}
class SimpleBindingsImpl {
    public static void main(String[] args)
    {
        SimpleBindingsAPIExample map = new SimpleBindingsAPIExample();
       
        map.put("1", "Ram");
        map.put("2", "Shyam");
        map.put("3", "Sita");
 
        Map<String, Object> anotherMap = new HashMap<String, Object>();
       
        anotherMap.put("4", "Geeta");
        anotherMap.put("5", "Tina");
        map.putAll(anotherMap);
 
        System.out.println("The key set of the map is : ");
       
        Set<String> keySet = map.keySet();
        Iterator<String> itr = keySet.iterator();
       
        while (itr.hasNext()) {
            System.out.print(itr.next() + "\n");
        }
       
        System.out.println();
 
        System.out.println("The values of map is :  ");
       
        Collection<Object> collectionOfValues = map.values();
        Iterator<Object> itrOfValues = collectionOfValues.iterator();
       
        while (itrOfValues.hasNext())
        {
            System.out.print(itrOfValues.next() + "\n");
        }
        System.out.println();
 
        System.out.println("The entry set of the map is ");
        Iterator<Entry<String, Object> > itrOfEntrySet;
       
        Set<Entry<String, Object> > entrySet = map.entrySet();
        itrOfEntrySet = entrySet.iterator();
       
        while (itrOfEntrySet.hasNext())
        {
            System.out.println(itrOfEntrySet.next());
        }
        System.out.println();
 
        // Returns true if map contains the key 2
        boolean check = map.containsKey("2");
        System.out.println("The map contains key 2 ? "
                           + check);
        System.out.println();
 
        // Return true if map contains the value snigdha
        check = map.containsValue("Tina");
        System.out.println("The map contains value Tina? "
                           + check);
        System.out.println();
 
        // Return the size of map
        int result = map.size();
        System.out.println("The number of key-value pairs in the map are : "
            + result);
        System.out.println();
 
        // Clear the map means delete all the key-value
        // pairs from the map
        map.clear();
 
        // Return true if map is empty
        check = map.isEmpty();
        System.out.println(
            "After clear the map, the map is empty ? "
            + check);
        System.out.println();
    }
}

Output

The key set of the map is : 
1
2
3
4
5

The values of map is :  
Ram
Shyam
Sita
Geeta
Tina

The entry set of the map is 
1=Ram
2=Shyam
3=Sita
4=Geeta
5=Tina

The map contains key 2 ? true

The map contains value Tina? true

The number of key-value pairs in the map are : 5

After clear the map, the map is empty ? true