Java.CodeCompared.To/Go

Go's fmt.Println() replaces Java's System.out.println(). A Go program needs only a package main declaration and a func main() — no class wrapping, no public modifier, no boilerplate.

Go's fmt.Printf() uses the same %s, %d, %f format verbs as Java's String.format() and printf(). The %v verb prints any value with its default format — useful when you don't know or care about the exact type.

fmt.Sprintf() is the Go equivalent of Java's String.format() — it returns a formatted string without printing it. The fmt package consistently uses the Print, Println, and Printf naming pattern for both console output and string building.

Go's %T verb prints the type, and %#v prints a Go-syntax representation — more useful than Java's getClass(). Note that Go prints slices without commas: [1 2 3] not [1, 2, 3].

Go's := declares and assigns in one step — the compiler infers the type. := can only be used inside functions; package-level variables must use the var keyword. Unlike Java's var, := can declare multiple variables at once: x, y := 1, 2.

Go has no null for value types. Every variable has a zero value — 0 for numbers, "" for strings, false for booleans. This eliminates an entire class of NullPointerExceptions. Pointers, slices, maps, and interfaces have a zero value of nil.

Go constants are declared with const at the package level or inside functions. Exported names start with an uppercase letter — Go's visibility mechanism replaces Java's public/private. There is no static final — Go has no static class members at all.

Go supports simultaneous assignment: the right side is fully evaluated before any assignment occurs. This makes swapping trivial and is how multiple return values are unpacked. Java requires a temporary variable for swaps.

Go has no implicit numeric conversions — float64(x) and int(x) are function-call syntax, not cast syntax. There is no widening: adding an int and a float64 is a compile error. strconv.Itoa and strconv.Atoi replace Java's Integer.toString() and Integer.parseInt().

Go strings are immutable UTF-8 byte sequences. Concatenation with + works the same as Java, but len() returns the number of bytes, not characters — use utf8.RuneCountInString() for character (rune) count. Use strings.Builder for repeated concatenation in a loop.

Go string operations live in the strings package as standalone functions rather than methods on a string type. strings.TrimSpace() replaces strip()/trim(). The -1 in strings.Replace() means "replace all occurrences" — use strings.ReplaceAll() for the same effect.

strings.Split() and strings.Join() replace Java's String.split() and String.join(). Note that Java's split() takes a regex pattern while Go's takes a literal string — use strings.FieldsFunc() for regex-based splitting.

Go's strings.Builder replaces Java's StringBuilder for efficient string construction in loops. fmt.Fprintf() writes formatted output directly into any io.Writer, including a strings.Builder. Use .WriteString() for plain string appends.

Go has int8, int16, int32, int64 (and unsigned uint variants). Bare int is platform-native width (64-bit on 64-bit systems). Unlike Java, Go has no Integer/Long wrapper types — all numeric types are value types.

Integer division behavior is identical: dividing two integers truncates. Go has no Math.pow() method — use math.Pow() (which returns float64). For integer exponentiation, use a loop or the standard library math/big package.

Go slices are dynamically sized like Java's ArrayList. append() always returns the (possibly new) slice — you must assign the result back. The []int{1, 2, 3} literal creates a pre-populated slice. len() replaces .size().

Go slices use bracket index notation like arrays. There is no negative indexing — use fruits[len(fruits)-1] for the last element. Index-out-of-bounds causes a runtime panic, not an IndexOutOfBoundsException.

Go slicing syntax (numbers[1:4]) uses exclusive end, same as Java's subList(1, 4). sort.Ints() sorts in-place (like Collections.sort()). Go's slice expression creates a view into the original — modifying it modifies the underlying array, unlike Java's subList().

range over a slice yields both index and value — use _ to discard the index if you only need values. This replaces both Java's enhanced for loop (value only) and the indexed for loop (index + value). range works on slices, arrays, maps, strings, and channels.

Accessing a missing key in a Go map returns the zero value for the value type — no exception, no null. To distinguish "key present with value 0" from "key missing", use the two-value form: value, ok := scores["Carol"]. ok is false if the key was absent.

The two-value map lookup value, ok := map[key] is idiomatic Go for existence checking — it replaces Java's containsKey(). delete(map, key) removes a key; deleting a non-existent key is a no-op. Maps are not safe for concurrent access — use sync.Map or a mutex for goroutine-shared maps.

range on a map yields key-value pairs — much cleaner than Java's entrySet() iteration. Map iteration order in Go is deliberately randomized on each run to prevent code from accidentally relying on it. Use sort.Strings(keys) to iterate in sorted key order.

Go's if does not require parentheses around the condition — they are illegal by convention. Curly braces are always required. The opening brace must be on the same line as the if; Go's formatter (gofmt) enforces this.

Go's if supports an optional initialization statement before the condition: if init; condition { }. Variables declared in the init statement are scoped to the entire if/else block. This pattern is ubiquitous for map lookups and error checks.

