Java.CodeCompared.To/Clojure

Clojure uses prefix notation: the function name comes first inside parentheses, followed by its arguments. println prints to stdout with a trailing newline — equivalent to System.out.println. There is no class wrapper, no main method, and no semicolons.

Clojure's println appends a newline; print does not. Both accept any value and convert it to a string automatically — there is no need to call String.valueOf() or concatenate with "". pr and prn print in a machine-readable form where strings include their quotes.

Clojure's format uses Java's printf-style format strings and returns a string — equivalent to String.format. Use (println (format ...)) to print the result. The format specifiers (%s, %d, %.2f) are identical to Java's.

Clojure uses semicolons for comments. By convention, ;; opens standalone comments on their own line, while ; follows code inline. The #_ reader macro comments out the next form entirely — any value, including a nested expression — without the reader processing it at all. There are no block comments equivalent to Java's /* ... */.

def creates a named var in the current namespace — similar to a static field. Clojure uses kebab-case by convention rather than Java's camelCase or SCREAMING_SNAKE_CASE. There is one naming convention for all definitions — no separate convention for constants vs variables.

let introduces immutable local bindings scoped to its body. The binding vector evaluates in order, so area can reference radius defined earlier in the same let. Unlike Java's block-scoped variables, let bindings cannot be reassigned — there is no equivalent of area = newValue inside the body.

conj (short for "conjoin") does not modify numbers — it returns a new vector with the element added. Clojure's persistent data structures use structural sharing, so creating a "modified" copy is efficient even for large collections. This is the central shift from Java: operations on collections always return new values rather than mutating the original.

In Clojure, every form is an expression that returns a value — if, let, cond, and defn bodies all return their last evaluated sub-expression. There are no statements that have no value. This is why if directly replaces Java's ternary operator ? : as well as regular if/else blocks.

Clojure uses kebab-case for all names — variables, functions, namespaces, and constants alike. There is no SCREAMING_SNAKE_CASE for constants and no camelCase. Predicates (functions returning a boolean) end with ? (e.g., empty?, even?). Functions with side effects or that mutate state end with ! (e.g., swap!, reset!).

Clojure uses named functions for integer division (quot) and modulo (mod). The / operator always returns the most precise result — exact rationals on the JVM, floats in ClojureScript. Math/pow delegates to JavaScript's Math.pow in Scittle, or to java.lang.Math on the JVM.

Keywords are one of Clojure's most distinctive types — they have no direct Java equivalent. A keyword like :active is a self-evaluating symbol that is always equal to itself. Unlike strings, keyword equality uses identity comparison, which makes them very fast as map keys. They are the idiomatic choice for map keys, replacing what Java would express with String constants or enum values.

Clojure's nil is equivalent to Java's null — it represents the absence of a value. Unlike Java, calling most Clojure functions on nil does not throw a NullPointerException: (count nil) returns 0, (get nil :key) returns nil. The type predicate functions nil?, boolean?, and integer? replace instanceof.

Clojure's truthiness rules are simpler than most languages: only nil and false are falsy; everything else is truthy. This differs from C, Python, and JavaScript where 0 and empty collections are falsy. Java is stricter — it requires actual boolean values in if conditions, so the distinction does not arise the same way.

Clojure provides predicate functions for type checking: string?, number?, integer?, vector?, map?, seq?, fn?, keyword?, and many more. These replace instanceof for the common cases. The dynamic type system means there are no type declarations — types are checked at runtime when needed.

str concatenates any number of arguments, converting non-strings automatically — a single function replaces Java's + operator for strings. Clojure has no string interpolation syntax; use str for simple concatenation or format for formatted output: (format "Player: %s, score: %d" first-name score).

count returns the length of strings and all collections. subs extracts a substring by start and optional end index. get retrieves a character by index. Unlike Java's method-on-object style, these are all free functions — composable with map, threading macros, and higher-order functions.

The clojure.string namespace provides string searching functions as free functions rather than methods. The names follow the predicate convention (includes?, starts-with?) and the functions are composable with threading macros. clojure.string is built into Scittle and does not need an explicit require.

