Java for C# Programmers 2: String, Console, Enum


C# has string, Java has String.

Strings are handled similar in both languages. In both cases, strings are class types and are immutable: String methods which seem at first to change the underlying object do not change this object, but create a new one and return the new one.

Escaping in string literals is the similar as in C#. Java knows

  • "\t, \n" and the like.
  • "\u20ac" for unicode characters.
  • Java understands "\065" as the octal value 065. This is not available in C#.
  • Java has no equivalent to the @ prefix for string constants. But it understands slashes as path separators, also on Windows.
  • Java does not understand "\x123" where 123 is interpreted as hex value.

Both languages have got also mutable string-like classes. C# has StringBuilder (not thread-safe). Java has StringBuilder (not thread-safe) and StringBuffer (thread-safe).

Like in C#, indexOf returns -1 if the searched string is not found.

string s = "abc";
int n = s.IndexOf("c", 7); // n = -1, no exception  

Gotcha: In Java, string comparison with == does not compare the contents. In C# it does. In Java, you have to use the function equals(..) to compare the contents of strings.

String Formatting

Java supports the old and well known C string formatters. C# doesn’t.

System.out.printf("Creating date: %02d.%02d.%04d", 10, 4, 2014); 
        // 10.04.2014

String s = String.format(">%6.2f<", 3.14159265359);  
        // s is  >  3,14< in Germany.
        // Yes, like in C#, the locale is used for formatting.

s = String.format(Locale.ENGLISH, ">%6.2f<", 3.141592);  
        // s is >  3.14<.

String Parsing

// Java
int i = Integer.parseInt("22"); 
int j = Integer.parseInt("ab");  // NumberFormatException

Java does not have TryParse functions.


Output to Stdout

Output to stdout is done via System.out.print*.

System.out.println();           // only newline
System.out.println("abc");      // abc + newline
System.out.print("abc");        // abc without newline
System.out.print("abc\n");      // abc + newline
System.out.print("a" + "bc" + "\n");      // abc + newline

Java does not support C#-like formatted printing with {0} and {1} and so on. Instead, it supports formatted printing with a C-like printf function with some extensions. I’m giving some examples here but won’t go into details.