Go's switch does not fall through by default — no break required. Multiple values in one case are separated by commas. Use fallthrough to opt in to the Java-style behavior. Go's switch also works without an expression: switch { case x > 0: ... } acts like a cleaner if-else chain.

defer schedules a function call to run when the surrounding function returns — after any return statement, including panics. It is the idiomatic way to close files, release mutexes, and clean up resources. Multiple deferred calls execute in LIFO order. Java's try-with-resources is similar but tied to the block, not the function.

Go has exactly one loop keyword: for. It handles the Java for, while, and do-while cases through different forms. The classic three-part form is identical to Java's for — just without parentheses.

A for with only a condition is Go's while. A bare for { } (no condition) is an infinite loop — equivalent to while (true). Go has no do-while; use for { ... if cond { break } } instead.

range replaces both Java's enhanced for loop and index-based loops in one construct. It works uniformly on slices, arrays, maps, strings, and channels. Use _ to ignore either the index or the value: for _, fruit := range fruits.

Go supports labeled break and continue for breaking out of nested loops — the same as Java's labeled statements. Labels are placed before the outer loop and referenced in the break/continue statement.

Go functions are declared with func, parameters listed as name type, and the return type after the parameter list. No static keyword — all package-level functions are analogous to Java statics. Capitalized names are exported (public); lowercase names are package-private.

Go functions can return multiple values natively — no wrapper record, pair, or array needed. This is the primary mechanism for returning both a result and an error. Java requires a record or similar container; Go just lists the return types in parentheses.

Go variadic functions use ...Type syntax, the same as Java's Type... (just reversed). To spread a slice into a variadic call, use slice... — unlike Java, where an array is passed directly without spreading.

Go functions are first-class values — they can be assigned to variables and passed as arguments. The type of a function value is written func(ParamTypes) ReturnType. This replaces Java's Function<T, R>, Predicate<T>, and other functional interfaces.

Go struct is the primary data type for grouping values — there are no classes. Go structs can be initialized with field names (Point{X: 0.0, Y: 0.0}) or positionally (Point{0.0, 0.0}). Field names starting with uppercase are exported; lowercase fields are package-private.

Methods in Go are defined separately from the struct, with a receiver parameter: func (c Circle) Area(). The receiver plays the role of Java's this. Methods can be defined on any named type in the same package, not just structs.

A pointer receiver (*Counter) allows the method to modify the struct — equivalent to Java's mutable instance methods. A value receiver (Counter) receives a copy and cannot modify the original. Use pointer receivers consistently for all methods on a type if any method needs to mutate.

Go interfaces are satisfied implicitly — a type implements an interface simply by having the required methods, with no implements declaration. This is structural (duck) typing enforced at compile time. Any existing type from any package can satisfy your interface, without modifying it.

The fmt.Stringer interface has one method: String() string. Any type implementing it controls how it prints via fmt.Println(), %v, and %s — exactly like Java's toString(). You satisfy it just by defining the method.

any (an alias for interface{}) is Go's equivalent of Java's Object — it accepts any type. Use type assertions (value.(string)) or type switches (switch v := value.(type)) to recover the concrete type, similar to Java's casts and instanceof.

Go returns errors as the last return value — there are no checked exceptions, no unchecked exceptions, no throws clause. Callers must explicitly handle or ignore errors. The convention is if err != nil { handle } immediately after every call that can fail.

fmt.Errorf("...: %w", err) wraps an error with context, like Java's exception chaining (new Exception(msg, cause)). errors.Is() checks if any error in the chain matches a target (like Java's getCause() traversal). errors.As() extracts a specific error type from the chain.

panic is for programming errors and unrecoverable states — like Java's RuntimeException, not checked exceptions. recover() inside a defer catches a panic and converts it to an error, analogous to catching an unchecked exception. For expected failure conditions, always use the (value, error) return pattern instead.

A goroutine is launched with the go keyword before any function call. Goroutines are multiplexed onto OS threads by the Go scheduler — you can run millions simultaneously with ~2 KB initial stack each. Java threads are 1:1 OS threads (~1 MB stack). sync.WaitGroup replaces Thread.join().

Channels are typed conduits for communicating between goroutines. The Go philosophy: "Don't communicate by sharing memory; share memory by communicating." This replaces Java's BlockingQueue, ConcurrentLinkedQueue, and other concurrent data structures with a language-level primitive.

Go has exactly two visibility levels: exported (starts with uppercase) and unexported (starts with lowercase). There is no protected, no private within a struct, and no package hierarchy — a package is either all-accessible or not. This applies to types, functions, constants, variables, and struct fields.

Go modules use the full repository URL as the import path (github.com/user/repo). Dependencies are declared in go.mod and pinned in go.sum. The toolchain (go get, go build, go test) is built in — no Maven, Gradle, or separate build tool needed.