Java List Implementation

[Claire Danvers]

I am required to write an ordedLinkedList class and UnOrderedArrayList class and a Student class. I have attached a zip file containing all my classes, interfaces, and methods. I can't seem to get any of my toString methods correct my output is messed up. I can't get the program to output the student name and then GPA. I am supposed to "test every method in both ordedLinkedList and UnOrderedArrayList classes on managing the student data type." I can't figure out where I'm going wrong or what I should change. I attached my output code in a picture as well.

[code=java]public class Student<T>  implements Comparable {
    private String name;
    private double gPA;
//    protected T[] list;
//    protected int rear;

    public Student() {
        name = "idk";
        gPA = 0.0;
    }
   

    
    public Student(String name, double gPA) {
        name = "sname";
        gPA = 4.0;
    }
    
//    @Override
//    public String toString(){
//        String result = "";
//        for(int i = 0; i < rear; i++){
//            result = result + list[i].toString() + "\n";
//        }
//        
//        return result;
//    }

    @Override
    public int compareTo(Object other) {
        if(this.getgPA() == ((Student) other).getgPA()){
            return 0;

        } else if (this.getgPA() > ((Student) other).getgPA()) {
            return 1;
        } else {
            return -1;
        }

    }

    /**
     * @return the name
     */
    public String getName() {
        return name;
    }

    /**
     * @param name the name to set
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * @return the gPA
     */
    public double getgPA() {
        return gPA;
    }

    /**
     * @param gPA the gPA to set
     */
    public void setgPa(double gPA) {
        this.gPA = gPA;
    }
    
    
    public String toString(String result){
         result = ("Student name is: " + name +" with GPA = "+ gPA);
         return result;
    }

}

[/code]

package project_4;

import java.util.logging.Level;
import java.util.logging.Logger;


public class OrderedLinkedList<T> extends LinkedList implements OrderedListADT<T> {

