Moving from C++ to Java

• First, the good news …

  • You already know most of the language
    • Syntax is largely the same as C++
    • Semantics are similar

• Then, the bad news …

  • The “standard libraries” of Java and C++ are very, very different

• In this lesson, I’ll highlight the differences between Java and C++ that you will need to get started.

public class HelloWorld {

  public static void main (String[] argv)
  {
    System.out.println ("Hello, World!");
  }
}

class MailingList {
private:
   struct Node {
      Contact data;
      Node* next;
   };
   Node* first;
public:
   MailingList() 
   {
      first = nullptr;
   }
     ⋮
};

public class MailingList {
   private class Node {
      Contact data;
      Node next;
   }
   private Node first;
   public MailingList() 
   {
      first = null;
   }
     ⋮
}

namespace myUtilities {
  class Randomizer {
    ⋮
  };
};

package myUtilities;
class Randomizer {
   ⋮
}

• Becomes part of the fully qualified name¹ of a class

We Can Have Short-Cuts

using myUtilities::Randomizer
   ⋮
Randomizer r;

import myUtilities.Randomizer;
   ⋮
Randomizer r;

using namespace myUtilities;
   ⋮
Randomizer r;

import myUtilities.*;
   ⋮
Randomizer r;

• C++ distinguishes between class

  • declarations: usually placed in a header (.h file), and
  • definitions: usually placed in a compilation unit (.cpp file)

  e.g.,

  mailinglist.h

  #ifndef MAILINGLIST_H
  #define MAILINGLIST_H
  
  #include <iostream>
  #include <string>
  
  #include "contact.h"
  
  /**
     A collection of names and addresses
  */
  
  class MailingList
  {
  public:
    MailingList();
    MailingList(const MailingList&);
    ~MailingList();
  
    const MailingList& operator= (const MailingList&);
  
    // Add a new contact to the list
    void addContact (const Contact& contact);
  
    // Remove one matching contact
    void removeContact (const Contact&);
    void removeContact (const Name&);
  
    // Find and retrieve contacts
    bool contains (const Name& name) const;
    Contact getContact (const Name& name) const;
  
  
    // combine two mailing lists
    void merge (const MailingList& otherList);
  
    // How many contacts in list?
    int size() const;
  
  
    bool operator== (const MailingList& right) const;
    bool operator< (const MailingList& right) const;
  
  private:
  
    struct ML_Node {
      Contact contact;
      ML_Node* next;
  
      ML_Node (const Contact& c, ML_Node* nxt)
        : contact(c), next(nxt)
      {}
    };
  
    int theSize;
    ML_Node* first;
    ML_Node* last;
  
    // helper functions
    void clear();
    void remove (ML_Node* previous, ML_Node* current);
  
    friend std::ostream& operator<< (std::ostream& out, const MailingList& addr);
  };
  
  // print list, sorted by Contact
  std::ostream& operator<< (std::ostream& out, const MailingList& list);
  
  
  #endif
  

  and

  mailinglist.cpp

  #include <cassert>
  #include <iostream>
  #include <string>
  #include <utility>
  
  #include "mailinglist.h"
  
  
  using namespace std;
  using namespace rel_ops;
  
  
  
  MailingList::MailingList()
    : first(nullptr), last(nullptr), theSize(0)
  {}
  
  MailingList::MailingList(const MailingList& ml)
    : first(nullptr), last(nullptr), theSize(0)
  {
    for (ML_Node* current = ml.first; current != nullptr;
         current = current->next)
      addContact(current->contact);
  }
  
  
  MailingList::~MailingList()
  {
    clear();
  }
  
  const MailingList& MailingList::operator= (const MailingList& ml)
  {
    if (this != &ml)
      {
        clear();
        for (ML_Node* current = ml.first; current != nullptr;
  	   current = current->next)
  	addContact(current->contact);
      }
    return *this;
  }
  
  
  // Add a new contact to the list
  void MailingList::addContact (const Contact& contact)
  {
    if (first == nullptr) 
      { // add to empty list
        first = last = new ML_Node(contact, nullptr);
        theSize = 1;
      }
    else if (contact > last->contact)
      { // add to end of non-empty list
        last->next = new ML_Node(contact, nullptr);
        last = last->next;
        ++theSize;
      }
    else if (contact < first->contact)
      { // add to front of non-empty list
        first = new ML_Node(contact, first);
        ++theSize;
      }
    else
      { // search for place to insert
        ML_Node* previous = first;
        ML_Node* current = first->next;
        assert (current != nullptr);
        while (contact < current->contact)
  	{
  	  previous = current;
  	  current = current->next;
  	  assert (current != nullptr);
  	}
        previous->next = new ML_Node(contact, current);
        ++theSize;
      }
  }
  
  
  // Remove one matching contact
  void MailingList::removeContact (const Contact& contact)
  {
    ML_Node* previous = nullptr;
    ML_Node* current = first;
    while (current != nullptr && contact > current->contact)
      {
        previous = current;
        current = current->next;
      }
    if (current != nullptr && contact == current->contact)
      remove (previous, current);
  }
  
  
  void MailingList::removeContact (const Name& name)
  {
    ML_Node* previous = nullptr;
    ML_Node* current = first;
    while (current != nullptr
  	 && name > current->contact.getName())
      {
        previous = current;
        current = current->next;
      }
    if (current != nullptr 
  	 && name == current->contact.getName())
      remove (previous, current);
  }
  
  
  
  // Find and retrieve contacts
  bool MailingList::contains (const Name& name) const 
  {
    ML_Node* current = first;
    while (current != nullptr
  	 && name > current->contact.getName())
      {
        previous = current;
        current = current->next;
      }
    return (current != nullptr 
  	  && name == current->contact.getName());
  }
  
  
  Contact MailingList::getContact (const Name& name) const
  {
    ML_Node* current = first;
    while (current != nullptr
  	 && name > current->contact.getName())
      {
        previous = current;
        current = current->next;
      }
    if (current != nullptr 
  	  && name == current->contact.getName())
      return current->contact;
    else
      return Contact();
  }
  
  
  
  
  
  // combine two mailing lists
  void MailingList::merge (const MailingList& anotherList)
  {
    // For a quick merge, we will loop around, checking the 
    // first item in each list, and always copying the smaller
    // of the two items into result
    MailingList result;
    ML_Node* thisList = first;
    const ML_Node* otherList = anotherList.first;
    while (thisList != nullptr and otherList != nullptr)
      {
        if (thisList->contact < otherList->contact)
  	{
  	  result.addContact(thisList->contact);
  	  thisList = thisList->next;
  	}
        else
  	{
  	  result.addContact(otherList->contact);
  	  otherList = otherList->next;
  	}
      }
    // Now, one of the two lists has been entirely copied. 
    // The other might still have stuff to copy. So we just copy
    // any remaining items from the two lists. Note that one of these
    // two loops will execute zero times.
    while (thisList != nullptr)
      {
        result.addContact(thisList->contact);
        thisList = thisList->next;
      }
    while (otherList != nullptr)
      {
        result.addContact(otherList->contact);
        otherList = otherList->next;
      }
    // Now result contains the merged list. Transfer that into this list.
    clear();
    first = result.first;
    last = result.last;
    theSize = result.theSize;
    result.first = result.last = nullptr;
    result.theSize = 0;
  }
  
  // How many contacts in list?
  int MailingList::size() const
  {
    return theSize;
  }
  
  
  bool MailingList::operator== (const MailingList& right) const
  {
    if (theSize != right.theSize) // (easy test first!)
      return false;
    else
      {
        const ML_Node* thisList = first;
        const ML_Node* otherList = right.first;
        while (thisList != nullptr)
  	{
  	  if (thisList->contact != otherList->contact)
  	    return false;
  	  thisList = thisList->next;
  	  otherList = otherList->next;
  	}
        return true;
      }
  }
  
  
  bool MailingList::operator< (const MailingList& right) const
  {
    if (theSize < right.theSize)
      return true;
    else
      {
        const ML_Node* thisList = first;
        const ML_Node* otherList = right.first;
        while (thisList != nullptr)
  	{
  	  if (thisList->contact < otherList->contact)
  	    return true;
  	  else if (thisList->contact > otherList->contact)
  	    return false;
  	  thisList = thisList->next;
  	  otherList = otherList->next;
  	}
        return false;
      }
  }
  
  
  // helper functions
  void MailingList::clear()
  {
    ML_Node* current = first;
    while (current != nullptr)
      {
        ML_Node* next = current->next;
        delete current;
        current = next;
      }
    first = last = nullptr;
    theSize = 0;
  }
  
  
  void MailingList::remove (MailingList::ML_Node* previous,
  			  MailingList::ML_Node* current)
  {
    if (previous == nullptr)
      { // remove front of list
        first = current->next;
        if (last == current)
  	last = nullptr;
        delete current;
      }
    else if (current == last)
      { // remove end of list
        last = previous;
        last->next = nullptr;
        delete current;
      }
    else
      { // remove interior node
        previous->next = current->next;
        delete current;
      }
    --theSize;
  }
  
  
  // print list, sorted by Contact
  std::ostream& operator<< (std::ostream& out, const MailingList& list)
  {
    MailingList::ML_Node* current = list.first;
    while (current != nullptr)
      {
        out << current->contact << "\n";
        current = current->next;
      }
    out << flush;
    return out;
  }
  

