Implementing Sparse Vector in Java

// importing generic packages
import java.util.Scanner;
import java.util.TreeMap;
import java.util.Map;

public class SparseVector {
  
    // TreeMap is used to maintain sorted order
    private TreeMap<Integer, Double> st;
    private int size;

    // Constructor
    public SparseVector(int size)
    {
        this.size = size;

        // assigning empty TreeMap
        st = new TreeMap<Integer, Double>();
    }

    // Function to insert a (index, value) pair
    public void put(int i, double value)
    {
        // checking if index(i) is out of bounds
        if (i < 0 || i >= size)
            throw new RuntimeException(
                "\nError : Out of Bounds\n");

        // if value is zero, don't add to that index &
        // remove any previously held value
        if (value == 0.0)
            st.remove(i);

        // if value is non-zero add index-value pair to
        // TreeMap
        else
            st.put(i, value);
    }

    // Function to get value for an index
    public double get(int i)
    {
        // checking if index(i) is out of bounds
        if (i < 0 || i >= size)
            throw new RuntimeException(
                "\nError : Out of Bounds\n");

        // if index is valid, return value at index
        if (st.containsKey(i))
            return st.get(i);

        // if index not found, it means the value is zero as
        // only non-zero entries are added to the Map
        else
            return 0.0;
    }

    // Function to get size of the vector
    public int size() { return size; }

    // Function to get dot product of two vectors
    public double dot(SparseVector b)
    {
        SparseVector a = this;

        // Dot product of Sparse Vectors whose lengths are
        // different is not possible
        if (a.size != b.size)
            throw new RuntimeException(
                "Error : Vector lengths are not same");

        double sum = 0.0;

        // Traversing each sorted vector and getting
        // product of consequent entries of the vectors
        if (a.st.size() <= b.st.size()) {
            for (Map.Entry<Integer, Double> entry :
                 a.st.entrySet())
                if (b.st.containsKey(entry.getKey()))
                    sum += a.get(entry.getKey())
                           * b.get(entry.getKey());
        }

        // Traversing each sorted vector and getting
        // product of consequent entries of the vectors
        else {
            for (Map.Entry<Integer, Double> entry :
                 b.st.entrySet())
                if (a.st.containsKey(entry.getKey()))
                    sum += a.get(entry.getKey())
                           * b.get(entry.getKey());
        }
        return sum;
    }

    // Function to get sum of two vectors
    public SparseVector plus(SparseVector b)
    {
        SparseVector a = this;

        // Addition of Sparse Vectors whose lengths are
        // different is not possible
        if (a.size != b.size)
            throw new RuntimeException(
                "Error : Vector lengths are not same");

        // creating new empty Sparse Vector object
        SparseVector c = new SparseVector(size);

        // Traversing and adding the two vectors a & b and
        // constructing resultant Sparse Vector c
        for (Map.Entry<Integer, Double> entry :
             a.st.entrySet())
            c.put(entry.getKey(), a.get(entry.getKey()));

        for (Map.Entry<Integer, Double> entry :
             b.st.entrySet())
            c.put(entry.getKey(),
                  b.get(entry.getKey())
                      + c.get(entry.getKey()));

        return c;
    }

    // Function toString() for printing vector
    public String toString()
    {
        String s = "";
        for (Map.Entry<Integer, Double> entry :
             st.entrySet())
            s += "(" + entry.getKey() + ", "
                 + st.get(entry.getKey()) + ") ";

        return s;
    }

    public static void main(String[] args)
    {
        Scanner scan = new Scanner(System.in);
        System.out.println(
            "Enter size of Sparse Vectors : ");

        // Size of the two Sparse Vector
        int n = scan.nextInt();

        // sparse vector a and b
        SparseVector A = new SparseVector(n);
        SparseVector B = new SparseVector(n);

        // store key, value pairs
        System.out.println(
            "Enter number of entries for Vector A :");
        int n1 = scan.nextInt();
        System.out.println("Enter " + n1
                           + " (int, double) pairs :");
        for (int i = 0; i < n1; i++)
            A.put(scan.nextInt(), scan.nextDouble());

        System.out.println(
            "Enter number of entries for vector B :");
        int n2 = scan.nextInt();
        System.out.println("Enter " + n2
                           + " (int, double) pairs :");
        for (int i = 0; i < n2; i++)
            B.put(scan.nextInt(), scan.nextDouble());

        System.out.println("\nVector A = " + A);
        System.out.println("Vector B = " + B);
        System.out.println("\nA dot B = " + A.dot(B));
        System.out.println("A  +  B   = " + A.plus(B));
    }
}