Feedback on this implementation of a HashMap

[lo2]

So I have tried to implement a HashMap myself via a Node class, which just
constructs a node with a key and a corresponding value, it has also got a getHashCode method, where I just concatenate the two values on each other.

I have also constructed a SinglyLinkedList (part of a previous assignment), which I use as the bucket.

And my Hash function is simply hashCode % hashMap.length.

Here is my own implementation, so what do you think of it?

	package spreadsheet; 

	public class HashTableMap {

	  private SinglyLinkedListMap[] hashArray;
	  private int size;
	  
	  
	  public HashTableMap() {
		hashArray = new SinglyLinkedListMap[64];
		size = 0;  
	  }
	  
	  
	  public void insert(final Position key, final Expression value) {
			
		  Node node = new Node(key, value); 
		  int hashNumber = node.getHashCode() % hashArray.length;	    
		  SinglyLinkedListMap bucket = new SinglyLinkedListMap();
		  bucket.insert(key, value);
		  if(hashArray[hashNumber] == null) {
			hashArray[hashNumber] = bucket;
			size++;	
		  }
		  if(hashArray[hashNumber] != null) {
			SinglyLinkedListMap bucket2 = hashArray[hashNumber];
			bucket2.insert(key, value);
			hashArray[hashNumber] = bucket2;
			size++;	
		  }
		  if (hashArray.length == size) {
			  SinglyLinkedListMap[] newhashArray = new SinglyLinkedListMap[size * 2];
		  for (int i = 0; i < size; i++) {
			  newhashArray[i] = hashArray[i];
		  }
		  hashArray = newhashArray;
		}
	  } 
	  
	  public Expression lookUp(final Position key) {
		  Node node = new Node(key, null); 
		  int hashNumber = node.getHashCode() % hashArray.length;
		  SinglyLinkedListMap foundBucket = hashArray[hashNumber];
		  return foundBucket.lookUp(key); 
	  }
	 }

The look up time should be around O(1), so I would like to know if that is the case? And if not how can I improve it, in that regard?

[DarrylBurke]

Moved from New to Java

db