Need help with this code. Basic arrays in java

public class ContactList {
    private static int INITIAL_LENGTH = 3;
    private PersonalContact[] contacts;
    private int numContacts;

   
    public ContactList(){
    //TODO 3: implement this method.
      contacts = new PersonalContact[INITIAL_LENGTH];
      numContacts = 0;


    }
    
   /* 
    *  Returns true if the contact list contains no contacts, false otherwise.
    */
    public boolean isEmpty(){
    //TODO 4: implement this method.
      for(PersonalContact u: contacts){
     	    if(u != null){
      	   return false;
      	}
     }
      return true;
      
    }
   
   /* Adds the PersonalContact object to the next available location in the array.
    * Before adding, the list is checked to see if it is full by calling the isFull() method.
    * If the list is full, it must be expanded before the contact can be added. To do this,
    * the expandList method is called, then the contact is added. If the list is not full, the 
    * contact is added. The numContacts can serve as an index number of the next available cell.
    * After adding, numContacts is updated.
    * Note: the array may have fewer contacts (PersonalContact objects) than its length.
    */
    public void addContact(PersonalContact newContact){
    //TODO 7: implement this method.
      	if(isFull()){
	   expandList();
      }
      for (int z  = 0; z< contacts.length-1; z++){
          if(contacts[z] == null){
            contacts[z] = newContact;
		
      numContacts ++;

         }
       }
    }
   
   /* Removes a contact from the list if it is in the list. The name of 
    * the contact is used to find the contact. If a match to the name is found, 
    * the value at that index is overwritten by null. Then the compressList
    * function is called to re-order the list so all objects are next to each other,
    * starting at index 0.
    * This method returns true if a contact was removed, false otherwise. 
    * After removing, numContacts is updated.
    */
    public boolean removeContact(String targetName){
    //TODO 9: implement this method.
    for(PersonalContact x:contacts){
         if(x.getName() == targetName){
            x = null;
		 compressList();
 return true;
   }
 
 
      
  }
  return false;
 }
   
   /* 
    * Return a list that contains only the PersonalContact objects that have been added.
    * This list does not contain any NULL values.
    * If the list does not contain any contacts, this method returns a PersonalContact array 
    * with zero length.
    */
    public PersonalContact[] getContactList(){
    //TODO 10: implement this method.
    int nulls = 0; 
    for(PersonalContact u: contacts){
	  if(u == null){
	   nulls++;
	}
  }
    PersonalContact[] getContactLists = new PersonalContact[contacts.length - nulls];
    compressList();
    for(int i = 0; i < getContactLists.length - 1; i++){
	   getContactLists[i] = contacts[i];
	}
    

      return getContactLists;

    

  }
   
   /* 
    * Removes all items from the list, resulting in an empty list.
    * The capacity of the new list will revert to the INITIAL_LENGTH.
    * numContacts is reset to 0.
    */
    public void clearContactList(){
    //TODO 11: implement this method.
    PersonalContact[] newcontact = new PersonalContact [INITIAL_LENGTH];
    contacts = newcontact;
    numContacts = 0;
    }
    
    /****** Private, "helper" method section ******/
   
   /* 
    * This method returns true if all cells in the array contain a PersonalContact
    * object, false otherwise. 
    */
    private boolean isFull(){
    //TODO 5: implement this method.
      for(int i = 0; i <= contacts.length-1; i++){
      if(contacts[i] == null){
      return false;
      }

    }
      return true;
}   
   /* Creates a new contacts array that is double the size of the current array.
    * It then copies the contacts from the current array to the new array. 
    * Note that the new array will contain the contacts from the current array followed 
    * by NULL values.
    */
    private void expandList(){
    //TODO 6: implement this method.
    PersonalContact [] expandcontacts = new PersonalContact[contacts.length *2];
      for(int i = 0; i < expandcontacts.length-1; i++){
         if(contacts[i] != null){
            expandcontacts[i] = contacts[i];
            } 
            contacts = expandcontacts;
      }




    }
    
   /* 
    * This method ensures that all PersonalContact objects in the contact list
    * are stored contiguously: next to each other (with no null value between any 
    * of them) starting at index 0. 
    * The method traverses the list and if it finds a null value it moves all objects 
    * to maintain contiguous storage. Design an algorithm to do this and implement it.
    * 
    */
    private void compressList(){
    //TODO 8: implement this method.
    for(int i = 0; i < contacts.length-1; i++){
	  if(contacts[i] == null){
		for(int j = i; j < contacts.length-1; j++){
		    contacts[contacts.length-1] = null;
		    contacts[j] = contacts[j+1];
			}
		}
	}

  }

 }