Java.CodeCompared.To/PHP

Your JVM keeps that static field for weeks, which is why a leak matters, why a singleton cache works, and why one bad request can poison every later one. A PHP request starts a fresh interpreter, runs your file, sends the output and throws everything away — including every static field, so the next request sees visit 1 again. Anything that must survive goes to a session, a cache like Redis, or the database. Almost everything else on this page follows from that sentence.

There is no warmup to wait for and no JIT tiering to reason about (PHP 8 has an optional JIT, and it helps compute-bound code rather than typical web work). Opcache is the piece that makes this viable: it caches the compiled bytecode of your files between requests, so parsing is paid once rather than per request — and it is a deployment concern, since a stale opcache serves old code. What genuinely disappears is the connection pool: each request opens its own database connection unless you put a proxy in front, which is why persistent connections and PgBouncer-style poolers matter more here than on the JVM.

$_GET, $_POST, $_SERVER, $_COOKIE, $_FILES and $_SESSION are visible in every scope without being passed or imported, because there is only ever one request in the process to confuse them with. That is also why the pattern is safe here and would be a catastrophe on the JVM. Every value in them is attacker-controlled text with no schema, so validate at the boundary. Symfony and Laravel wrap them in a PSR-7 Request object precisely so code can be tested and typed.

echo writes exactly what you give it and adds no newline, so you write one. A file that is nothing but PHP omits the closing ?> by convention, because whitespace after it is sent to the browser and breaks a later header() call. There is no compile step and no artifact: the .php file you write is the file the server executes.

A bare $name works; anything more complex needs braces, as in "{$user['name']}" or "{$order->total}". Java previewed string templates in 21 and 22 and then withdrew them, so this is one of the rare places PHP has the more modern syntax. Concatenation is . rather than +, and + on two strings is a TypeError in PHP 8. printf is C's and behaves as Java's does, minus %n.

PHP's margin is set by the indentation of the closing marker (since 7.3), where Java uses the least-indented line or the closing delimiter, whichever is further left. The difference that matters is interpolation: a heredoc interpolates, so formatted(...) is unnecessary. Use <<<'TEXT' with quotes around the marker for the nowdoc form — no interpolation and no escapes, which is the closer analogue of a Java text block.

That is a genuinely different trade, and it is worth appreciating rather than dismissing: a wrong argument fails at the boundary with a named error rather than three frames deeper. declare(strict_types=1) as the first statement of every file is the setting you want — without it PHP coerces, so "21" silently becomes 21 and a float is truncated. It is per-file rather than per-project, which surprises everyone once. Static analysers (PHPStan, Psalm) read the same declarations and give you the compile-time half.

@template T is read by PHPStan and Psalm, which check the calls and infer the element type through your code — genuinely comparable to what javac does with <T>. The difference from Java's erasure is that here nothing exists at run time either: the engine sees mixed. Two habits to bring across: type collection parameters as list<User> or array<string, User> in a docblock (array alone says nothing), and run PHPStan at level 9 in CI so those comments are load-bearing rather than decorative.

?-> short-circuits the whole chain to null at the first empty, and ?? supplies the fallback exactly as orElse does. There is no Optional and no need for one at this scale. The type half is stronger than Java's too: a function declaring : string genuinely cannot return null — it throws on the way out — where a Java method returning String may hand you null with nothing to say so. isset() means "set and not null"; empty() is the trap, since it is also true for 0, "0", "" and [].

First, / always promotes to float: 7 / 2 is 3.5, not 3, and integer division is intdiv. Second, there is no overflow: past PHP_INT_MAX an integer silently becomes a float and starts losing precision, where a Java long wraps to a negative number. Neither is checked, so both are quiet — but a float is at least approximately right. Note the printing: plain echo rounds to 14 significant digits and hides 0.1 + 0.2, while var_export and json_encode show the truth.

So count() works on both and every array function takes both. What you give up is the type-level distinction — array as a declared type says nothing about keys or elements, which is why the docblock vocabulary from the generics row matters. array_is_list() (8.1) is the run-time check, and it has a visible consequence: json_encode emits […] for a list and {…} for anything else, so removing one element from the middle changes the shape of your API response.

So a function that appends to an array parameter changes nothing the caller can see, and the whole defensive-copying discipline the JVM requires — List.copyOf on the way in and out, Collections.unmodifiableList for a view — is simply unnecessary. The copy is lazy underneath (copy-on-write), so the cost is paid only on modification. Declare &$items to pass by reference when you genuinely want the Java behaviour. Objects go the other way and behave exactly as in Java: $b = $a gives two names for one instance, and clone makes a shallow copy.