• Java puts the entire class into one file

  MailingList.java

  package mailinglist;
  
  /**
   * A collection of names and addresses
   */
  public class MailingList implements Cloneable {
  
  	/**
  	 * Create an empty mailing list
  	 *
  	 */
  	public MailingList() {
  		first = null;
  		last = null;
  		theSize = 0;
  	}
  
  	/**
  	 *  Add a new contact to the list
  	 *  @param contact new contact to add
  	 */
  	public void addContact(Contact contact) {
  		if (first == null) {
  			// add to empty list
  			first = last = new ML_Node(contact, null);
  			theSize = 1;
  		} else if (contact.compareTo(last.contact) > 0) {
  			// add to end of non-empty list
  			last.next = new ML_Node(contact, null);
  			last = last.next;
  			++theSize;
  		} else if (contact.compareTo(first.contact) < 0) {
  			// add to front of non-empty list
  			first = new ML_Node(contact, first);
  			++theSize;
  		} else {
  			// search for place to insert
  			ML_Node previous = first;
  			ML_Node current = first.next;
  			assert (current != null);
  			while (contact.compareTo(current.contact) < 0) {
  				previous = current;
  				current = current.next;
  				assert (current != null);
  			}
  			previous.next = new ML_Node(contact, current);
  			++theSize;
  		}
  	}
  
  	/**
  	 *  Remove one matching contact 
  	 *  @param c remove a contact equal to c
  	 */
  	public void removeContact(Contact c) {
  		ML_Node previous = null;
  		ML_Node current = first;
  		while (current != null && c.compareTo(current.contact) > 0) {
  			previous = current;
  			current = current.next;
  		}
  		if (current != null && c.equals(current.contact))
  			remove(previous, current);
  	}
  
  	/**
  	 * Remove a contact with the indicated name
  	 * @param name name of contact to remove
  	 */
  	public void removeContact(String name) {
  		ML_Node previous = null;
  		ML_Node current = first;
  		while (current != null && name.compareTo(current.contact.getName()) > 0) {
  			previous = current;
  			current = current.next;
  		}
  		if (current != null && name == current.contact.getName())
  			remove(previous, current);
  
  	}
  
  	/**
  	 * Search for contacts
  	 * @param name name to search for
  	 * @return true if a contact with an equal name exists
  	 */
  	public boolean contains(String name) {
  		ML_Node current = first;
  		while (current != null && name.compareTo(current.contact.getName()) > 0) {
  			current = current.next;
  		}
  		return (current != null && name == current.contact.getName());
  	}
  
  	/**
  	 * Search for contacts
  	 * @param name name to search for
  	 * @return contact with that name if found, null if not found
  	 */
  	public Contact getContact(String name) {
  		ML_Node current = first;
  		while (current != null && name.compareTo(current.contact.getName()) > 0) {
  			current = current.next;
  		}
  		if (current != null && name == current.contact.getName())
  			return current.contact;
  		else
  			return null;
  	}
  
  	/**
  	 * combine two mailing lists
  	 *
  	 */
  	public void merge(MailingList anotherList) {
  		// For a quick merge, we will loop around, checking the 
  		// first item in each list, and always copying the smaller
  		// of the two items into result
  		MailingList result = new MailingList();
  		ML_Node thisList = first;
  		ML_Node otherList = anotherList.first;
  		while (thisList != null && otherList != null) {
  			if (thisList.contact.compareTo(otherList.contact) < 0) {
  				result.addContact(thisList.contact);
  				thisList = thisList.next;
  			} else {
  				result.addContact(otherList.contact);
  				otherList = otherList.next;
  			}
  		}
  		// Now, one of the two lists has been entirely copied. 
  		// The other might still have stuff to copy. So we just copy
  		// any remaining items from the two lists. Note that one of these
  		// two loops will execute zero times.
  		while (thisList != null) {
  			result.addContact(thisList.contact);
  			thisList = thisList.next;
  		}
  		while (otherList != null) {
  			result.addContact(otherList.contact);
  			otherList = otherList.next;
  		}
  		// Now result contains the merged list. Transfer that into this list.
  		first = result.first;
  		last = result.last;
  		theSize = result.theSize;
  	}
  
  	/**
  	 * How many contacts in list?
  	 */
  	public int size() {
  		return theSize;
  	}
  
  	/**
  	 * Return true if mailing lists contain equal contacts
  	 */
  	public boolean equals(Object anotherList) {
  		MailingList right = (MailingList) anotherList;
  		if (theSize != right.theSize) // (easy test first!)
  			return false;
  		else {
  			ML_Node thisList = first;
  			ML_Node otherList = right.first;
  			while (thisList != null) {
  				if (!thisList.contact.equals(otherList.contact))
  					return false;
  				thisList = thisList.next;
  				otherList = otherList.next;
  			}
  			return true;
  		}
  	}
  
  	public int hashCode() {
  		int hash = 0;
  		ML_Node current = first;
  		while (current != null) {
  			hash = 3 * hash + current.hashCode();
  			current = current.next;
  		}
  		return hash;
  	}
  
  	public String toString() {
  		StringBuffer buf = new StringBuffer("{");
  		ML_Node current = first;
  		while (current != null) {
  			buf.append(current.toString());
  			current = current.next;
  			if (current != null)
  				buf.append("\n");
  		}
  		buf.append("}");
  		return buf.toString();
  	}
  
  	/**
  	 * Deep copy of contacts
  	 */
  	public Object clone() {
  		MailingList result = new MailingList();
  		ML_Node current = first;
  		while (current != null) {
  			result.addContact((Contact) current.contact.clone());
  			current = current.next;
  		}
  		return result;
  	}
  
  	private class ML_Node {
  		public Contact contact;
  
  		public ML_Node next;
  
  		public ML_Node(Contact c, ML_Node nxt) {
  			contact = c;
  			next = nxt;
  		}
  	}
  
  	private int theSize;
  
  	private ML_Node first;
  
  	private ML_Node last;
  
  	// helper functions
  	private void remove(ML_Node previous, ML_Node current) {
  		if (previous == null) {
  			// remove front of list
  			first = current.next;
  			if (last == current)
  				last = null;
  		} else if (current == last) {
  			// remove end of list
  			last = previous;
  			last.next = null;
  		} else {
  			// remove interior node
  			previous.next = current.next;
  		}
  		--theSize;
  	}
  
  }
  