    @Override
    public void add(T element) {
        
        Comparable temp = null;
        if(element instanceof Comparable){
            temp = (Comparable)element;
        }else{
            try {
                throw new NonComparableElementException("double ordered list");
            } catch (NonComparableElementException ex) {
                Logger.getLogger(OrderedLinkedList.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
        
        LinearNode<T> newNode = new LinearNode<T>(element);
        
        LinearNode<T> current = front;
        LinearNode<T> previous = null;
        
        if(isEmpty()){
            front = newNode;
            rear = newNode;
        }else if(temp.compareTo(rear.getElem())>= 0){
            rear.setNext(newNode);
            newNode.setNext(null);
            rear = newNode;
        }else if(temp.compareTo(front.getElem()) <= 0){
            newNode.setNext(front);
            front = newNode;
        }else{
            while((temp.compareTo(current.getElem()) > 0)){
                previous = current;
                current = current.getNext();
            }
            newNode.setNext(current);
            previous.setNext(newNode);
        }
        count++;
    }
    
    @Override
   public T removeFirst() throws EmptyCollectionException{
       if(isEmpty()){
           throw new EmptyCollectionException("List");
       }
       LinearNode<T> result = front;
       front = front.getNext();
       if(front == null){
           rear = null;
       }
       count--;
       return result.getElem();
   } 
    
    
}

package project_4;

public class UnOrderedArrayList<T> extends ArrayList<T> implements UnorderedListADT<T> {

    public void expandCapacity() {
        T[] larger = (T[]) (new Object[list.length * 2]);

        for (int scan = 0; scan < rear; scan++) {
            larger[scan] = list[rear];
            rear = (rear + 1) % list.length;
        }
        rear = 0;
        list = larger;
    }

    @Override
    public void addToFront(T element) {
        if (size() == list.length) {
            expandCapacity();
        }

        for (int scan = rear; scan > 0; scan--) {
            list[scan] = list[scan - 1];

            list[0] = element;
            rear++;
        }
    }

    @Override
    public void addToRear(T element) {
        if (size() == list.length) {
            expandCapacity();
        }

        list[rear] = element;
        rear++;
    }

    @Override
    public void addToAfter(T element, T target) {
        if (size() == list.length) {
            expandCapacity();
        }
        int scan = 0;
        while (scan < rear && !target.equals(list[scan])) {
            scan++;
        }
        if (scan == rear) {
            throw new ElementNotFoundException("list");
        }
        scan++;
        for (int scan2 = rear; scan2 > scan; scan2--) {
            list[scan2] = list[scan2 - 1];
        }
        list[scan] = element;
        rear++;
    }

}

package project_4;

public class ArrayList<T> implements ListADT {

    protected final int MAX = 100;
    private final int NOT_FOUND = -1;
    protected int rear;
    protected T[] list;

    public void ArraryList() {
        rear = 0;
        list = (T[]) (new Object[MAX]);
    }

    public void ArrayList(int initialCapacity) {
        rear = 0;
        list = (T[]) (new Object[initialCapacity]);
    }

    @Override
    public Object removeFirst() {
        if (rear == 0) {
            throw new EmptyCollectionException("list");
        }
        T result = list[0];
        rear--;

        for (int scan = 0; scan < rear; scan++) {
            list[scan] = list[scan + 1];
        }
        list[rear] = null;

        return result;
    }

    @Override
    public Object removeLast() {
        if (rear == 0) {
            throw new EmptyCollectionException("list");
        }
        T result = list[rear - 1];
        rear--;
        list[rear] = null;

        return result;
    }

    @Override
    public Object remove(Object element) {
        T result;
        int index = find((T) element);
        if (index == NOT_FOUND) {
            throw new ElementNotFoundException("list");
        }
        result = list[index];
        rear--;
        //Shift the appropriate elements
        for (int scan = index; scan < rear; scan++) {
            list[scan] = list[scan + 1];
        }
        list[rear] = null;

        return result;

    }

    private int find(T target) {
        int scan = 0;
        int result = NOT_FOUND;
        boolean found = false;

        if (isEmpty()) {
            while (!found && scan < rear) {
                if (target.equals(list[scan])) {
                    found = true;
                } else {
                    scan++;
                }
            }
        }
        if (found) {
            result = scan;
        }
        return result;
    }

    @Override
    public Object first() {
        return rear;
    }

    @Override
    public Object last() {
        return rear;
    }

    @Override
    public boolean contains(Object target) {
        if (target == null) {
            return false;
        }
        return true;
    }

    @Override
    public int size() {
        return rear;
    }

    @Override
    public boolean isEmpty() {
        return (rear == 0);
    }

}

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package project_4;

/**
 *
 * @author delaneycoats
 * @param <T>
 */
public class LinkedList<T> implements ListADT<T> {

    protected int count;
    protected LinearNode<T> front, rear;

    LinkedList() {
        count = 0;
        front = rear = null;
    }

    @Override
    public T removeFirst() throws EmptyCollectionException {
        if (isEmpty()) {
            throw new EmptyCollectionException("List");
        }
        LinearNode<T> result = front;
        front = front.getNext();
        if (front == null) {
            rear = null;
        }
        count--;
        return result.getElem();
    }

    @Override
    public T removeLast() throws EmptyCollectionException {
        if (isEmpty()) {
            throw new EmptyCollectionException("list");
        }
        LinearNode<T> previous = null;
        LinearNode<T> current = front;

        while (current.getNext() != null) {
            previous = current;
            current = current.getNext();
        }

        LinearNode<T> result = rear;
        rear = previous;
        if (rear == null) {
            front = null;
        } else {
            rear.setNext(null);
        }
        count--;
        return result.getElem();
    }

    @Override
    public T remove(T targetElement) throws EmptyCollectionException, ElementNotFoundException {
        if (isEmpty()) {
            throw new EmptyCollectionException("List");
        }
        boolean found = false;
        LinearNode<T> previous = null;
        LinearNode<T> current = front;

        while (current != null && !found) {
            if (targetElement.equals(current.getElem())) {
                found = true;
            } else {
                previous = current;
                current = current.getNext();
            }
        }
        if (!found) {
            throw new ElementNotFoundException("list");
        }
        if (size() == 1) {
            front = rear = null;
        } else if (current.equals(front)) {
            front = current.getNext();
        } else if (current.equals(rear)) {
            rear = previous;
            rear.setNext(null);
        } else {
            previous.setNext(current.getNext());
        }
        count--;
        return current.getElem();
    }

    @Override
    public T first() {
        return front.getElem();
    }

    @Override
    public T last() {
        return rear.getElem();
    }

    @Override
    public boolean contains(T target) {
        if (target == null) {
            return false;
        }
        return true;
    }

    @Override
    public int size() {
        return count;
    }

    @Override
    public boolean isEmpty() {
        return (count == 0);
    }
    
//    public String toString(String result){
//        result = "";
//             
//        
//        LinearNode<T> current = front;
//        
//        while(current != null){
//            result = result + current.getElem().toString() + "\n";
//            current= current.getNext();  //gets the next linear node
//        }
//        
//        return result;

        public String toString(){
        String result = "";
        for(int i = 0; i < count; i++){
           result = result + rear.getElem().toString() + "\n";
       }
       
        return result;
    }
  
    }

//Main Method For Testing

package project_4;


public class Project_4 {

   
    public static void main(String[] args) {
        System.out.println("Step 1-----> test the add() method of OrderedLinked List");
        
        OrderedLinkedList<Student> studentList = new OrderedLinkedList<Student>();
        
        studentList.add(new Student("A" , 4.0));
        studentList.add(new Student("B" , 3.0));
        studentList.add(new Student("C" , 2.0));
        studentList.add(new Student("D" , 1.0));
        studentList.add(new Student("E" , 3.3));
        studentList.add(new Student("F" , 2.3));
        System.out.println("The current student List includes:\n " + studentList.toString());

        
        System.out.println("Step 2----> test the removeFirst() method of OrderedLinkedList");
        studentList.removeFirst();
        System.out.println("The current student List includes:\n " + studentList.toString());
        
        System.out.println("Step 3---> test the removeLast() method of OrderedLinkedList");
        studentList.removeLast();
        System.out.println("The current student List includes:\n " + studentList.toString());
        
         System.out.println("Step 4---> test the first() method of OrderedLinkedList");
         studentList.first();
         System.out.println(studentList.first());
         System.out.println("The current student List includes:\n " + studentList.toString());

         System.out.println("Step 6---> test the last() method of OrderedLinkedList");
         studentList.last();
         System.out.println(studentList.last());
         System.out.println("The current student List includes:\n " + studentList.toString());

        UnOrderedArrayList<Student> studentList2 = new UnOrderedArrayList<Student>(); 
        System.out.println("Step 1---> test the addToFront() method of UnOrderedArrayList");

        studentList2.addToFront(new Student("H" , 2.3));
        studentList2.addToAfter((new Student("F" , 4.1)), new Student("H" , 2.3));
        System.out.println("The current student List includes:\n " + studentList2.toString());

        
        System.out.println("Step 2---> test the addToRear() method of UnOrderedArrayList");
        studentList2.addToRear(new Student("G" , 1.5));
        System.out.println("The current student List includes:\n " + studentList2.toString());

    }
    
}

[Keith Lynn]

I don't see where you override toString in your orderedLinkedList and unOrderedArrayList classes

[Claire Danvers]

I didn't know if the toString should be in those methods or in the ArrayList/LinkedList?

[Campbell Ritchie]

Welcome to the Ranch