They are also eager: each call builds a whole new array, where a stream is lazy and fused. For a large source that matters, and the answer is a foreach or a generator. Watch the argument order, which is genuinely inconsistent — array_map(callback, array) puts the callback first while array_filter(array, callback) puts the array first. And array_filter preserves keys, so filtering a list can leave keys 1, 3, 5 and turn the next json_encode into an object; wrap it in array_values().

The comparator contract is identical: negative, zero or positive, and PHP's <=> spaceship operator produces exactly that for any two comparable values. The family is large and the names encode the axis: sort discards keys, asort keeps them, ksort sorts by key, and the u prefix takes your comparator. There is no Comparator.comparing(...).thenComparing(...) builder — a compound sort is one comparator with ?: chaining the spaceships.

Since arrays are values, foreach iterates a copy and modifying the array inside the loop is safe: there is no ConcurrentModificationException and no iterator to invalidate. Writing foreach ($items as &$item) takes a reference so you can modify elements in place, and it carries a famous trap — $item is still a reference to the last element after the loop, so a second foreach reusing that name corrupts the array. unset($item) after the loop, or avoid the ampersand.

The argument order is the part everyone complains about. str_replace($search, $replace, $subject) puts the subject last while strpos($haystack, $needle) puts it first; the inconsistency is historical and permanent. The modern additions are consistent and worth preferring: str_contains, str_starts_with and str_ends_with (PHP 8.0) take the haystack first and return real booleans, replacing the old strpos(...) !== false dance.

PHP strings are values, not objects, so there is no identity to accidentally compare: == compares text. === additionally requires the same type, which is what you want — "1" == 1 is still true in PHP 8 while "1" === 1 is false. The same applies to arrays: === compares contents (and key order), which is a real convenience after Arrays.equals and List.equals. For objects, PHP keeps the Java rule — == is same class with equal properties, === is the same instance.

A Java String is UTF-16, so length() counts code units — imperfect for astral characters but at least "naïve".length() is 5. PHP's strlen says 6, and substr($word, 0, 3) can cut a character in half and produce invalid UTF-8. The rule: use the mb_* family for anything user-facing and set mb_internal_encoding('UTF-8'); byte functions are correct only when you genuinely mean bytes. There is no char type and no Charset to specify — a string simply holds whatever bytes you put in it. mb_* lives in the mbstring extension, which is not compiled into every PHP build — extension_loaded('mbstring') is worth checking before you rely on it.

Matches come back through a by-reference third parameter, and the return value is the count (or false on a malformed pattern), which is why the result is read from $match rather than from the call. Note the escaping: PHP's single-quoted string leaves \d alone, where Java needs \\d in a literal — one of the small daily reliefs. The engine is PCRE rather than java.util.regex, so the syntax is close but not identical (possessive quantifiers and recursion are available; some Java-specific constructs are not).

Both are expressions, both allow several labels per arm, and both refuse to fall through. Two differences: PHP's match compares with === rather than equals, and an unmatched value with no default throws UnhandledMatchError — the analogue of Java's MatchException. What PHP lacks is pattern matching: there are no type patterns, no record deconstruction and no sealed-type exhaustiveness. The idiomatic replacement for an if/else ladder is match(true) with boolean arms.

Falsy: false, 0, 0.0, "", "0", [] and null. The string "0" is the one that bites — a form field or a database column arriving as text can be silently falsy. ?: (Elvis) falls back on anything falsy, while ?? falls back only on null or a missing key; reach for ?? unless you genuinely mean "or anything empty". Writing the explicit test (count($items) === 0) is never wrong and is what a Java reader should keep doing until the falsy list is second nature.

The Java column also shows the flaw the idiom carries: two overloads differing only in an int cannot express which int the caller meant, and connect("host", 5) silently means timeout. Named arguments make that explicit. The new obligation is that a parameter name is now part of your public signature, so renaming one is a breaking change. Variadics are ...$rest, and spreading a keyed array at a call site fills in named arguments.

use ($count) captures the value at the moment the closure is created; use (&$count) captures the variable, which is what makes the counter work. Arrow functions (fn() => ..., 7.4) capture the enclosing scope automatically by value and are limited to one expression. Note that PHP has no block scope and no lexical closure by default — a variable set inside an if is visible after it, and a nested function sees nothing from around it.

A plain string names a global function; an array names a method ([$object, 'method'] or [Klass::class, 'staticMethod']); and PHP 8.1's first-class callable syntax makes a real Closure out of any of them — strtoupper(...), $object->method(...), Klass::make(...). Prefer that last form for the same reason you prefer String::toUpperCase to reflection: it is checked where it is written. The callable type declaration accepts all of them and says nothing about the signature; a docblock callable(int): string is how PHPStan learns it.