• Function bodies are written immediately after their declaration

  • To C++ programmers, these look like inline functions

public class HelloWorld {

  public static void main (String[] argv)
  {
    System.out.println ("Hello, World!");
  }
}

package Foo;

public class HelloWorld {

  public static void main (String[] argv)
  {
    System.out.println ("Hello, World!");
  }
}

package Foo.Bar;

public class HelloWorld {

  public static void main (String[] argv)
  {
    System.out.println ("Hello, World!");
  }
}

int x = 2;
int y = x;
++x;
System.out.println ("x=" + x + " y=" + y);

void foo(java.awt.Point p) {
  p.x = 1;
  java.awt.Point w = p;
  w.x = 2;
  System.out.println ("p.x=" + p.x + " w.x=" + w.x);
}

  java.awt.Point w = p;

Point p (1,2);

Point p = new Point(1,2);

int a[10];
Point* p = new Point[10];

int[] b = new int[10];
Point[] q = new Point[10];
for (int i = 0; i < q.length; ++i)
   q[i] = new Point();

void printSorted(const vector<int>& v)
{
   int* array = new int[v.size()];
   for (int i = 0; i < v.size(); ++i)
       array[i] = v[i];
   sort (array, array+v.size());
   for (int i = 0; i < v.size(); ++i)
       cout << array[i] << endl;
}

