Hash Map Team#1

package com.kpi.fict.it01.haspmap;

import java.util.ArrayList;

public class HashMap<Value> {

    private ArrayList<Node<Value>> buckets;
    private int bucketsAmount;
    private int size;

    public HashMap() {
        buckets = new ArrayList<>(16);
        bucketsAmount = 16;
        size = 0;

        for (int i = 0; i < bucketsAmount; i++)
            buckets.add(null);
    }

    public int getSize() {
        return size;
    }

    public Value get(String key) {
        Node<Value> node = buckets.get(getBucketIndex(key));
        while (node != null) {
            if (node.key.equals(key))
                return node.value;
            node = node.nextNode;
        }
        return null;
    }

    public void remove(String key) {
        int bucketIndex = getBucketIndex(key);

        Node<Value> nodeToRemove = buckets.get(bucketIndex);
        if (nodeToRemove == null) return;

        Node<Value> previousNode = null;
        while (nodeToRemove != null) {
            if (nodeToRemove.key.equals(key))
                break;
            previousNode = nodeToRemove;
            nodeToRemove = nodeToRemove.nextNode;
        }
        size -= 1;

        if (previousNode != null) {
            if (nodeToRemove == null) {
                return;
            }
            previousNode.nextNode = nodeToRemove.nextNode;
        } else {
            buckets.set(bucketIndex, nodeToRemove.nextNode);
        }
    }

    public ArrayList<Value> toArray() {
        ArrayList<Value> result = new ArrayList<>();

        for (Node<Value> node: buckets) {
            while (node != null) {
                result.add(node.value);
                node = node.nextNode;
            }
        }

        return result;
    }

    public void add(String key, Value value) {
        int bucketIndex = getBucketIndex(key);
        Node<Value> nodeAfterInserted = buckets.get(bucketIndex);

        while (nodeAfterInserted != null) {
            if (nodeAfterInserted.key.equals(key)) {
                nodeAfterInserted.value = value;
                return;
            }
            nodeAfterInserted = nodeAfterInserted.nextNode;
        }

        size++;
        nodeAfterInserted = buckets.get(bucketIndex);
        Node<Value> newNode = new Node(key, value);
        newNode.nextNode = nodeAfterInserted;
        buckets.set(bucketIndex, newNode);

        if (!isLoadFactorAcceptable()) {
            ensureCapacity();
        }
    }

    private void ensureCapacity() {
        ArrayList<Node<Value>> temp = buckets;
        size = 0;
        bucketsAmount *= 2;
        buckets = new ArrayList<>(bucketsAmount);

        for (int i = 0; i < bucketsAmount; i++)
            buckets.add(null);

        for (Node<Value> node : temp) {
            while (node != null) {
                add(node.key, node.value);
                node = node.nextNode;
            }
        }
    }

    private boolean isLoadFactorAcceptable() {
        return (1.0*size/bucketsAmount) <= 0.7;
    }

    private int getBucketIndex(String key) {
        return Math.abs(getHashCode(key) % bucketsAmount);
    }

    private static int getHashCode(String key) {
        double smallNumber = 79;
        double bigNumber = 27644437;
        double multiplier = 1;
        int hashCode = 0;

        for (char i : key.toCharArray()) {
            hashCode += ((int) i) * multiplier % bigNumber;
            multiplier = multiplier * smallNumber % bigNumber;
        }

        return hashCode;
    }

    private class Node<Value> {
        String key;
        Value value;

        Node<Value> nextNode;

        public Node(String key, Value value) {
            this.key = key;
            this.value = value;
        }
    }
}