Mac Has Java 25 Installed But Still Shows an Old Version? 2026 Beginner Fix Guide

An installed JDK is like a textbook placed in a bookcase. The java command is the book currently sitting on your desk. Installing another textbook does not automatically replace the one you are reading.

Open Terminal and run these commands separately:

java -version
which java
javac -version
which javac
/usr/libexec/java_home -V

The commands answer different questions:

• java -version shows the runtime version used by the current java command. If it reports an older release, Java 25 is not the active runtime.
• which java shows the executable path selected by your shell. If it points to an unexpected location, the issue is probably PATH.
• javac -version checks whether the Java compiler is available. Java learning requires this check because running a program and compiling a program are separate tasks.
• which javac shows which compiler your shell finds. It should belong to the JDK you intend to use.
• /usr/libexec/java_home -V asks macOS to list recognized JDK installations. Oracle documents this Java selection method for macOS, along with the JDK installation structure in its JDK 25 macOS installation guide.

Expected result: the JDK list includes a Java 25 installation, while the first two version commands may still show an older release. That means installation succeeded, but selection is wrong.

Stop here if the JDK list does not include Java 25. Do not edit shell files yet. Confirm that you downloaded and completed a full JDK installation from the official JDK 25 download information, then repeat the checks.

A runtime can launch Java programs. A full JDK also includes development tools such as javac. Think of the runtime as a classroom where you can read instructions, while the JDK is the classroom plus the tools needed to submit your own assignment.

Run:

java -version
javac -version

If the first command works and the second returns command not found, check the installation list:

/usr/libexec/java_home -V

Then inspect the selected home directory:

echo "$JAVA_HOME"

Possible outcomes:

• If no Java 25 installation appears, the JDK is not installed or macOS does not recognize it.
• If Java 25 appears but JAVA_HOME is empty, your shell has no explicit JDK selection.
• If JAVA_HOME points to an older directory, the compiler check may be using the wrong installation.
• If JAVA_HOME points to Java 25 but javac is still missing, the JDK may be incomplete or PATH may not include its bin directory.

Oracle's macOS documentation describes the JDK installation directory and the supported Java home selection process. Use those documented locations and commands instead of copying a random repair script from a forum.

Do not delete files from protected macOS system directories, disable security controls, or run an unknown script with administrator privileges. A version mismatch is an environment-selection problem until your checks prove otherwise.

A complete Java learning environment should pass both tests:

java -version
javac -version

The version lines should identify Java 25, or the exact JDK version currently required by your course. If your course uses another release, do not force Java 25 just because it is newer. Keep the course requirement as the decision rule.

JAVA_HOME is like a course registration card. It tells tools which JDK should be treated as the active one. PATH is the classroom directory map. It tells the shell where to look for commands.

First ask macOS for the Java home associated with Java 25:

/usr/libexec/java_home -v 25

If the command returns a valid Java 25 directory, test that directory in the current Terminal window:

export JAVA_HOME=$(/usr/libexec/java_home -v 25)
export PATH="$JAVA_HOME/bin:$PATH"

Now verify:

echo "$JAVA_HOME"
java -version
javac -version

The first line should show the Java 25 home selected by macOS. Both version commands should now use Java 25. This temporary test is useful because it does not permanently change your shell configuration.

When the fix disappears after reopening Terminal

If the commands work until you close Terminal, the selection was only stored in the current shell session. Save the same two export lines in the startup file used by your shell. Before editing, create a backup of the file you plan to change:

cp ~/.zshrc ~/.zshrc.backup

Then open the file:

nano ~/.zshrc

Add:

export JAVA_HOME=$(/usr/libexec/java_home -v 25)
export PATH="$JAVA_HOME/bin:$PATH"

Save the file, reopen Terminal, and run the verification commands again.

If ~/.zshrc does not control your Terminal session, check which shell is active:

echo "$SHELL"

Do not create several startup files just to make the setting work. That often produces a new conflict.

When several JAVA_HOME lines already exist

Search your common shell file:

grep -n "JAVA_HOME\|PATH=.*JAVA" ~/.zshrc ~/.zprofile 2>/dev/null

If you see multiple assignments, read them from top to bottom. The last assignment may override the earlier one. Keep a backup, remove or comment out obsolete Java entries, and leave one clear Java 25 selection. If you are unsure which line belongs to your school or work setup, restore the backup instead of guessing.

To return to the previous temporary state in the current Terminal window, use:

unset JAVA_HOME

For permanent changes, restore your backup:

mv ~/.zshrc.backup ~/.zshrc

Only use the restore command if that backup represents the configuration you want to recover. The purpose is controlled rollback, not repeated trial and error.

Java 25 macOS packages distinguish between Apple Silicon systems using AArch64 and Intel systems using x64. Oracle lists these architecture choices in its JDK documentation and download materials.

Identify the processor architecture with:

uname -m

Interpret the result:

• arm64 means the Mac uses Apple Silicon. Select the AArch64 package.
• x86_64 means the Mac uses an Intel processor. Select the x64 package.

An incorrect package can fail during installation, launch unexpectedly, or create compatibility problems later. It is not a reason to promise a specific performance difference. The correct choice is simply the package matching the processor.

