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

Strings

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.

Console

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: http://docs.oracle.com/javase/tutorial/essential/io/formatting.html. And find the full format string syntax here:
http://docs.oracle.com/javase/7/docs/api/java/util/Formatter.html#syntax.

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(System.in);
sc.close();
sc = new Scanner(System.in);
sc.nextInt();

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

Enums

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 };

or

public class A 
{
    enum SortOrder { ASCENDING, DESCENDING };
}

or

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

The main methods of Enum are shown here.

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

Fruit b = Fruit.valueOf("APPLE");   // Create an enum from its name  
System.out.println(b.name());       // 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.name(), i.ordinal());  
    // -> BANANA:0 ORANGE:1 APPLE:2 LEMON:3 PEAR:4


// 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("==");       // ==
if(d.equals(e))
    System.out.println("equal");    // equal

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

Flags

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

[Flags]
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 
{ 
    BANANA(EnumSet.of(Flavors.SWEET)),
    ORANGE(EnumSet.of(Flavors.SWEET, Flavors.SOUR)),
    LEMON(EnumSet.of(Flavors.SOUR));

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

    @Override
    public String toString()
    {
        return name().toLowerCase() + flavors.toString();
    }

    public String toGerman()
    {
        switch(name())
        {
            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 http://docs.oracle.com/javase/tutorial/java/.
  • 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 😉

Identifiers

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. app.boats.bananaboat
  • 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.

Literals

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();
    i.set(3);
    passByRef1(i);
    System.out.println("i: " + i);      // i: 4

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

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

static void passByRef1(AtomicInteger i)
{
    i.incrementAndGet();
}

static void passByRef2(int[] i)
{
    i[0]++;
}

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.

Randomness in Unit Tests

Poker set 2

Most of us programmers are writing unit tests for at least some of their code. This is very fine.

And, as I’ve seen in one of my latest projects, many of us have had the idea to use randomness in these unit tests. On the one hand, this good: With randomness, more different inputs are tested.
On the other hand, this is bad: Because if the seed of the random number generator is not known, we cannot reproduce a failing test.
So it could be the case that we have a nightly build with failing tests, but no way to reproduce (and hence debug) them because of the random input.

The solution: Use a seed that is based on the day, but not on on hours, minutes, seconds or ticks. This way we have both advantages: testing regularly with different input, but also easy reproducibility if one knows the day on which the test was run.
In C#, like this:

static DateTime now = DateTime.Now;
static int seed = (now.Year << 16) + (now.Month << 8 ) + now.Day;
static Random randomGenerator = new Random(seed);

 

LINQPad: Most Amazing Tool to do Database Queries, Learn .NET, LINQ and More

LINQPad is an amazing tool for .NET developers. Really, it is the best tool for .NET developers that I’ve ever come across – aside of VisualStudio. So it deserves well to be the subject of the first post in my blog about time-tested tools for developers:

99 Developer Tools

With LINQPad, you can

  • Run any C#, F#, VB code snippet you like, e.g. test regular expressions, …
  • Get information about the tables in your database.
  • Do database queries with LINQ query syntax.
  • See the result of the query nicely formatted in different ways.
  • See the Lambda code created by the compiler from your query code.
  • See the SQL code created from your query code.
  • See the execution time of  your LINQ query.
  • Do database queries with Lambda syntax.
  • Learn LINQ.
  • See dozens of examples of LINQ queries. Just select “Samples” in the lower left window of LINQPad, work through all the examples, and you’ve mastered LINQ 😉
  • If you forgot some keyword or some syntax, the “Samples” section is also good as a reference book for LINQ.
  •  Use a typed data context from your own assembly/EF, too. (I’ve not tried this out, yet.)

LINQPad 4

 

How to attach LINQPad to a SQLite database XYZ.db:

  • Download and start LINQPad. No installation needed.
  • At the top left, select “Add connection”.
  • View more drivers / IQ driver for MySQL, SQLite, … / Download & enable driver
  • Build data context automatically / IQ (Supports … SQLite)
  • SQLite
  • Browse / Location of database File / XYZ.db

What do you think about LINQPad? Are there similar tools that I should know of?

Cheers
Andreas