Visual Basic.CodeCompared.To/Java

Java keeps the wrapper Visual Basic keeps: a type containing an entry point. Module becomes class, Sub Main() becomes public static void main(String[] args) — that exact signature, always. Console.WriteLine becomes System.out.println. Blocks close with a brace rather than End, and every statement ends with a semicolon. Of every target on this anchor, Java asks for the most boilerplate around the smallest program.

Java has no $"..." equivalent. The three options are concatenation with +, String.format, and printf, all using C-style placeholders: %s, %d, %.2f, %05d. %n is the newline, which is why printf needs one and println does not. Java 21's string templates were withdrawn before standardisation, so this is the state of things and is unlikely to change soon.

Every End becomes a closing brace, Then disappears, and ElseIf becomes two words. A single-statement block may drop its braces, and the convention in most Java codebases is to keep them anyway. Note that && and || replace AndAlso and OrElse, and a condition must be a boolean — there is no truthiness, so if (count) does not compile.

Identifiers are case-sensitive. The convention is camelCase for variables and methods — not PascalCase — with PascalCase reserved for classes and interfaces and UPPER_SNAKE_CASE for constants. So person.Describe() becomes person.describe(), and this is the fastest way to spot code written by someone arriving from .NET. Interfaces take no I prefix either.

' becomes //, plus a block form /* ... */ Visual Basic never had. Javadoc, /** ... */, is what '''<summary> becomes: the same idea with @param, @return and @throws tags instead of XML elements, read by the IDE and by the javadoc tool.

Read Dim count As Integer right to left and you have int count. Option Infer becomes var, available for locals only. Const becomes static final, and a local constant is just final. The one that needs care: Java has no Decimal. BigDecimal is the money type, it is a class rather than a primitive, it has no literal syntax, and it must be constructed from a string — new BigDecimal(19.99) has already lost the precision you wanted.

Integer→int, Long→long, Single→float, Double→double, Boolean→boolean, Char→char with single quotes. In .NET an Integer is an object when it needs to be. In Java the primitive int and the class Integer are different types, and List<int> does not compile — it must be List<Integer>. The conversion happens automatically (autoboxing), which is convenient until it is not; the gotchas section covers the case where it bites.

Nothing becomes null, with two differences. A Java primitive cannot be null — int x = null; does not compile — so nullability means using the boxed type, which is Java's version of Integer?. And modern Java prefers Optional<T> as a return type: the caller can see absence is possible and orElse supplies the fallback that the two-argument If() supplies. Optional is for return values, not fields or parameters — that is the community convention.

CInt→Integer.parseInt, CDbl→Double.parseDouble, CStr→String.valueOf. Widening is implicit as it is in Visual Basic; narrowing needs a cast, (int) someDouble, which is DirectCast. There is no TryParse — Java has no output parameters — so a conversion that might fail is wrapped in try/catch (NumberFormatException). That is the idiomatic answer, not a workaround.

For primitives, == compares values as you expect. For objects — including String — == compares references, so two strings with identical contents can be unequal. Visual Basic's = on strings compares value, so a mechanically translated comparison changes meaning without any warning. Always use .equals(), and Objects.equals(a, b) when either side may be null. Java's == is Visual Basic's Is; Visual Basic's = is Java's .equals.

There is no \: 17 / 5 between two ints truncates to 3, so a Visual Basic / copied straight across silently starts truncating. Make an operand a double to get the fractional answer. Mod becomes %, taking the sign of the left operand as Visual Basic does. There is no exponent operator: ^ is bitwise exclusive-or, so 7 ^ 2 quietly evaluates to 5 — use Math.pow.

If(condition, a, b) becomes condition ? a : b. If(value, fallback) has no operator equivalent — Java has no ?? and no ?.. The nearest things are Objects.requireNonNullElse, an explicit ternary, or Optional.ofNullable(x).orElse(y). This is why null-heavy Java code is noticeably wordier than the equivalent C#, and why Optional is preferred at API boundaries.

Trim→trim, ToUpper→toUpperCase, Contains→contains, Replace→replace — all camelCase. Two details: substring(start, end) takes an end index where .NET's Substring(start, length) takes a length, so any call with a non-zero start needs recomputing. And strip() is the Unicode-aware trim added in Java 11; trim() only removes characters below U+0020 and is kept for compatibility.

Java treats \ as an escape, so a doubled quote becomes \" and a Windows path needs every backslash doubled. There is no @"...". What Java does have is the text block, """, which spans lines and strips the common indentation relative to the closing delimiter — the same idea as C#'s raw string literal, and the right home for JSON or SQL. Text blocks still process escapes.

