Java.CodeCompared.To/Ruby

Ruby programs need no class wrapper, no main method, and no access modifiers. puts prints a value followed by a newline — the exact equivalent of System.out.println. Ruby scripts run top-to-bottom, with any code at the top level executed immediately.

puts appends a newline after each argument; print does not. Ruby also has p, which calls inspect on its argument — useful for debugging because it shows the type: p "hi" prints "hi" (with quotes), while puts "hi" prints hi.

p calls .inspect on each argument, which shows the type and full structure. p "hello" prints "hello" (with quotes); p [1, 2, 3] prints [1, 2, 3]; p nil prints nil. Unlike Java where debug printing requires manual type extraction, p works correctly for any object.

Ruby uses # for single-line comments — shorter than Java's //. The =begin / =end block comment exists but is rarely used in practice; most Ruby code uses consecutive # lines for multi-line comments. The =begin must start at the very beginning of the line.

Ruby variables are created on first assignment — no type annotation, no var. The interpreter determines the type at runtime. There is no boolean type; the classes are TrueClass and FalseClass, and the values are the singleton objects true and false.

Ruby's nil is an actual object of class NilClass. Unlike Java's null, nil responds to methods: nil.to_s returns "", nil.to_a returns [], and nil.to_i returns 0. Calling an undefined method on nil raises NoMethodError, not a NullPointerException.

In Ruby, any variable can hold any value at any time — there is no static type constraint, even with var. The .class method returns the actual runtime type. This is fundamentally different from Java's type system, where even var locks the inferred type at declaration.

Ruby constants start with an uppercase letter; SCREAMING_SNAKE_CASE is the convention. Unlike Java's final, Ruby constants are not truly immutable — reassigning one produces a warning but not an error. For enforced immutability, call .freeze: MAX_RETRIES = 3.freeze.

is_a? (or its alias kind_of?) tests whether an object's class matches or inherits from the given class — equivalent to Java's instanceof. .class returns the exact runtime class. Ruby also has respond_to?(:method_name) for duck-typing checks, which is often more idiomatic than checking the class.

Ruby uses #{expression} inside double-quoted strings for interpolation — equivalent to Java's string concatenation or the Java 21 String Templates preview feature. Any expression works inside #{}, including method calls and arithmetic. Single-quoted strings do not interpolate: '#{name}' prints literally #{name}.

