What is the equivalent of the C# 'var' keyword in Java?

There is none. Alas, you have to type out the full type name.

Edit: 7 years after being posted, type inference for local variables (with var) was added in Java 10.

Edit: 6 years after being posted, to collect some of the comments from below:

• The reason C# has the var keyword is because it's possible to have Types that have no name in .NET. Eg:

  var myData = new { a = 1, b = "2" };
  

  In this case, it would be impossible to give a proper type to myData. 6 years ago, this was impossible in Java (all Types had names, even if they were extremely verbose and unweildy). I do not know if this has changed in the mean time.

• var is not the same as dynamic. variables are still 100% statically typed. This will not compile:

  var myString = "foo";
  myString = 3;
  

• var is also useful when the type is obvious from context. For example:

  var currentUser = User.GetCurrent();
  

  I can say that in any code that I am responsible for, currentUser has a User or derived class in it. Obviously, if your implementation of User.GetCurrent return an int, then maybe this is a detriment to you.

• This has nothing to do with var, but if you have weird inheritance hierarchies where you shadow methods with other methods (eg new public void DoAThing()), don't forget that non-virtual methods are affected by the Type they are cast as.

  I can't imagine a real world scenario where this is indicative of good design, but this may not work as you expect:

  class Foo {
      public void Non() {}
      public virtual void Virt() {}
  }
  
  class Bar : Foo {
      public new void Non() {}
      public override void Virt() {}
  }
  
  class Baz {
      public static Foo GetFoo() {
          return new Bar();
      }
  }
  
  var foo = Baz.GetFoo();
  foo.Non();  // <- Foo.Non, not Bar.Non
  foo.Virt(); // <- Bar.Virt
  
  var bar = (Bar)foo;
  bar.Non();  // <- Bar.Non, not Foo.Non
  bar.Virt(); // <- Still Bar.Virt
  

  As indicated, virtual methods are not affected by this.

• No, there is no non-clumsy way to initialize a var without an actual variable.

  var foo1 = "bar";        //good
  var foo2;                //bad, what type?
  var foo3 = null;         //bad, null doesn't have a type
  var foo4 = default(var); //what?
  var foo5 = (object)null; //legal, but go home, you're drunk
  

  In this case, just do it the old fashioned way:

  object foo6;
  

If you add Lombok to your project you can use its val keyword.

http://projectlombok.org/features/val.html

JEP - JDK Enhancement-Proposal

http://openjdk.java.net/jeps/286

JEP 286: Local-Variable Type Inference

Author Brian Goetz

// Goals:
var list = new ArrayList<String>();  // infers ArrayList<String>
var stream = list.stream();          // infers Stream<String>

With the release of JDK 10 on March 20, Java now includes a var reserved type name (not a keyword—see below) as specified in JEP 286. For local variables, the following is now valid in Java 10 or higher:

var map = new HashMap<String, Integer>();

The var reserved type name in Java is nearly identical to the var keyword in C# in that both allow for implicit typing (see below for important differences). var in Java can only be used for implicit type inference in the following contexts (as enumerated in JEP 286: Goals):

• local variables with initializers
• indexes in the enhanced for-loop
• locals declared in a traditional for-loop

Therefore var cannot be used for fields, return types, class names, or interface names. Its rationale is to remove the need for including long type names when declaring and defining local variables, as stated in JEP 286 (authored by Brian Goetz):

We seek to improve the developer experience by reducing the ceremony associated with writing Java code, while maintaining Java's commitment to static type safety, by allowing developers to elide the often-unnecessary manifest declaration of local variable types.

var Scoping in Java

It should be noted that var is not a keyword in Java, but rather a reserved type name. As quoted from JEP 286:

The identifier var is not a keyword; instead it is a reserved type name. This means that code that uses var as a variable, method, or package name will not be affected; code that uses var as a class or interface name will be affected (but these names are rare in practice, since they violate usual naming conventions).

Note that since var is a reserved type name and not a keyword, it can still be used for package names, method names, and variable names (along with its new type-interference role). For example, the following are all examples of valid uses of var in Java:

var i = 0;
var var = 1;
for (var i = 0; i < 10; i++) { /* ... */ }
public int var() { return 0; }
package var;

As quoted from JEP 286:

This treatment would be restricted to local variables with initializers, indexes in the enhanced for-loop, and locals declared in a traditional for-loop; it would not be available for method formals, constructor formals, method return types, fields, catch formals, or any other kind of variable declaration.

Differences Between var in Java & C

This is one notable difference between var in C# and Java include the following: var can be used as a type name in C# but cannot be used as a class name or interface name in Java. According to the C# documentation (Implicitly Typed Local Variables):

If a type named var is in scope, then the var keyword will resolve to that type name and will not be treated as part of an implicitly typed local variable declaration.

The ability to use var as a type name in C# creates some complexity and introduces some intricate resolution rules, which are avoided by var in Java by disallowing var as a class or interface name. For information on the complexities of var type names in C#, see Restrictions apply to implicitly-typed variable declarations. For more information on the rationale behind the scoping decision for `var in Java, see JEP 286: Scoping Choices.

I have cooked up a plugin for IntelliJ that – in a way – gives you var in Java. It's a hack, so the usual disclaimers apply, but if you use IntelliJ for your Java development and want to try it out, it's at https://bitbucket.org/balpha/varsity.