System.out.printf("'%d'", 3);       //  '3'
System.out.printf("'%3x'", 10);     //  '  a'
System.out.printf("'%03d'", 3);     //  '003'
     String[][] z = {
            { "Name", "Anna" },
            { "Age", "27" },
            { "Sex", "Female" },
     for (String[] s : z) 
         System.out.printf("%-5s:%7s", s[0], s[1]);

     // This prints:

    Name :  Anna
    Age  :     19
    Sex  : Female

Find a tutorial of Java’s string formatting possibilities with printf and format there: And find the full format string syntax here:

Input From Stdin

        System.out.print("\nEnter your weight:");
        double weight = sc.nextDouble();
        sc.nextLine(); // needed to consume the enter-key  
                       // left by the input of the double 

        System.out.print("\nEnter your name:");
        String name = sc.nextLine();

        System.out.print("\nEnter your size in cm:");
        int size = sc.nextInt();

        System.out.printf("\nWeight: %g   Name: %s   Size: %d", 
            weight, name, size);

Gotcha: After

Scanner sc = new Scanner(;
sc = new Scanner(;

you’ll get an NoSuchElementException in the last line. It is because sc.close() closes not only the Scanner, but also the stream. Which cannot be reopened. So if you want to have a Scanner in your program which is bound to, you can not close it if you may need it any time later in the same program.


There are enums in both languages, but there are huge differences. In C#, enums are implemented very similar to C and C++, as some special integers. They are derived from type Enum which is derived from one of the integer value types.

In Java, enumerations are also derived from a type called Enum, but this is a class, a reference type. There are no traces of underlying integers like in C#.

Like classes, enums can be defined in an own source file, as a subtype of another class or as a non-public type in a source file with another public type.

public enum Fruit { BANANA, ORANGE, APPLE, LEMON, PEAR };


public class A 
    enum SortOrder { ASCENDING, DESCENDING };


public class A 
enum Erinyes { Alecto, Megaera, Tisiphone };

The main methods of Enum are shown here.

Fruit a = Fruit.BANANA;
    // -> BANANA    name()  is not overridable
    // -> BANANA    toString() is overridable

Fruit b = Fruit.valueOf("APPLE");   // Create an enum from its name  
System.out.println(;       // APPLE    

// Create an enum from its name, 2nd possibility:

Fruit c = Enum.valueOf(Fruit.class, "ORANGE");  

// The ordinal() value is used to sort enums. 
// You cannot change the ordinal value
// aside of by changing the order in the definition. 
System.out.printf("%s:%d\n", c, c.ordinal());   // ORANGE:1
System.out.println(a.compareTo(b));             // -2     

for(Fruit i: Fruit.values())        
    System.out.printf("%s:%d ",, i.ordinal());  

// In contrast to Java's behaviour for strings, 
// the == operator for enums does what you expect.         

Fruit d = Fruit.ORANGE, e = Fruit.ORANGE;
if(d == e)
    System.out.println("==");       // ==
    System.out.println("equal");    // equal

Fruit k = Fruit.valueOf("Grapple"); // IllegalArgumentException    


In C#, you can define and use a set of flags like this:

enum Spices { None, Salt=1, Pepper=2, Chili=4, Paprika=8 };

void Main() 
    Spices x = Spices.Salt | Spices.Pepper;
    Console.WriteLine(x);               // Salt, Pepper

This is not possible in Java. In Java, you have to use a set of enums to represent flags. The type EnumSet is designed for that.

enum Spices { SALT, PEPPER, CHILI };

EnumSet<Spices> s = EnumSet.noneOf(Spices.class);   // s is empty. 
s = EnumSet.allOf(Spices.class);  // s is (SALT | PEPPER | CHILI)

s = EnumSet.of(Spices.PAPRIKA, Spices.CHILI);   // s is (PEPPER | CHILI)

s = EnumSet.complementOf(s);                    // s is (SALT)

EnumSet<Spices> z = EnumSet.copyOf(s);          // z is (SALT) 
System.out.println(z);                          // [SALT]

Enum With Methods, Properties And Constructors

You can add methods and properties to an enum like to any ordinary class. You can override virtual methods and you can add constructors. You cannot create an enum that is derived from another enum.

public enum Flavors { SWEET, SOUR, SPICY };

public enum Fruit 
    ORANGE(EnumSet.of(Flavors.SWEET, Flavors.SOUR)),

    private Fruit(EnumSet<Flavors> flavors)
        this.flavors = flavors;

    public String toString()
        return name().toLowerCase() + flavors.toString();

    public String toGerman()
            case "BANANA":
                return "Banane";
            case "ORANGE":
                return "Orange";
            case "LEMON":
                return "Zitrone";
        return null;

    private EnumSet<Flavors> flavors;

System.out.println(Fruit.BANANA.toString());   // banana[SWEET]    

System.out.println(Fruit.ORANGE);              // orange[SWEET, SOUR]

System.out.println(Fruit.LEMON.toGerman());    // Zitrone

Java for C# Programmers, Part 1: Primitives

This is part 1 of a series of articles about Java for C# Programmers.

  • I strive to present a terse but complete depiction of the differences between Java and C#, from the point of view of an experienced C# programmer.
  • I do not strive to present a a complete reference of the Java language here. A complete reference for Java can be found on
  • Gotcha: Facts that are really unexpected for a C# guy are labeled Gotcha.

How Came?

  • Currently, I’m doing a Java course. While learning, I’m writing down what I’ve learned, as a reference for other C# guys and myself.
  • Java is a programming language. As such, it is a developer tool. It is public since 1995. A time-tested one, too 😉


In both languages, indentifiers must not start with a number and must not contain spaces. Aside of these rules, most characters are allowed. Including german umlauts ÄÖÜ and currency symbols. Äöüß$$€ is an allowed indentifier.

Naming Conventions

  • Classes and interfaces: First letter uppercase. Rest camel cased.
  • Packages: lowercased, no _ separators. package bananaboat;. When you have a lot of packages, subdivide names by dots.
  • Use pascal cased nouns for class names. Banana, BookDocument
  • Use adjectives for interface names, without leading I. Eatable, Printable
  • Methods: First letter lowercase. Rest camel cased. Verbs. getPrinter()
  • Variables: Like methods. myFruit. Use short names for short lived variables. int i.
  • Constants: All uppercased, _ as separator. MAX_WIDTH

Primitive Data Types

It is all the same as in C#, aside of the following differences.

  • The unsigned integer types do not exist in Java.
  • Gotcha: This means byte is signed in Java.
  • The high precision floating point type decimal does not exist in Java.
  • bool is called boolean.
  • C#’s nullable bool? type supports ternary logic with the & and | operators. There is no equivalent in Java.
  • Pointers and tuples do not exist in Java.
  • In Java, the primitive types are not derived from object. (In C# they are, via Object -> ValueType -> primitive type.)
  • Gotcha: Java’s Date is a reference type but C#’s DateTime a value type.
  • There is no TimeSpan in Java.


Mostly the same as in C#.

Gotcha: In Java, integer literals starting with a zero are interpreted as octal values. Not so in C#.
int i = 077; // Java: i is 63 decimal

Gotcha: In the following piece of code, the longWithoutL constant is calculated as int and then just assigned to the long. In C#, you’ll get a compile error when making such a mistake.

long longWithL = 1000*60*60*24*365L;
long longWithoutL = 1000*60*60*24*365;
System.out.println(longWithL);    // 31536000000
System.out.println(longWithoutL); // 1471228928

Additionally, binary notation for integer type values
is allowed.

int eleven = 0b1011;        // 11 decimal
int minuseleven= -0b1011;   // -11 decimal
byte minusone =         // Compile error. Byte is signed.  
         0b11111111;    //  You can use only 7 bits in 0b notation. 
byte b = -0b1;          // -1 decimal

Wrapper Classes / Boxing / Unboxing

In Java, the primitve types are not derived from Object. Probably because of this, you cannot use them in generics, cannot pass them by reference and they have no methods.
But for every primitive data type, there is a wrapper class which you can use in generics and has generally the same behaviour as the primitive type.

  • They are called Byte, Short, Integer, Long. Float, Double, Boolean. Character, ….
  • Automatic conversion to and from the primitive types works well.
  • You cannot use these wrapper classes to do a pass by reference for primitive types.
  • Some standard functions are implemented on these wrapper classes, e.g. toString().

Java’s Atomic Wrapper Classes

There is another type of wrapper classes available in Java. They are called Atomic Wrapper Classes.

  • AtomicBoolean, AtomicInteger, AtomicLong, and AtomicReference.
  • There is no automatic conversion to and from these types.
  • You can change their value and so they can be used for pass by reference of primitive types.
  • They are thread safe.
  • They implement a lot of functions in an atomic way, like incrementAndGet(), getAndAdd(int delta) and the like.

Pass By Ref of Primitive Data Types

static void Test()
    AtomicInteger i = new AtomicInteger();
    System.out.println("i: " + i);      // i: 4

    int[] j = { 3 };
    System.out.println("j[0]: " + j[0]);    // j[0]: 4

    Integer k = 3;
    System.out.println("k: " + k);      // k: 3   **GOTCHA**

static void passByRef1(AtomicInteger i)

static void passByRef2(int[] i)

static void passByRefNotGood(Integer i)
        i += 1;     // **GOTCHA** This does NOT increment the 
                    // outer Integer, but there's no compile error.

Unboxing of Numbers in Calculations

// C#:
int? a = null, c = 3;
int? b = c * a;        // b becomes null.

bool? d = false, e = null;
bool? f = d & e;       // f becomes false. Ternary logic.   
bool? g = d | e;       // g becomes null. Ternary logic.  

// Java: 
Integer a = null, c = 3;   
Integer b = c * a;      // NullPointerException happens. 

Boolean d = false, e = null;
Boolean f = d & e;      // NullPointerException.