If you use a remote Mac, do not infer the architecture from a machine nickname, location, or plan label. Ask for the architecture in the delivery information, or check it from the remote desktop with uname -m. You need the operating system result, not a guess based on the device name.

If the package architecture is wrong, stop before changing JAVA_HOME. Download the matching JDK, complete the official installation, and then return to the path checks.

A correct terminal result does not prove that an IDE uses Java 25. There may be three separate selections:

• The JDK used by the Terminal.
• The runtime used to launch the IDE.
• The project or module SDK selected inside the IDE.

For IntelliJ IDEA, inspect the project SDK and module settings. JetBrains explains the relationship between the IDE SDK and project configuration and provides further detail about project and module structure.

Use one small file to compare the environments:

public class VersionCheck {
    public static void main(String[] args) {
        System.out.println(System.getProperty("java.version"));
        System.out.println(System.getProperty("java.home"));
    }
}

Save it as VersionCheck.java. In Terminal, compile and run it:

javac VersionCheck.java
java VersionCheck

Then run the same file from the IDE.

Interpret the difference:

• If both outputs identify Java 25, the project is aligned.
• If Terminal shows Java 25 but the IDE shows an older version, change the project SDK or module SDK.
• If the IDE cannot compile the file, its selected SDK is missing or points to a runtime without the compiler.
• If the IDE output changes but Terminal does not, the IDE is using its own project setting. That is acceptable if the course project works, but document the difference.

Do not turn this repair into a full IDE installation tutorial. First identify which of the three environments is wrong. For IDE terminal behavior, compare its terminal configuration with the official terminal emulator settings.

Choose the next action from the condition that matches your evidence:

• If /usr/libexec/java_home -V lists Java 25 and the temporary exports fix both commands, then clean up duplicate shell entries and keep the local setup.
• If Java 25 is listed but javac remains unavailable, then verify that a complete JDK is installed. Do not treat a working java command as proof that the compiler exists.
• If Terminal passes but the IDE fails, then change the project or module SDK. Reinstalling the JDK is not the first response.
• If the architecture does not match the downloaded package, then install the AArch64 or x64 package that matches uname -m.
• If the school device blocks installation or shell-file changes, then ask for an authorized environment or use a separate Mac. Do not bypass device management.
• If the environment keeps changing after every login and you cannot control the startup files, then stop repairing that machine and move the project to a clean, authorized environment.

This prevents the common mistake of reinstalling Java when the real problem is a stale path.

Mark each item only after it succeeds:

• [ ] java -version reports the intended Java 25 installation.
• [ ] javac -version works in the same Terminal session.
• [ ] which java and which javac point to the expected JDK family.
• [ ] /usr/libexec/java_home -V shows the installed JDK.
• [ ] echo "$JAVA_HOME" matches the selected Java home.
• [ ] The shell still works after you reopen Terminal.
• [ ] VersionCheck.java compiles with javac.
• [ ] The program runs from Terminal.
• [ ] The same file runs from the IDE with the intended project SDK.
• [ ] Your course project files are saved in a location you can access after reconnecting.
• [ ] You have not modified protected system directories or bypassed school controls.

If one item fails, record the exact command and output. Avoid changing several variables at once. A clean record makes it easier to ask a teacher, administrator, or support engineer for help.

Why does installing Java 25 not change java -version?

Because installation adds a JDK, while the shell still follows its existing path. Check the JDK list, which java, JAVA_HOME, and PATH in that order. The result tells you whether Java 25 is missing, unselected, or hidden behind an older entry.

How do I make Java 25 the default on macOS?

Use /usr/libexec/java_home -v 25 to obtain the recognized Java 25 home. Export that result through JAVA_HOME, place $JAVA_HOME/bin first in PATH, and test both java -version and javac -version. Save the setting only after the temporary test succeeds.

Why is javac missing even though Java runs?

You may have a runtime without compiler tools, an incomplete JDK, or a path aimed at another installation. Check javac -version, which javac, and the recognized JDK list. Install a complete JDK from the official source if Java 25 is not fully present.

Why does IntelliJ IDEA use an older JDK?

The project SDK is independent from the terminal default. Open the project and module SDK settings, select the intended Java 25 installation, and run the small version-check file inside the IDE. Compare java.version and java.home with the terminal output.

A school-managed computer can block installation. An old personal Mac can contain years of conflicting shell entries. A temporary remote environment can also be easier to reset than a machine you share with other users. Your current setup becomes the weaker option when you cannot obtain permission, cannot preserve the configuration after login, or cannot compile the course project consistently.

For short assignments, testing, or a course project, an authorized remote Mac can give you a separate macOS workspace without forcing changes to a school computer. CALMVPS provides remote Mac access through its available service options; review the Mac environment overview before deciding whether that workflow fits your class.

The important comparison is not “local versus remote” in the abstract. Your current setup may have restricted permissions, stale PATH entries, and an IDE that resets its SDK. A managed remote Mac can offer a clean starting point, persistent project storage when the selected arrangement supports it, and access from a computer that cannot install development tools. It is not the best choice for every long-running workload or for projects that require direct physical hardware, but it can be a sensible temporary learning environment. Check the available CALMVPS options only after your acceptance checklist shows what your course actually needs.