Both languages have immutable strings, so both have a builder. StringBuilder keeps its name; Append becomes append. String.Join(separator, items) becomes String.join(separator, items) with the arguments in the same order, unlike Python and Ruby where the separator does the joining. Note that new is required to construct anything — Java has no As New shorthand.

List(Of String) becomes List<String> — angle brackets rather than (Of ...). The convention is to declare the interface and construct the implementation: List<String> x = new ArrayList<>(), where the empty <> infers the type argument. Count→size(), fruits(0)→fruits.get(0) — there is no indexer syntax for anything but arrays. Careful with remove: on a List<Integer>, remove(2) removes the item at index 2, while remove(Integer.valueOf(2)) removes the value 2.

Dictionary(Of K, V) becomes Map<K, V>. ages("Alan") = 41 becomes put, reading becomes get, ContainsKey becomes containsKey, and TryGetValue becomes getOrDefault — no output parameter. The implementation matters: HashMap has no defined iteration order, while LinkedHashMap preserves insertion order and TreeMap sorts by key. A .NET Dictionary happens to preserve insertion order in practice, so code that relied on that needs LinkedHashMap here.

Dim scores(4) declares indices 0 through 4 — five slots, because the number is the upper bound — while new int[5] names the count. They happen to agree here; they will not when the number is not one less. UBound becomes length - 1, and note length is a field on an array but a method on a String. Printing an array gives you a useless identity hash, so Arrays.toString is what you actually want.

The arrow form — case 1 -> "one"; — has no fall-through and needs no break, so it behaves exactly like Select Case. Several values share an arm with a comma, matching Case 2, 3. Used as an expression it must produce a value on every path, and the compiler checks that. The older colon form still exists and still falls through silently; there is no reason to write it in new code.

TypeOf value Is Integer becomes value instanceof Integer number, which tests and binds in one step — and inside a switch it becomes a type pattern, case Integer number ->. when adds a guard, spelled the same way C# spells it. Record patterns go further and destructure fields directly. All of this arrived between Java 16 and 21 and is what makes modern Java read very differently from the Java of ten years ago.

The clauses are "initializer; condition; step". You state the ending condition, so the inclusive To 5 becomes <= 5 — the classic off-by-one, and worth checking every time. Step -2 becomes the step clause. The loop variable is scoped to the loop, as index As Integer is. Console.Write becomes System.out.print.

For Each word As String In words becomes for (String word : words) — the colon is read as "in". It works on anything implementing Iterable and on arrays. When you also need the position there is no enumerate and no entries(): the counted loop shown is the ordinary answer, and it is what most Java code does.

While ... End While becomes while (...) { }; the Do ... Loop family becomes do { } while (...), and since there is no Until, Loop Until attempt >= 2 flips to while (attempt < 2). Exit For becomes break, Continue For becomes continue. Java adds labels, so break outer leaves a specific enclosing loop — the one thing here Visual Basic and C# both lack.

Sub becomes void and Function ... As Integer becomes int. Everything must live inside a class — there are no free functions and no Module, so a bag of helpers becomes a class of static methods. Unlike Visual Basic's Module, whose members are callable unqualified, a static method in another class needs the class name: MathHelpers.add(2, 3).

There are no default parameter values and no named arguments. The idiom is a chain of overloads, each delegating to the fullest one — which is why Java APIs have so many methods with the same name. Skipping a middle argument is impossible; you pass the default explicitly, as the third call does. When a method has more than three or four parameters the community answer is a builder object rather than more overloads.

ParamArray values() As Integer becomes int... values — three dots after the type. It must be the last parameter, there can be only one, and the caller may pass loose arguments or a ready-made array. Inside the method it simply is an array.

There is no ByRef, no ref, no out — every argument is copied. For a primitive that means the caller sees nothing. For an object the reference is copied, so reassigning the parameter changes nothing but calling a mutating method changes the caller's object. The idiomatic answer is to return a new value; when a method genuinely must produce two things, return a record or an array rather than reaching for a wrapper class.

Public Sub New becomes a method named after the class with no return type. ReadOnly becomes final. Me becomes this, needed here to distinguish the field from the parameter of the same name — a very common Java idiom. Access modifiers are the same words in lower case, and a member with none is package-private, a visibility level .NET has no exact equivalent for (Friend is per-assembly, this is per-package).

Java has no property syntax. The convention is a pair of methods named getX and setX — the JavaBeans convention, which every framework and IDE assumes. So reading.Celsius = 100 becomes reading.setCelsius(100), and there is no way to make a field access run code later without changing every caller. That is why Java codebases wrap fields in getters from the start, where C# and Visual Basic can promote a field to a property invisibly.