void printSorted(ArrayList<int> v)
{
   int[] array = new int[v.size()];
   for (int i = 0; i < v.size(); ++i)
       array[i] = v.get(i);
   Arrays.sort (array);
   for (int i = 0; i < v.size(); ++i)
       System.out.println("" + array[i]);
}

(If you are interested in how garbage collection works, you can read about it here.)

Point p = new Point(1,2);
Point q = new Point(1,2);
if (p.equals(q))
   System.out.println ("That's better.");
else
   System.out.println ("Pay no attention...");

import java.io.*;

/**
   Demo of a program that may throw exceptions.
   @param argv The name of a file to open for input
*/
public class OpenFile1 {

  /**
     Attempt to open a file
  */
  static void openFile (String fileName) {
	FileReader reader = new FileReader(fileName);
  }
  
  /**
     Attempt to open the file whose name is given in
     the first command line parmaeter
  */
  public static void main (String[] argv) {
	String fileName = argv[1];
	openFile (fileName);
  }
}

import java.io.*;

/**
   Demo of a program that may throw exceptions.
   @param argv The name of a file to open for input
*/
public class OpenFile2 {
  
  /**
     Attempt to open a file
  */
  static void openFile (String fileName)
	throws java.io.FileNotFoundException
  {
	FileReader reader = new FileReader(fileName);
  }
  
