How do you compare objects of different types?

In the program below DList1

, it is an abstraction of a list.

I would like to run multiple unit test cases in the main () function of a class DList1

.

To be specific,

In the main()

method Line 105

, l.head.item != 9

it gives a compilation error: Incompatible operand types Object and int

.

At compile time, the value 9

is of primitive type int

and l.head.item

is of type class Object

.

l.head.item

Will be of type at run time class Integer

. Not sure about the type of the value 9

.

/* DList1.java */

/**
 *  A DList1 is a mutable doubly-linked list.  (No sentinel, not
 *  circularly linked.)
 */

public class DList1 {

  /**
   *  head references the first node.
   *  tail references the last node.
   *
   *  DO NOT CHANGE THE FOLLOWING FIELD DECLARATIONS.
   */

  protected DListNode1 head;
  protected DListNode1 tail;
  protected long size;

  /* DList1 invariants:
   *  1)  head.prev == null.
   *  2)  tail.next == null.
   *  3)  For any DListNode1 x in a DList, if x.next == y and x.next != null,
   *      then y.prev == x.
   *  4)  For any DListNode1 x in a DList, if x.prev == y and x.prev != null,
   *      then y.next == x.
   *  5)  The tail can be accessed from the head by a sequence of "next"
   *      references.
   *  6)  size is the number of DListNode1s that can be accessed from the
   *      head by a sequence of "next" references.
   */

  /**
   *  DList1() constructor for an empty DList1.
   */
  public DList1() {
    this.head = null;
    this.tail = null;
    this.size = 0;
  }


  /**
   *  insertFront() inserts an item at the front of a DList1.
   */
  public void insertFront(Object item) {
      if(this.head == null){
          this.head = new DListNode1(item);
          this.tail = this.head;
      }else{
          DListNode1 newNode = new DListNode1(item);
          newNode.next = this.head;
          this.head.prev = newNode;
          this.head = newNode;
      }
      this.size++;
  }

  /**
   *  removeFront() removes the first item (and node) from a DList1.  If the
   *  list is empty, do nothing.
   */
  public void removeFront() {
      if(this.size == 0){
          return;
      }else if(size ==1){
          this.head = null;
          this.tail = null;
      }else{
          this.head.next.prev = null;
          this.head = this.head.next;
      }
  }

  /**
   *  toString() returns a String representation of this DList.
   *
   *  DO NOT CHANGE THIS METHOD.
   *
   *  @return a String representation of this DList.
   */
  public String toString() {
    String result = "[  ";
    DListNode1 current = head;
    while (current != null) {
      result = result + current.item + "  ";
      current = current.next;
    }
    return result + "]";
  }

  public static void main(String[] args) {
    // DO NOT CHANGE THE FOLLOWING CODE.

    DList1 l = new DList1();
    System.out.println("### TESTING insertFront ###\nEmpty list is " + l);

    l.insertFront(9);
    System.out.println("\nInserting 9 at front.\nList with 9 is " + l);
    if (l.head == null) {
      System.out.println("head is null.");
    } else {
        if (l.head.item != 9) { //Line 105
            System.out.println("head.item is wrong.");
        }
        if (l.head.prev != null) {
            System.out.println("head.prev is wrong.");
        }
    }
    if (l.tail == null) {
      System.out.println("tail is null.");
    } else {
      /*if (l.tail.item != 9) {
        System.out.println("tail.item is wrong.");
      }
      if (l.tail.next != null) {
        System.out.println("tail.next is wrong.");
      }*/
    }
    if (l.size != 1) {
      System.out.println("size is wrong.");
    }

    l.insertFront(8);
    System.out.println("\nInserting 8 at front.\nList with 8 and 9 is " + l);
    if (l.head == null) {
      System.out.println("head is null.");
    } else {
      /*if (l.head.item != 8) {
        System.out.println("head.item is wrong.");
      }*/
      if (l.head.prev != null) {
        System.out.println("head.prev is wrong.");
      }
      if (l.head.next != l.tail) {
        System.out.println("head.next is wrong.");
      }
    }
    if (l.tail == null) {
      System.out.println("tail is null.");
    } else {
      if (l.tail.next != null) {
        System.out.println("tail.next is wrong.");
      }
      if (l.tail.prev != l.head) {
        System.out.println("tail.prev is wrong.");
      }
    }
    if (l.size != 2) {
      System.out.println("size is wrong.");
    }

  }

}

      


/* DListNode1.java */

/**
 *  A DListNode1 is a node in a DList1 (doubly-linked list).
 */

class DListNode1 {

  /**
   *  item references the item stored in the current node.
   *  prev references the previous node in the DList.
   *  next references the next node in the DList.
   *
   *  DO NOT CHANGE THE FOLLOWING FIELD DECLARATIONS.
   */

  Object item;
  DListNode1 prev;
  DListNode1 next;

  /**
   *  DListNode1() constructor.
   */
  DListNode1() {
    this.item = null;
    this.prev = null;
    this.next = null;
  }

  DListNode1(Object item) {
    this.item = item;
    this.prev = null;
    this.next = null;
  }
}

      


My question is:

How can I make the types compatible at both compile time and runtime, and allow the value to be compared Line 105

? What is a runtime type 9

?

+1


source to share


2 answers


  • You can use type listing before comparison: (int)l.head.item != 9

    (it works in Java 7 and later, in older versions you can use (Integer)l.head.item

    ).
  • If the list is supposed to be homogeneous, using generics is a good idea.


+1


source


As you noted, the compiler cannot compare a primitive int

with Object

. One way is to use a wrapper class Integer

:



if (Integer.valueOf(9).equals(l.head.item)) { //Line 105

      

0


source







All Articles