The closest Java equivalents are a lazy Stream (as above) or a hand-written Iterator, neither of which lets you write the producer as ordinary sequential code with local state. yield $key => $value produces keys, yield from delegates to another generator, and $generator->send() passes values back in. Generators are the standard way to stream a large database result or a big file without holding it in memory — the same job as a Stream, written the other way round.

Three notes. $this-> is an arrow, not a dot, and it is mandatory — a bare $balance inside a method is a local variable. readonly (8.1) makes a property assignable exactly once, from inside the class, which is stronger than final plus a getter and much shorter; a public readonly property needs no accessor at all. And the constructor is named __construct rather than after the class, so there is exactly one — no overloading, which is what default and named arguments replace.

Inside the class, self:: refers to the class the code was written in and static:: to the class actually being called (late static binding), which is the distinction Java has no need for because static methods are not virtual. parent::method() is super.method(). One inconsistency you will mistype: a static property keeps its $ after the colons (Counter::$created) while a const does not.

What is missing is @Override: nothing marks an override and nothing warns when a misspelled name silently becomes a new method — the bug the annotation exists to prevent. Static analysers catch it; the language does not. final works on classes and methods as in Java, abstract too, and a child's method may not narrow visibility. There are no annotations for the compiler to read at all, though attributes (8.0) are the metadata equivalent, which the frameworks section covers.

This is how Laravel's Eloquent models expose database columns as properties, and how a great deal of PHP framework magic works. The cost is real: __get and __call are invisible to static analysis and to your editor, which is what the @property docblock is for — it tells PHPStan and PhpStorm what the class pretends to have. The others worth knowing are __toString, __invoke (making an object callable) and __clone. Reach for them when modelling something genuinely dynamic; declare real properties otherwise.

What PHP gives you for free is the comparison: == on two objects is true when they are the same class with equal properties, so structural equality needs no equals and no hashCode. === is identity. What you write yourself is __toString, and there is no with-style copy — clone plus readonly properties means a changed copy needs a new constructor call, or PHP 8.3's clone with-adjacent workarounds. Note that a readonly property cannot be reassigned even inside __clone before 8.3.

The interface-plus-trait pairing is the idiomatic replacement and is what the standard library does: the interface is the type, the trait is the code. Every interface member is implicitly public. Multiple interface inheritance works as in Java. Note that a trait cannot be used as a type — a parameter typed with a trait name is an error — which is exactly why the interface is still needed.

It is inserted into the using class at compile time — no extra class in the hierarchy, no runtime lookup, and the methods behave as if you had written them there. Conflicts between two traits are a fatal error you must resolve explicitly with insteadof and as, which is more honest than a linearisation rule. Traits may declare abstract methods (a requirement on the using class) and static properties (one per using class, not shared). This is the feature that makes Laravel's models and Symfony's helpers as compact as they are.

A backed enum (the : string) declares its scalar value in the case list rather than in a constructor, with Status::from('active') to convert in (throwing on an unknown value) and tryFrom returning null instead. ->value reads it back and ->name gives the case name. Status::cases() is values(). A match over every case needs no default, but — unlike Java — adding a case later does not break the compile; it throws UnhandledMatchError at run time. Enums may implement interfaces and hold constants, but not properties.

The closest shape is an abstract base with final subclasses, matched by instanceof inside a match (true). Nothing stops a third subclass appearing in another file, and nothing warns when a match misses it — it throws UnhandledMatchError at run time, which is a real check and not a compile-time one. PHPStan can be told the closed set with an annotation, which is again the analyser doing the compiler's job. There is also no destructuring: the payload is read through properties.

The @throws docblock is documentation — though PHPStan and Psalm both read it, and both can be configured to report a call that ignores a documented exception, which gets you most of the way back. catch is typed exactly as in Java and several clauses may follow one try, with catch (AException|BException $error) for alternatives. Since 8.0 the variable is optional: catch (JsonException) is legal when you do not need it.

That inverts a Java habit. NullPointerException, ClassCastException and ArithmeticException are all RuntimeExceptions, so catch (Exception) catches them; in PHP TypeError, ValueError, DivisionByZeroError and ArgumentCountError are Errors, and catch (Exception $e) — which looks like a catch-all — misses every one of them. Catch \Throwable when you mean everything. For your own exceptions extend RuntimeException or LogicException; the SPL hierarchy is shallow and conventional.