  /**
     Attempt to open the file whose name is given in
     the first command line parmaeter
  */
  public static void main (String[] argv) {
	String fileName = argv[0];
	openFile (fileName);
  }
}

import java.io.*;

/**
   Demo of a program that may throw exceptions.
   @param argv The name of a file to open for input
*/
public class OpenFile3 {
  
  /**
     Attempt to open a file
  */
  static void openFile (String fileName)
	throws java.io.FileNotFoundException
  {
	FileReader reader = new FileReader(fileName);
  }
  
  /**
     Attempt to open the file whose name is given in
     the first command line parmaeter
  */
  public static void main (String[] argv) {
      try {
	  openFile (argv[0]);
      }
      catch (java.io.FileNotFoundException ex)
	  {
	      System.err.println ("Something is wrong with the file: " + ex);
	  }
      System.out.println ("All done");
  }
}

using both the names of existing and non-existing files, or no name at all.

Unchecked Exceptions

Exceptions come in two main kinds: checked and unchecked

• unchecked exceptions could arise almost anywhere

  • e.g., NullPointerException, ArrayIndexOutOfBoundsException

• functions need not declare that they might throw these

Checked Exceptions

checked exceptions are more specialized

• include all programmer-defined exceptions

• functions must declare if they can throw these

Another Cultural Difference

• C++ actually has exceptions as well.

  • Same throw and try – catch syntax

  • Can’t declare what exceptions a function is known to throw

• But they are used much more widely in Java

The Java API (the equivalent of the C++ std library) is huge, but well documented

• Focus initially on packages java.lang, java.io, and java.util

• BTW, You can use the javadoc to generate the same kind of documentation for your own code. Example

5.2 Strings

C++ std::string : Java java.lang.String

• Strings in Java are immutable
  • You cannot change the contents of a string value
  • But you can compute a slightly different value and make a string variable point to the different value

string s = ...
s[s.size()/2] = 'b';
s = s + s;

String s = ...
s = s.substring(0,s.length()/2)
  + 'b' 
  +  s.substring(s.length()/2+1);
s = s + s;

If You Need to Change a Java String…

…use a StringBuilder

StringBuilder sb = new StringBuilder();
String line = input.readline();
while (line != null) {
  sb.append(line);
  sb.append("\n");
  line = input.readline();
}
String allTheText = sb.toString();

vector<string> v;
v.push_back("foo");
cout << v[0] << endl

ArrayList<String> v = new ArrayList<String>();
v.add("foo");
System.out.println (v.get(0)); 

list<string> L;
L.push_back("foo");
cout << L.front() << endl

LinkedList<String> L = new LinkedList<String>();
L.add("foo");
System.out.println (L.getFirst()); 

set<string> s;
s.insert("foo");
cout << s.count("foo") << endl

TreeSet<String> S = new TreeSet<String>();
S.add("foo");
System.out.println ("" + S.contains("foo")); 

unordered_set<string> s;
s.insert("foo");
cout << s.count("foo") << endl

HashSet<String> S = new HashSet<String>();
S.add("foo");
System.out.println ("" + S.contains("foo")); 

map<string,int> zip;
zip["ODU"] = 23529;
cout << zip["ODU"] << endl

TreeMap<String,Integer> zip
     = new TreeMap<String,Integer>();
zip.put("ODU", 23529);
System.out.println (zip.get("ODU")); 

unordered_map<string,int> zip;
zip["ODU"] = 23529;
cout << zip["ODU"] << endl

HashMap<String,Integer> zip
     = new HashMap<String,Integer>();
zip.put("ODU", 23529);
System.out.println (zip.get("ODU")); 

1: A fully qualified name is an unambiguous name for an entity (function, variable, class, etc.) that is independent of the context in which it is used. Generally this means that when you have a hierarchy of entities contained inside other entities, you must name all of the containers, in order.