The clojure.string functions are all pure — they return new strings without modifying the original. trim, triml (left), and trimr (right) correspond to Java's trim, stripLeading, and stripTrailing. The replace function accepts strings or regex patterns.

clojure.string/split takes a regex pattern written as #"pattern" and returns a vector of strings. clojure.string/join takes a separator and any sequence. These return Clojure's persistent vectors rather than Java arrays — they work naturally with map, filter, and other sequence operations.

Clojure vectors ([...]) are the most common collection type — ordered, indexed, and persistent. conj returns a new vector with the element appended; the original is unchanged. Vectors are also functions of their index: (numbers 2) retrieves the element at index 2. Use (count v) instead of .size().

Clojure maps use {} with key-value pairs separated by spaces or commas. Keywords are the idiomatic key type, and keywords are also functions that look themselves up in a map: (:name person) is equivalent to (get person :name). assoc returns a new map with the key set; dissoc returns a new map with the key removed.

Clojure sets (#{...}) are unordered collections of unique values. contains? tests for membership. Sets are also functions of their elements: (primes 5) returns 5 if present or nil if absent — useful for filtering. conj returns a new set; the original is unmodified. Duplicate literals in a set literal are a compile error.

Clojure's nested data structures are built from the same persistent maps, vectors, and sets. get-in navigates a nested structure with a path vector, eliminating the cascading casts required in Java. assoc-in and update-in return new structures with one nested value changed. There is no need for separate DTO classes.

apply unpacks a collection as arguments to a function — (apply min numbers) is equivalent to calling (min 3 1 4 ...). empty? tests for an empty collection. some with a set tests membership in any sequence — the set acts as a predicate returning the element if found or nil if not.

Clojure lists ('(...)) are singly-linked lists — efficient at prepending with cons, but O(n) for indexed access. The quote (') prevents evaluation: without it, (2 3) would try to call 2 as a function. In practice, vectors are preferred for data; lists appear mainly in macros and when representing code as data.

defn defines a named function. The argument vector [name] replaces the Java parameter list. The function body is a sequence of expressions; the last one is implicitly returned — there is no return keyword. The function is defined in the current namespace and called using prefix notation: (greet "Alice").

Clojure handles multiple arities in a single defn using parenthesized groups, one per arity. This replaces Java's method overloading. By convention, lower-arity versions delegate to the highest-arity version with default values. Each arity body is evaluated independently; all share the same function name and namespace binding.

fn creates an anonymous function — equivalent to Java 8+ lambda expressions. The shorthand #(* % 2) is a reader macro: % is the first argument, %2 the second. Functions are first-class values in Clojure: stored in variables, passed as arguments, and returned from functions without any functional-interface wrapper.

In Clojure, any function can be passed as an argument without wrapping it in a functional interface like UnaryOperator<T>. The type system is dynamic, so apply-twice works with any unary function — numeric, string, or otherwise. Named functions like clojure.string/upper-case are values and can be passed directly.

partial returns a new function with one or more arguments pre-filled. (partial * 3) returns a function that multiplies its argument by 3. This replaces the pattern of writing a factory method that returns a lambda. partial works with any function, including built-ins like *, +, str, and conj.

Clojure's map is a free function taking a function and a sequence — not a method on a stream. It returns a lazy sequence; nothing is computed until the values are consumed. The function comes before the collection, the opposite of Java's .map(). No .collect() call is needed for most use cases.

filter takes a predicate function and a sequence, returning a lazy sequence of elements for which the predicate returns truthy. Named predicates like even?, odd?, nil?, string?, and pos? are available in core and work directly as arguments to filter.

reduce takes a function, an optional initial value, and a sequence. Arithmetic operators (+, *, max, min) are regular functions and can be passed directly — no lambda wrapper needed. Without an initial value, reduce uses the first element as the starting accumulator.

Clojure's range returns an infinite lazy sequence — elements are computed only as they are consumed. take forces the first n elements. Chaining filter, map, and take evaluates elements one at a time without building intermediate collections. This is equivalent to Java's stream pipeline but is the default behavior of all sequence operations.

Clojure's for is a list comprehension that generates a lazy sequence — not a loop. It binds each variable to each element in turn, producing the Cartesian product by default. The :when modifier filters combinations; :let adds intermediate bindings. This replaces Java's nested for-loops for collection generation.

Clojure's if is an expression that returns a value: (if condition then-expr else-expr). The else branch is optional; if omitted and the condition is falsy, if returns nil. For multiple expressions in a branch, use do: (if condition (do expr1 expr2) else-expr).

when is equivalent to if with no else branch, but it allows multiple expressions in its body without a do wrapper. All body expressions are evaluated in sequence; the result of the last is returned if the condition is truthy, or nil if falsy. Use when-not for the opposite condition.

cond tests conditions in sequence and returns the value paired with the first truthy test. The :else keyword is idiomatic for the default case (any truthy value works, but :else is self-documenting). Because cond returns a value, it can be used directly inside a let binding — no imperative assignment needed.

case dispatches on an exact value using constant-time lookup (not sequential testing like cond). Multiple values matching the same branch are grouped in a list. The final unmatched value is the default — if omitted and no case matches, an exception is thrown. case works with numbers, strings, keywords, and symbols.

dotimes executes its body a fixed number of times, binding the current index (starting at 0) to the given name. It is the direct replacement for Java's counted for loop. dotimes is used for side effects — it returns nil. For building a collection, prefer (mapv ... (range 5)) or a for comprehension.

loop establishes a recursion point with initial bindings; recur jumps back with new values. This is Clojure's primary iteration mechanism when map, filter, or reduce does not fit. recur uses tail-call optimization — it does not grow the stack, making loop/recur safe for any number of iterations.

Destructuring binds names to positions in a vector in one step, eliminating the series of .get(0), .get(1) calls needed in Java. The & captures remaining elements as a lazy sequence. Destructuring works anywhere bindings appear: in let, function parameters, for, and loop.

Map destructuring binds names to specific keys. The :keys shorthand is idiomatic when the binding name matches the keyword name. :as whole-map keeps the original map bound alongside the destructured parts. :or provides default values for missing keys: {:keys [name age] :or {age 0}}.

Destructuring in function parameters eliminates the extraction boilerplate that Java requires inside the method body. The parameter list directly names the keys of interest from the map argument. This pattern is very common for functions that take "options maps" — equivalent to Java's builder pattern or parameter objects, but without the boilerplate class.

Nested destructuring unpacks nested structures without cascading casts or repeated .get() calls. Binding user first, then destructuring it in the next binding, is readable and explicit. One or two levels of nesting is idiomatic; deeper nesting is a signal to use get-in instead.

The -> (thread-first) macro threads a value as the first argument of each successive form, left to right. It transforms deeply nested calls into a readable pipeline that mirrors Java's method-chaining style. When the function takes additional arguments, wrap the step in a list: (clojure.string/replace "WORLD" "CLOJURE").

The ->> (thread-last) macro threads a value as the last argument of each form. This matches Clojure's sequence functions, which always take the collection last. Use ->> for collection pipelines (the equivalent of Java's stream chain) and -> for method-chain-style transformations where the subject is the first argument.