Reading a missing array index is a warning, not an exception, and the value you get is null. The second line is where it turns dangerous: adding one gives 1, because null converts to 0 — a wrong answer that looks exactly like a right one, where Java would have thrown at the first line. Two habits: read anything that might be absent with ??, and install a set_error_handler that throws ErrorException, which every framework does for you. The @ operator suppresses diagnostics for one expression and is almost always the wrong tool.

What PHP does have, and Java gave up, is a deterministic destructor: __destruct runs as soon as the last reference goes away, because the engine is reference-counted with a cycle collector behind it. So an object holding a file handle really does release it at end of scope. It is still not the place for important cleanup — destruction order during shutdown is unspecified, and an exception thrown from a destructor is fatal — but it is closer to RAII than anything on the JVM. And at the end of every request the whole process goes away, which is its own kind of cleanup.

That sounds like a limitation and is also why PHP sidestepped a decade of concurrency bugs the JVM world fought: there is no shared mutable state to corrupt, because there is nothing to share it with. Concurrency comes from running more processes — PHP-FPM keeps a pool of workers, and the tuning knob is pm.max_children rather than a thread pool size. The parallel extension exists and is rare; pcntl_fork exists and is for CLI scripts only. Design for a request that does one thing at a time.

When that is too slow, the three answers above cover nearly every case, and the second is the one most PHP applications reach for — anything slow is pushed to a queue and answered later, which is the same architecture a JVM team would use for work too long for a request thread. What is missing is the middle ground: there is no way to fan out CPU work inside one request, so a PHP application that needs that is usually the wrong tool rather than the wrong design.

A fiber is not concurrency — there is still one thread and the scheduler is you (or ReactPHP, or Amp). What it shares with a virtual thread is the property that matters: the suspension is invisible to the caller, so an ordinary function deep inside a fiber may suspend and no signature needs marking. That is exactly why Fibers were added, and it is why you will almost certainly never write new Fiber yourself. A virtual thread costs two real threads underneath — a carrier to run it and an unblocker to wake it, one more than the servers that run the Java here allow, so the Java is shown rather than run.

total += 1 is a read, an add and a write, so the Java column loses updates and prints a number well under 200,000 that varies between runs. PHP has nothing to share the variable with, so the answer is exact. (The Java is shown rather than run: the servers that run it here allow only one thread beyond main, and this needs two.) The category of bug that synchronized, AtomicInteger and the Java memory model exist to prevent simply does not arise — and neither do their costs. What replaces the concern is cross-request state: two simultaneous requests hitting the same database row still need a transaction or a lock, and that is where the reasoning moves.

The separator is a backslash, which is why it must be escaped in double-quoted strings and why example code is full of them; a leading backslash means the global namespace (\strlen(), \Throwable). use X as Y aliases, which Java cannot do. Nothing enforces the path-to-namespace correspondence — PSR-4 is a convention the autoloader relies on, so App\Http\Client lives in src/Http/Client.php because composer.json says the App\ prefix maps to src/. There is also no package-private visibility: public, protected and private are the whole list.

First, Composer has a real lockfile and commits it, so composer install is reproducible where mvn package depends on resolution rules. Second, there is no classpath: require vendor/autoload.php once at each entry point and every installed class is available by name, loaded lazily on first use. Third, there is no build — no jar, no shading, no fat-jar plugin — which removes a category of problem and replaces it with deployment questions about opcache. Packagist is Maven Central, and the version constraint syntax is npm-style carets rather than Maven ranges.

The practical effect is the same one Jakarta EE aims at — a library can accept a PSR-7 Request or log through a PSR-3 LoggerInterface without knowing which framework you use — reached by adoption rather than by certification. PSR-4 and PSR-12 are the two you will meet immediately: the first is why your directory layout matters, the second is what php-cs-fixer formats to. There is no reference implementation and no compliance test suite; a package either implements the interface or does not.

The syntax is #[Name(args)], which is a comment to older parsers — that is why it was chosen. An attribute is an ordinary class, so its constructor signature is its parameter list, and newInstance() constructs it. Symfony uses them for routing and dependency injection, Doctrine for entity mapping, PHPUnit for test metadata — the same places Spring and JPA use annotations. Before 8.0 the ecosystem read the same metadata out of docblock comments, which you will still meet in older Doctrine and Symfony code.

Symfony is the closer analogue: a container that autowires constructors, attributes for routing, and Doctrine as a data-mapper ORM with the same identity-map and unit-of-work ideas as JPA. Laravel is Rails-shaped — Eloquent is active record, so the model is the table row, which has no JPA equivalent and is the bigger adjustment. The one structural difference behind both: the container is rebuilt every request, so it is compiled and cached to a file rather than assembled at startup, and a "singleton" is a singleton for one request only.