A record declares the fields, the constructor, equals, hashCode and a readable toString. Records are immutable, and the accessors are named after the components — price.amount(), not getAmount(), which is the one place Java breaks its own getter convention. There is no with expression as C# records have, so a modified copy means constructing a new one by hand. Records also work as patterns in a switch, which is where they earn most of their keep.

Implements IGreeter becomes implements Greeter on the class, and the method must have the same name as the interface member; Visual Basic's per-member Implements IGreeter.Greet, which lets you rename, has no counterpart. @Override is optional but always worth writing — it makes a misspelling a compile error. The addition is the default method, which carries a real body, so an interface can supply shared behaviour the way a Ruby mixin does. Interface names take no I prefix.

Inherits becomes extends, MustInherit and MustOverride both become abstract, NotInheritable becomes final, and MyBase becomes super. The missing one is Overridable: every non-final method is overridable in Java, which is the opposite default from .NET, so sealing a method means marking it final rather than leaving a keyword off. A class may extend one class and implement any number of interfaces.

Function(value) value * 2 becomes value -> value * 2. But there is no single Func/Action pair: Java uses functional interfaces, and which one you need depends on the shape — Function<T,R> (called with apply), Consumer<T> (accept), Supplier<T> (get), Predicate<T> (test), BiFunction, and primitive-specialised versions such as IntFunction to avoid boxing. A method reference, String::toUpperCase, is Java's AddressOf.

Where→filter, Select→map, Any→anyMatch, All→allMatch, First→findFirst, OrderBy→sorted, Aggregate→reduce, GroupBy→Collectors.groupingBy. Two differences: you must open the chain with .stream() and close it with a collect (or toList() in Java 16+), and a stream is single-use — iterating one twice throws. Sum needs mapToInt because Stream<Integer> has no sum; the primitive streams do.

Catch name As TypeName becomes catch (TypeName name). Finally becomes finally. Order still matters, most specific first. error_.Message becomes error.getMessage(), since Java has no properties. Java also allows catch (A | B error) to handle two types in one block, which .NET has no equivalent for. There is no exception filter — no When — so a conditional catch becomes an if and a rethrow.

Java divides exceptions in two. A checked exception must be declared with throws and every caller must either catch it or declare it too — the compiler refuses otherwise. An unchecked one (anything extending RuntimeException) behaves like every .NET exception: invisible in the signature, catchable or not as you please. Checked exceptions are why so much Java code has throws IOException travelling up through it, and why some codebases wrap everything in unchecked exceptions on principle.

Using ... End Using becomes try (resource) { ... }, and it closes the resource whether the block ends normally or by exception. Java's AutoCloseable is IDisposable, and close() is Dispose(). Several resources go in one clause separated by semicolons, closed in reverse order. Note that close() may itself be declared to throw, which is why the method carries throws Exception.

Visual Basic's = on strings compares value. Java's == compares identity. Compile-time constants are interned, so typed == built is true and the bug hides — until a string arrives from a file, a database or user input, when it becomes false. Always equals, and Objects.equals(a, b) when either might be null. This is the same trap C# would set except that C# overloads == for String to compare value; Java does not.

Java caches boxed Integer objects for values from −128 to 127, so == on two boxed 100s is true and on two boxed 1000s is false. Code tested with small numbers passes and then fails in production. The rule is the same as for strings — use equals, or better, keep the values as primitive int where you can. Autoboxing is also where an unexpected NullPointerException comes from: unboxing a null Integer into an int throws.

Java implements generics by erasure: List<Integer> and List<String> are the same class at runtime and the type argument is gone. So you cannot ask what a list holds, cannot write instanceof List<Integer>, cannot create new T[], and cannot overload two methods that differ only in type argument. .NET reifies generics, so all of those work there. The practical consequence is that a Java API needing the type at runtime asks you to pass a Class<T> alongside it.

There is no Decimal primitive. BigDecimal is exact and is the right type for money, with three costs: it must be built from a string (new BigDecimal(0.1) has already lost the value), it has no operators so + becomes .add() and * becomes .multiply(), and equals compares scale as well as value — so 0.10 does not equal 0.1 and you must use compareTo(...) == 0. Every one of those catches people once.

Nothing carries over by name. My.Computer.Name becomes InetAddress.getLocalHost().getHostName(), My.Computer.FileSystem becomes java.nio.file.Files and Path, IsNumeric becomes a regular expression or a try around parseInt, Now becomes LocalDate.now() or Instant.now(). NuGet becomes Maven or Gradle, the .vbproj becomes a pom.xml or build.gradle, and MsgBox and the WinForms designer have no equivalent — a desktop Java application means Swing or JavaFX, and most Java work is server-side.