Ruby has two common string delimiters: double quotes process escape sequences (\n, \t) and interpolation (#{}); single quotes treat everything literally except \\ and \'. Use single quotes when the string needs neither — it signals intent to readers and avoids accidental interpolation.

Ruby's <<~HEREDOC (squiggly heredoc, available since Ruby 2.3) strips leading whitespace, matching Java's text block behavior. The terminator identifier is arbitrary. chomp removes the trailing newline. Unlike Java text blocks, Ruby heredocs support interpolation by default — use <<~'HEREDOC' (single-quoted terminator) to disable interpolation.

Ruby string method names differ from Java's: strip is the same, but length (or size) replaces length(), upcase/downcase replace toUpperCase()/toLowerCase(), and gsub (global substitute) replaces replace. Methods chain naturally because Ruby strings are objects with a rich API.

Ruby uses the % operator for printf-style formatting — a more concise syntax than Java's String.format. The format specifiers are the same as C's printf. Ruby also has sprintf and format as method aliases for the same operation. For most cases, string interpolation (#{}) is preferred over format strings.

In Ruby 4.0, all string literals are frozen by default, matching Java's long-standing String immutability. Attempting to mutate a frozen string (e.g. base << " world") raises FrozenError. Use dup or +"" to get a mutable copy when mutation is required. The +@ unary operator also returns a mutable version: +base.

Ruby symbols are immutable, interned identifiers written with a colon prefix (:name). Unlike strings, every occurrence of the same symbol literal is the same object — :active.object_id == :active.object_id is always true. The closest Java analog is String.intern(), but symbols are a distinct type used for identifiers: hash keys, method names, and configuration options.

to_s converts a symbol to a string; to_sym converts a string to a symbol. Symbols respond to fewer methods than strings — they lack mutation methods since symbols are immutable. When you need to manipulate the text (split, substitute, format), convert to a string first.

The { key: value } syntax is Ruby's shorthand for symbol keys — { name: "Alice" } is equivalent to { :name => "Alice" }. Accessing hash values uses bracket notation with the symbol: person[:name]. String keys and symbol keys are distinct: { "name" => "Alice" }[:name] returns nil.

Ruby has a single Integer class that automatically handles arbitrarily large integers — no int/long/BigInteger split. Underscores in numeric literals are for readability (like Java's 100_000) and are ignored by the interpreter. Ruby integers are full objects: 42.class, 42.even?, 42.times { } all work.

Ruby integers have iteration methods built in: times counts from 0 to n–1, upto counts up to a limit (inclusive), and downto counts down. These replace Java's for (int i = 0; i < n; i++) loops for simple counting. The block argument receives the current value.

Ruby integer division truncates toward negative infinity (like Java). A float operand makes the result a float: 10 / 3 → 3, 10.0 / 3 → 3.3333.... The round, ceil, and floor methods are built into Float and Integer, so no Math class is needed for basic numeric operations.

Ruby integers have predicate methods like even?, odd?, positive?, negative?, and zero? — replacing Java's arithmetic comparisons. The ** operator handles exponentiation (Java's Math.pow). Methods ending in ? conventionally return true or false.

Ruby arrays are created with bracket literals — no new ArrayList(), no generic type parameter, no imports. Arrays are dynamic and heterogeneous by default: [1, "two", :three, nil] is valid. The %w[apple banana cherry] shorthand creates an array of strings without quotation marks.

Ruby arrays support negative indices: colors[-1] is the last element, colors[-2] the second-to-last. Slicing accepts either array[start, length] or a range: array[1..3] (inclusive). These replace subList and eliminate the common Java off-by-one error where subList(from, to) excludes the last index.

push and pop operate on the end of the array (stack); unshift and shift operate on the beginning (queue). The << operator is an alias for push: items << "d". These replace Java's verbose add()/remove(size-1)/add(0, x)/remove(0) on ArrayList.

Ruby's map (alias: collect) transforms each element; select (alias: filter) keeps elements matching the block; reject keeps elements that do NOT match. These come from the Enumerable module, available on any class that implements each. No stream() call, no collect(Collectors.toList()) — the result is always an array.

reduce (alias: inject) folds an array into a single value. The first argument is the initial accumulator; the block receives the accumulator and each element in turn. Ruby's shorthand inject(:+) uses the method name as a symbol — equivalent to stream().reduce(Integer::sum) in Java.

sort returns a new sorted array; sort! sorts in place (mutating methods conventionally end in !). uniq removes duplicates (like Java's distinct()). flatten recursively expands nested arrays — Java has no direct equivalent. compact removes nil values — like Java's stream filter for null.

Ruby hashes are created with curly-brace literals. The { key: value } syntax uses symbol keys (the most common style); { "key" => value } uses string keys or any other object as a key. Hashes maintain insertion order (since Ruby 1.9), equivalent to Java's LinkedHashMap. No imports, no type parameters.

Hash values are set with bracket assignment: hash[:key] = value. Accessing a missing key returns nil (not an exception). fetch is the strict version: fetch(:key) raises KeyError if the key is absent; fetch(:key, default) returns the default instead. Use fetch when absence means a bug.

each on a hash yields two-element arrays that Ruby automatically destructures: |key, value|. keys and values return plain arrays. Hashes also support the full Enumerable API — map, select, reject, any?, all? — with no need for entrySet().stream().

Hash.new(default) sets the value returned for any missing key. word_count["missing"] returns 0 instead of nil, making += 1 safe on first access. For a computed default (e.g. an empty array per key), use a block: Hash.new { |hash, key| hash[key] = [] }.

transform_values returns a new hash with the same keys and transformed values — equivalent to Java's verbose Collectors.toMap identity-on-keys pattern. transform_keys does the same for keys. Both replace the entrySet().stream().collect(...) boilerplate. merge combines two hashes: defaults.merge(overrides).

1..10 is an inclusive range (includes 10); 0...5 is exclusive (excludes 5). Ranges are first-class objects — call include?, min, max, each, and to_a on them directly. Java has no range literal; the closest is IntStream.rangeClosed, which requires boxing and lacks the concise expression form.

Ranges support each and the full Enumerable suite: map, select, reduce, first, etc. String ranges iterate over characters using Ruby's lexicographic successor. Ranges of dates and custom objects (any type with succ defined) can also be iterated. This is more expressive than Java's for loop, which works only with numbers.

Ranges work naturally in Ruby's case/when expressions — each when calls === on the range, which checks membership. This replaces Java's cascading if/else if for numeric range checks and is far cleaner than Java's switch, which cannot match ranges. case in Ruby is an expression and returns the matched value.

Ruby's keyword is elsif (no second "e"), not else if or elif. No parentheses are required around the condition, and no curly braces around the body — end closes the block. if in Ruby is an expression and returns the value of the matched branch, so you can write label = if condition then "yes" else "no" end.

unless is the negated form of if — it executes its body when the condition is falsy. It is equivalent to if !condition but reads more naturally in English for negative guards. Avoid using unless with an else clause (it becomes hard to follow) and avoid unless with a complex negated condition.

Ruby's case/when has no fallthrough — each when is independent. Multiple values in a single when are comma-separated. when uses === (case equality) for matching, which means it works with classes (when String), ranges (when 1..10), and regular expressions (when /pattern/), not just literal values.

Ruby has the same ternary operator as Java: condition ? value_if_true : value_if_false. Postfix if and unless are idiomatic for single-line guards: expression if condition. The postfix form reads naturally — "do this if that" — and is preferred over a full if ... end block for simple guards.

while loops run while the condition is true; until loops run while it is false (while !condition). Ruby has no do...while — use loop do ... break if condition end for a guaranteed first execution. In practice, Ruby code rarely uses while: each, times, and upto cover most iteration.

loop do ... end is Ruby's infinite loop — equivalent to while (true). break exits the loop; next skips to the next iteration (Java's continue). Both work inside blocks as well: next inside each skips to the next element, and break stops the entire iteration.

Ruby methods return the value of their last expression — no return keyword is needed (though it can be used for early return). There is no return type declaration. Methods defined at the top level become private methods of Object. The method body is indented with two spaces; end closes it.

Ruby supports default parameter values directly in the method signature — no overloading is required. Java requires separate overloaded methods to simulate defaults. Default values are evaluated at call time (not definition time), so def timestamp(value = Time.now) gives a fresh timestamp each call.

Ruby keyword arguments are declared with a colon after the name: name:. At the call site the argument names are visible: create_user(name: "Alice", age: 30). Keyword arguments with defaults are optional; those without are required. Java has no direct equivalent — the self-documenting call site is a significant readability advantage.

*args collects positional arguments into an array — like Java's varargs. **kwargs collects keyword arguments into a hash — Java has no direct equivalent. The splat can also expand at the call site: print_all(*words_array) spreads an array into positional arguments.

Ruby 3.0 introduced endless (one-liner) method syntax: def name(params) = expression. It is equivalent to a normal method with an implicit return but reads like a mathematical definition. Use it for simple, single-expression methods where the body is obvious. For multi-line logic, use the traditional def ... end form.

A Ruby block is an anonymous chunk of code passed to a method. The do |params| ... end form is used for multi-line blocks; the { |params| ... } form is used for single-line blocks. Blocks are similar to Java's lambdas but are passed implicitly — they are not a parameter in the method signature, yet the method can call them with yield.

Each chained method returns a new array; the next block operates on that result. The convention is: use { } for one-liners that fit on a single line, and do ... end for multi-line blocks. Method chaining in Ruby requires no stream() call — arrays respond to Enumerable methods directly.

yield invokes the block that was passed to the method. Any method can accept a block — no special parameter declaration is required. block_given? checks whether a block was provided. This is the mechanism behind all of Ruby's iterators: each, map, and select all call yield internally.

Ruby's Enumerable provides all?, any?, none?, count, find, min, max, sum, and first — all operating via a block. No stream() call, no Optional wrapper, no .get(). find returns nil on an empty collection rather than throwing.

each_with_index yields each element and its zero-based index — replacing Java's counter-for loop. each_with_object(accumulator) yields each element and a shared accumulator, useful for building results: words.each_with_object({}) { |word, hash| hash[word] = word.length }.

A Proc is a block turned into an object — it can be stored, passed, and called. proc { |x| ... } is shorthand for Proc.new { ... }. Procs are Ruby's equivalent of Java's functional interfaces (Function, Consumer, Supplier). Unlike lambdas, procs do not check argument count and treat return as returning from the enclosing method.

The ->(params) { body } syntax creates a lambda. Lambdas are stricter than Procs: they enforce argument count (raising ArgumentError on mismatch) and treat return as returning from the lambda itself, not the enclosing method. Prefer lambdas when the behavior should resemble a function with a defined contract.

method(:name) retrieves a method as an object; the & prefix converts it to a block — equivalent to Java's method reference (ClassName::methodName). Symbol-to-proc also works: words.map(&:upcase) is equivalent to words.map { |word| word.upcase }. This is the idiomatic Ruby shorthand for single-method transformations.

Ruby has two closures: Proc (loose) and lambda (strict). Key differences: lambdas enforce argument count, raising ArgumentError on mismatch; Procs ignore extra arguments and fill missing ones with nil. Also, return in a Proc returns from the enclosing method; return in a lambda returns only from the lambda. lambda? distinguishes them at runtime.

Ruby classes use initialize instead of a constructor named after the class. Instance variables start with @. BankAccount.new allocates the object and calls initialize. to_s is Ruby's toString(); defining it makes puts account print nicely. There is no new keyword as a language construct — new is just a class method.

attr_accessor generates both a getter and a setter for an instance variable. attr_reader generates only a getter (read-only); attr_writer only a setter. This replaces Java's boilerplate getter/setter methods. Setters use the name= naming convention — person.name = "Alicia" calls the name= method.

Class methods are defined with self.method_name — the equivalent of Java's static methods. Class variables start with @@ and are shared across all instances (like Java's static fields). In practice, Ruby often uses class-level instance variables (@count on the class object itself) instead of @@ to avoid inheritance edge cases.

Ruby uses < for inheritance: class Dog < Animal. super calls the parent's method of the same name, passing through all arguments by default. Ruby supports only single inheritance (no multiple base classes), but modules fill the role of Java's interfaces. There is no @Override annotation — overriding methods are simply redefined.

Ruby classes are always "open" — you can add methods to any class at any time, including built-in classes like String, Integer, and Array. This is called monkey patching and enables natural extension of the standard library. Java's closed class model prevents this. Used with care, open classes make code read naturally; used carelessly, they can introduce surprising behavior.

In Ruby, public, protected, and private are keywords that act as mode switches — all method definitions that follow become that visibility. Unlike Java's per-method modifiers, they set a section for the rest of the class body. private methods cannot be called with an explicit receiver — even self.format_age inside the class raises NoMethodError.

Ruby modules serve as namespaces — grouping related classes and constants under a name, equivalent to Java's packages. The :: operator accesses constants and classes inside a module. Unlike Java's package system, Ruby modules can be reopened and extended at any time. Modules also serve a second role as mixins (see next example).

include ModuleName mixes in all the module's methods as instance methods — equivalent to Java's interface with default methods, but more powerful because the module can access the including class's state via the class's own methods. Ruby supports including multiple modules (no limit), while Java classes can extend only one class. extend mixes module methods in as class methods.

Including Comparable and defining <=> (the spaceship operator) grants <, <=, >, >=, between?, and clamp for free — equivalent to implementing Comparable in Java. The <=> operator returns -1, 0, or 1, matching Java's compareTo contract.

Including Enumerable and defining each grants the full suite: map, select, reject, reduce, min, max, sort, find, group_by, count, first, to_a, and more — over 50 methods for free. Java's Iterable gives only the raw iterator; Streams must be called explicitly for higher-order methods.

begin/rescue/ensure map directly to Java's try/catch/finally. rescue catches the exception and binds it with => error. ensure always runs, even if no exception is raised. Unlike Java, all Ruby exceptions are unchecked — you never declare which exceptions a method raises.

raise is Ruby's equivalent of throw. The most common form is raise ExceptionClass, "message". Bare raise inside a rescue re-raises the current exception. Ruby's ArgumentError is the closest equivalent to Java's IllegalArgumentException. There are no checked exceptions — no method signature declarations for raised exceptions.

Custom Ruby exceptions inherit from StandardError (not Exception). Inheriting from StandardError is the convention — bare rescue catches StandardError and its descendants. Custom fields are added as instance variables with attr_reader, replacing Java's verbose field + getter pattern. There is no RuntimeException distinction — all Ruby exceptions are unchecked.

Multiple rescue clauses catch different exception types, matched in order from top to bottom. Bare rescue => error (with no class specified) catches StandardError and all its descendants — the catch-all. A single rescue can handle multiple types: rescue ArgumentError, TypeError => error.

retry inside a rescue clause re-runs the entire begin block from the top. This is the idiomatic pattern for transient-failure retries (network calls, rate limits, database timeouts). Java requires a manual loop with a counter; Ruby's retry is declarative and cleaner. Always include a retry limit to prevent infinite loops — bare raise re-raises the original exception after the limit.

Ruby's case/in (pattern matching, stable since Ruby 3.0) matches arrays by structure. [Integer => x, Integer => y] checks that both elements are integers and binds them to x and y. _ is a wildcard that matches any value without binding. This is more expressive than Java's switch patterns, which match on types but not on structural position.

Hash patterns match by key presence and value: { role: "admin" } succeeds if the hash has a :role key with value "admin". Extra keys are ignored. String => name checks the type and binds the value. Hash patterns are ideal for processing API responses and configuration objects.

Guards are if conditions appended to a pattern: in Integer => number if number > 0. The pattern must match AND the guard must be true for the branch to execute. This is equivalent to Java 21's guarded patterns (case Integer number when number > 0). Guards can use any Ruby expression, including method calls on the bound variables.

Define deconstruct (for array patterns) and deconstruct_keys (for hash patterns) to make custom classes work with case/in. This is similar to Java's automatic record deconstruction, but extensible to any class. Java records generate deconstruction for free; Ruby requires explicit methods, but the approach works on any class including existing library classes.