comp creates a composed function that applies functions right-to-left: (comp f g) is equivalent to (fn [x] (f (g x))). This reversal is mathematically conventional but differs from Java's andThen, which applies left-to-right. Read (comp step3 step2 step1) as "apply step1, then step2, then step3."

doseq iterates over a sequence for its side effects, binding each element to the given name. It returns nil. Unlike the for comprehension (which builds a lazy sequence), doseq is the right tool when the goal is side effects — printing, writing to a database, or calling an external API.

Clojure namespaces correspond to Java packages. The ns form at the top of a file declares the namespace and all its dependencies in one place — there are no separate import statements. The :require vector lists dependencies with optional aliases (:as string) or individual names to refer into the namespace (:refer [upper-case]).

require loads a namespace and optionally creates an alias. Using :as string lets you write string/upper-case instead of clojure.string/upper-case. The idiomatic style is to put all :require declarations in the ns form at the top of the file. In-line require calls are used at the REPL.

The clojure.set namespace provides set operations as pure functions returning new persistent sets. intersection, union, and difference replace Java's mutable retainAll, addAll, and removeAll. All results are new sets; the originals are untouched.

:refer is the Clojure equivalent of Java's static import. Naming the specific functions to refer (:refer [upper-case lower-case]) is idiomatic. :refer :all (like Java's wildcard import static com.example.*) is discouraged in library code because it makes the origin of names ambiguous when reading the code.

On the JVM, Clojure calls Java instance methods using dot notation: (.methodName object args...). The object comes second, unlike Java where it comes before the dot. This provides full access to any Java library. This example does not run in the browser because Scittle (ClojureScript) does not have access to the JVM class library.

Clojure accesses Java static methods and fields using slash notation: Math/PI for a field, (Math/sqrt 16.0) for a method call. Note that Math/PI and (Math/pow x y) work in Scittle as a special case because they delegate to JavaScript's Math object, which Scittle maps to the same syntax. This example is marked norun for clarity about the general rule.

Clojure constructs Java objects using (ClassName.) — a dot at the end of the class name indicates a constructor call. The doto macro calls multiple methods on a single object and returns the object, replacing the Java pattern of naming a variable and calling methods on it line by line. In idiomatic Clojure, Java interop is used only when no pure Clojure alternative exists.

Clojure and Java can call each other on the JVM. Clojure code calls Java directly with dot notation. Java code calls Clojure via the clojure.java.api.Clojure runtime API, or by compiling Clojure namespaces to Java classes with :gen-class. This bidirectional interop makes gradual adoption practical — add Clojure to an existing Java project one namespace at a time.

Atoms are Clojure's primary tool for managing mutable state. swap! applies a function to the current value and replaces it atomically — without locks. @atom (or deref) reads the current value. Unlike Java's mutable fields, atoms are explicitly identified in the code and their updates are always safe under concurrent access.

swap! is the atomic equivalent of reading the current value, applying a function, and writing the result. (swap! event-log conj "started") is equivalent to eventLog.add("started") but is safe under concurrent access — if two threads call swap! simultaneously, both updates are applied without data loss. The function passed to swap! must be pure because it may be retried.

reset! sets an atom to an absolute value (unlike swap! which applies a function). add-watch registers a callback that fires whenever the atom's value changes, providing a reactive pattern without the complexity of Java's PropertyChangeListener. The watcher receives the key, the atom reference, the old value, and the new value.

The idiomatic Clojure approach often avoids atoms entirely — pass state as a function argument and return the new state. update applies a function to a value in a map and returns the new map. fnil wraps a function so that a nil argument (missing key) is replaced with a default value. This functional style makes state transitions explicit and easy to test in isolation.

Clojure's try/catch/finally mirrors Java's structure. In ClojureScript (Scittle), use :default to catch any exception — there are no named exception classes as in the JVM. On the JVM, write (catch ArithmeticException error ...). The finally block runs regardless of whether an exception was thrown.

ex-info creates an exception with a message and a data map — richer than Java's plain message string. The data map carries structured context (the actual values that caused the error). On the JVM, ex-data retrieves this map from a caught exception. For catching specific Java exception classes on the JVM: (catch IllegalArgumentException error ...).

ex-info replaces Java's custom exception subclasses. Instead of defining a new class with additional fields, attach structured data as a map. On the JVM, (ex-data error) retrieves this map from a caught ExceptionInfo. This approach is more flexible than a class hierarchy — the data map can contain arbitrary context without writing boilerplate classes.

Most Clojure core functions are nil-safe by convention — count, get, and first on nil return sensible defaults rather than throwing NullPointerException. The some-> macro threads a value like -> but stops and returns nil if any step returns nil — equivalent to Java's optional chaining or Optional.map().