Windows 环境下 Java 多版本管理与切换指南

Windows 环境下 Java 多版本管理与切换指南 | 极客日志

方案	难度	灵活性	自动化程度	适用场景
手动环境变量	⭐⭐	⭐⭐	⭐	偶尔切换，简单项目
批处理脚本	⭐⭐⭐	⭐⭐⭐⭐	⭐⭐⭐	频繁切换，多项目开发
PowerShell 脚本	⭐⭐⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐	高级用户，复杂环境
JENV 工具	⭐⭐	⭐⭐⭐⭐⭐	⭐⭐⭐⭐⭐	专业开发，团队协作
IDE 配置	⭐	⭐⭐⭐	⭐⭐⭐⭐	IDE 内开发，项目隔离

推荐的 JDK 版本组合： 🔥 主力版本： - JDK 17 (LTS) - 当前主流长期支持版本 - JDK 11 (LTS) - 企业级应用广泛使用 - JDK 8 (LTS) - 历史项目维护必备 🚀 尝鲜版本： - JDK 21 (LTS) - 最新长期支持版本 - JDK 22 - 最新特性体验 📊 特殊需求： - JDK 1.7 - 极老项目维护 - OpenJDK - 开源项目偏好

C:\Program Files\Java\
 ├── jdk-8\ # JDK 8
 ├── jdk-11\ # JDK 11
 ├── jdk-17\ # JDK 17
 ├── jdk-21\ # JDK 21
 └── current -> jdk-17\ # 当前使用版本的符号链接

# 1. 访问 Oracle 官网下载
# https://www.oracle.com/java/technologies/downloads/
# 2. 选择对应版本的 Windows x64 Installer
# 例如：jdk-17_windows-x64_bin.exe
# 3. 安装时自定义安装路径
# 默认路径：C:\Program Files\Java\jdk-17
# 建议路径：C:\Java\jdk-17 (避免空格路径问题)

# 使用 Chocolatey 包管理器安装（推荐）
# 1. 安装 Chocolatey
Set-ExecutionPolicy Bypass -Scope Process-Force
[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072
iex((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))
# 2. 安装多个 OpenJDK 版本
choco install openjdk8 -y
choco install openjdk11 -y
choco install openjdk17 -y
choco install openjdk21 -y
# 3. 查看安装的版本
choco list openjdk -l

# 创建 Java 安装目录
New-Item -ItemType Directory -Path "C:\Java" -Force
# 下载并解压 OpenJDK（以 JDK 17 为例）
# 1. 从 https://adoptium.net/ 下载 zip 包
# 2. 解压到 C:\Java\jdk-17
# 验证安装
C:\Java\jdk-17\bin\java -version

# check_jdk_installations.ps1
Write-Host "=== JDK Installation Check ===" -ForegroundColor Green
$jdkPaths = @("C:\Java\jdk-8","C:\Java\jdk-11","C:\Java\jdk-17","C:\Java\jdk-21","C:\Program Files\Java\jdk-8","C:\Program Files\Java\jdk-11","C:\Program Files\Java\jdk-17","C:\Program Files\Java\jdk-21")
foreach($path in $jdkPaths){
    if(Test-Path "$path\bin\java.exe"){
        Write-Host "✅ Found JDK at: $path" -ForegroundColor Green
        # 获取版本信息
        $version = & "$path\bin\java.exe" -version 2>&1 | Select-String "version" | Select-Object -First 1
        Write-Host " Version: $version" -ForegroundColor Cyan
        Write-Host ""
    }
}
Write-Host "Current JAVA_HOME: $env:JAVA_HOME" -ForegroundColor Yellow
Write-Host "Current PATH Java: $(where.exe java)" -ForegroundColor Yellow

方法一：通过系统属性
1. 右键'此电脑' → '属性'
2. 点击'高级系统设置'
3. 点击'环境变量'按钮
方法二：通过运行命令
1. Win + R 打开运行对话框
2. 输入：sysdm.cpl
3. 切换到'高级'选项卡
4. 点击'环境变量'
方法三：通过设置应用
1. Win + I 打开设置
2. 搜索'环境变量'
3. 点击'编辑系统环境变量'

在'系统变量'区域：
1. 点击'新建'按钮
2. 变量名：JAVA_HOME
3. 变量值：C:\Java\jdk-17
4. 点击'确定'
注意事项：
- 路径不要包含分号
- 路径末尾不要加反斜杠
- 如果路径包含空格，需要用双引号包围

在'系统变量'区域找到 PATH：
1. 选中'Path'变量，点击'编辑'
2. 点击'新建'按钮
3. 输入：%JAVA_HOME%\bin
4. 点击'确定'
或者在变量值末尾添加：;%JAVA_HOME%\bin
注意：
- 使用%JAVA_HOME%引用，便于后续切换
- 确保%JAVA_HOME%\bin 在其他 Java 路径之前

# 重新打开命令提示符窗口
# 验证 JAVA_HOME
echo %JAVA_HOME%
# 验证 PATH 中的 Java
where java
# 验证 Java 版本
java -version
# 验证编译器版本
javac -version
# 完整验证脚本
# 🔧 实用技巧：保存为 verify_java.bat，用于快速验证 Java 环境配置
@echo off
echo === Java Environment Verification ===
echo.
echo JAVA_HOME: %JAVA_HOME%
echo.
echo Java executable location: where java
echo.
echo Java version: java -version
echo.
echo Java compiler version: javac -version
echo.
echo === Verification Complete ===
pause

1. 打开环境变量设置
2. 修改 JAVA_HOME 的值为目标 JDK 路径
例如：C:\Java\jdk-11
3. 点击'确定'保存
4. 重新打开命令提示符验证

变量类型	作用范围	权限要求	建议使用场景
用户变量	仅当前用户	普通用户权限	个人开发环境
系统变量	所有用户	管理员权限	团队共享环境

# 查看当前用户的 Java 环境
[Environment]::GetEnvironmentVariable("JAVA_HOME","User")
[Environment]::GetEnvironmentVariable("PATH","User")
# 查看系统级的 Java 环境
[Environment]::GetEnvironmentVariable("JAVA_HOME","Machine")
[Environment]::GetEnvironmentVariable("PATH","Machine")

@echo off
REM switch_jdk.bat - JDK 版本切换脚本
REM 💡 重点提示：这是最基础的 JDK 切换脚本，适合快速上手
echo === JDK Version Switcher ===
echo.
echo Available JDK versions:
echo 1. JDK 8
echo 2. JDK 11
echo 3. JDK 17
echo 4. JDK 21
echo 5. Show current version
echo 0. Exit
echo.
set /p choice="Please select JDK version (0-5): "
if "%choice%"=="1" goto JDK8
if "%choice%"=="2" goto JDK11
if "%choice%"=="3" goto JDK17
if "%choice%"=="4" goto JDK21
if "%choice%"=="5" goto SHOW
if "%choice%"=="0" goto EXIT
goto INVALID

:JDK8
set JAVA_HOME=C:\Java\jdk-8
echo Switched to JDK 8
goto VERIFY

:JDK11
set JAVA_HOME=C:\Java\jdk-11
echo Switched to JDK 11
goto VERIFY

:JDK17
set JAVA_HOME=C:\Java\jdk-17
echo Switched to JDK 17
goto VERIFY

:JDK21
set JAVA_HOME=C:\Java\jdk-21
echo Switched to JDK 21
goto VERIFY

:SHOW
echo Current JAVA_HOME: %JAVA_HOME%
"%JAVA_HOME%\bin\java" -version
goto END

:VERIFY
echo.
echo New JAVA_HOME: %JAVA_HOME%
echo Verifying installation...
"%JAVA_HOME%\bin\java" -version
goto END

:INVALID
echo Invalid choice! Please try again.
goto END

:EXIT
echo Goodbye!
exit /b 0

:END
echo.
pause

@echo off
REM advanced_jdk_switch.bat - 高级 JDK 切换脚本
REM 🚀 实用技巧：这个脚本包含日志记录、历史查看、永久设置等高级功能
setlocal enabledelayedexpansion
REM 配置 JDK 安装路径
set JDK_BASE_PATH=C:\Java
set JDK8_PATH=%JDK_BASE_PATH%\jdk-8
set JDK11_PATH=%JDK_BASE_PATH%\jdk-11
set JDK17_PATH=%JDK_BASE_PATH%\jdk-17
set JDK21_PATH=%JDK_BASE_PATH%\jdk-21
REM 日志文件
set LOG_FILE=%~dp0jdk_switch.log

:MAIN
cls
echo ╔══════════════════════════════════════╗
echo ║ JDK Version Manager ║
echo ╚══════════════════════════════════════╝
echo.
REM 检查当前 JDK 版本
call :CHECK_CURRENT
echo Available operations:
echo [1] Switch to JDK 8
echo [2] Switch to JDK 11
echo [3] Switch to JDK 17
echo [4] Switch to JDK 21
echo [5] List all installed JDKs
echo [6] Verify current installation
echo [7] Set JAVA_HOME permanently
echo [8] View switch history
echo [0] Exit
echo.
set /p "choice=Select option (0-8): "
if "%choice%"=="1" call :SWITCH_JDK "8" "%JDK8_PATH%"
if "%choice%"=="2" call :SWITCH_JDK "11" "%JDK11_PATH%"
if "%choice%"=="3" call :SWITCH_JDK "17" "%JDK17_PATH%"
if "%choice%"=="4" call :SWITCH_JDK "21" "%JDK21_PATH%"
if "%choice%"=="5" call :LIST_JDKS
if "%choice%"=="6" call :VERIFY_INSTALLATION
if "%choice%"=="7" call :SET_PERMANENT
if "%choice%"=="8" call :SHOW_HISTORY
if "%choice%"=="0" goto :EXIT
echo.
pause
goto :MAIN

REM 检查当前 JDK 版本
:CHECK_CURRENT
echo Current Status:
if defined JAVA_HOME (
    echo JAVA_HOME: %JAVA_HOME%
    if exist "%JAVA_HOME%\bin\java.exe" (
        for /f "tokens=3" %%a in ('"%JAVA_HOME%\bin\java" -version 2^>^&1 ^| findstr "version"') do (
            set CURRENT_VERSION=%%a
            set CURRENT_VERSION=!CURRENT_VERSION:"=! 
        )
        echo Current Version: !CURRENT_VERSION!
    ) else (
        echo ❌ JAVA_HOME points to invalid path
    )
) else (
    echo ❌ JAVA_HOME not set
)
echo ----------------------------------------
return

REM 切换 JDK 版本
:SWITCH_JDK
set JDK_VERSION=%~1
set JDK_PATH=%~2
echo.
echo Switching to JDK %JDK_VERSION%...
REM 检查 JDK 是否存在
if not exist "%JDK_PATH%\bin\java.exe" (
    echo ❌ JDK %JDK_VERSION% not found at: %JDK_PATH%
    echo Please install JDK %JDK_VERSION% first.
    return
)
REM 设置环境变量
set JAVA_HOME=%JDK_PATH%
set PATH=%JAVA_HOME%\bin;%PATH%
REM 验证切换结果
echo ✅ Successfully switched to JDK %JDK_VERSION%
echo New JAVA_HOME: %JAVA_HOME%
echo.
REM 显示版本信息
"%JAVA_HOME%\bin\java" -version
REM 记录切换历史
echo [%date% %time%] Switched to JDK %JDK_VERSION% at %JDK_PATH% >> "%LOG_FILE%"
return

REM 列出所有已安装的 JDK
:LIST_JDKS
echo.
echo ═══ Installed JDK Versions ═══
set JDK_FOUND=0
if exist "%JDK8_PATH%\bin\java.exe" (
    echo ✅ JDK 8 - %JDK8_PATH%
    set /a JDK_FOUND+=1
)
if exist "%JDK11_PATH%\bin\java.exe" (
    echo ✅ JDK 11 - %JDK11_PATH%
    set /a JDK_FOUND+=1
)
if exist "%JDK17_PATH%\bin\java.exe" (
    echo ✅ JDK 17 - %JDK17_PATH%
    set /a JDK_FOUND+=1
)
if exist "%JDK21_PATH%\bin\java.exe" (
    echo ✅ JDK 21 - %JDK21_PATH%
    set /a JDK_FOUND+=1
)
if %JDK_FOUND%==0 (
    echo ❌ No JDK installations found
    echo Please install JDK versions in: %JDK_BASE_PATH%
)
echo.
echo Total JDK versions found: %JDK_FOUND%
return

REM 验证当前安装
:VERIFY_INSTALLATION
echo.
echo ═══ Installation Verification ═══
if not defined JAVA_HOME (
    echo ❌ JAVA_HOME is not set
    return
)
echo JAVA_HOME: %JAVA_HOME%
if not exist "%JAVA_HOME%\bin\java.exe" (
    echo ❌ java.exe not found
    return
)
if not exist "%JAVA_HOME%\bin\javac.exe" (
    echo ❌ javac.exe not found
    return
)
echo ✅ Java Runtime: "%JAVA_HOME%\bin\java" -version
echo.
echo ✅ Java Compiler: "%JAVA_HOME%\bin\javac" -version
echo.
echo ✅ Installation verification passed!
return

REM 永久设置 JAVA_HOME
:SET_PERMANENT
echo.
echo ═══ Set JAVA_HOME Permanently ═══
echo.
echo This will set JAVA_HOME in system environment variables.
echo Current session JAVA_HOME: %JAVA_HOME%
echo.
set /p "confirm=Make this permanent? (y/n): "
if /i "%confirm%"=="y" (
    echo Setting JAVA_HOME permanently...
    setx JAVA_HOME "%JAVA_HOME%" /M >nul 2>&1
    if errorlevel 1 (
        echo ❌ Failed to set system variable. Try running as Administrator.
        setx JAVA_HOME "%JAVA_HOME%" >nul 2>&1
        if errorlevel 1 (
            echo ❌ Failed to set user variable as well.
        ) else (
            echo ✅ Set JAVA_HOME for current user only.
        )
    ) else (
        echo ✅ JAVA_HOME set permanently for all users.
    )
) else (
    echo Operation cancelled.
)
return

REM 显示切换历史
:SHOW_HISTORY
echo.
echo ═══ JDK Switch History ═══
if exist "%LOG_FILE%" (
    type "%LOG_FILE%"
) else (
    echo No switch history found.
)
return

:EXIT
echo.
echo Thanks for using JDK Version Manager!
exit /b 0

REM create_shortcut.bat - 创建桌面快捷方式
@echo off
set SCRIPT_PATH=%~dp0advanced_jdk_switch.bat
set SHORTCUT_PATH=%USERPROFILE%\Desktop\JDK Switcher.lnk
REM 使用 PowerShell 创建快捷方式
powershell -Command "& {$WshShell = New-Object -comObject WScript.Shell; $Shortcut = $WshShell.CreateShortcut('%SHORTCUT_PATH%'); $Shortcut.TargetPath = '%SCRIPT_PATH%'; $Shortcut.WorkingDirectory = '%~dp0'; $Shortcut.IconLocation = 'C:\Windows\System32\cmd.exe,0'; $Shortcut.Description = 'JDK Version Switcher'; $Shortcut.Save()}"
echo Desktop shortcut created: %SHORTCUT_PATH%
pause

REM project_jdk.bat - 项目级 JDK 配置
REM 💡 重点提示：将此脚本放在项目根目录，配合.jdkversion 文件使用
@echo off
REM 检查项目配置文件
if exist ".jdkversion" (
    set /p PROJECT_JDK=<.jdkversion
    echo Found project JDK configuration: %PROJECT_JDK%
    REM 根据配置设置 JDK
    if "%PROJECT_JDK%"=="8" set JAVA_HOME=C:\Java\jdk-8
    if "%PROJECT_JDK%"=="11" set JAVA_HOME=C:\Java\jdk-11
    if "%PROJECT_JDK%"=="17" set JAVA_HOME=C:\Java\jdk-17
    if "%PROJECT_JDK%"=="21" set JAVA_HOME=C:\Java\jdk-21
    set PATH=%JAVA_HOME%\bin;%PATH%
    echo Project JDK set to: %JAVA_HOME%
    java -version
) else (
    echo No .jdkversion file found in current directory
    echo Create .jdkversion file with content: 8, 11, 17, or 21
)
REM 启动项目开发环境
if exist "pom.xml" (
    echo Maven project detected
    mvn --version
) else if exist "build.gradle" (
    echo Gradle project detected
    gradle --version
) else if exist "build.sbt" (
    echo SBT project detected
    sbt about
)
cmd /k

# JDKManager.ps1 - PowerShell JDK 版本管理器
# 🔧 重点提示：这是功能最完整的 JDK 管理器，支持命令行参数和交互式菜单
param([string]$Action = "menu",[string]$Version = "",[switch]$List,[switch]$Current,[switch]$Install,[switch]$Remove,[switch]$Permanent,[switch]$Help)

# 配置参数
$JDK_BASE_PATH = "C:\Java"
$CONFIG_FILE = "$env:USERPROFILE\.jdkmanager.json"
$LOG_FILE = "$env:USERPROFILE\.jdkmanager.log"

# JDK 版本配置
$JDK_VERSIONS = @{
    "8" = @{"Path" = "$JDK_BASE_PATH\jdk-8"; "Name" = "Oracle JDK 8"; "LTS" = $true}
    "11" = @{"Path" = "$JDK_BASE_PATH\jdk-11"; "Name" = "Oracle JDK 11"; "LTS" = $true}
    "17" = @{"Path" = "$JDK_BASE_PATH\jdk-17"; "Name" = "Oracle JDK 17"; "LTS" = $true}
    "21" = @{"Path" = "$JDK_BASE_PATH\jdk-21"; "Name" = "Oracle JDK 21"; "LTS" = $true}
}

# 日志函数
function Write-Log {
    param([string]$Message,[string]$Level = "INFO")
    $timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
    $logEntry = "[$timestamp] [$Level] $Message"
    Add-Content -Path $LOG_FILE -Value $logEntry
    switch($Level) {
        "ERROR" { Write-Host $logEntry -ForegroundColor Red }
        "WARN" { Write-Host $logEntry -ForegroundColor Yellow }
        "SUCCESS" { Write-Host $logEntry -ForegroundColor Green }
        default { Write-Host $logEntry -ForegroundColor White }
    }
}

# 检查 JDK 是否已安装
function Test-JDKInstallation {
    param([string]$JDKPath)
    return (Test-Path "$JDKPath\bin\java.exe") -and (Test-Path "$JDKPath\bin\javac.exe")
}

# 获取 JDK 版本信息
function Get-JDKVersion {
    param([string]$JDKPath)
    if (Test-JDKInstallation -JDKPath $JDKPath) {
        try {
            $versionOutput = & "$JDKPath\bin\java.exe" -version 2>&1
            $versionLine = $versionOutput | Select-String "version" | Select-Object -First 1
            return $versionLine.ToString()
        } catch {
            return "Unknown version"
        }
    }
    return "Not installed"
}

# 列出所有 JDK 版本
function Show-JDKList {
    Write-Host "`n═══ Installed JDK Versions ═══" -ForegroundColor Cyan
    $installedCount = 0
    foreach ($version in $JDK_VERSIONS.Keys | Sort-Object) {
        $jdkInfo = $JDK_VERSIONS[$version]
        $isInstalled = Test-JDKInstallation -JDKPath $jdkInfo.Path
        if ($isInstalled) {
            $versionInfo = Get-JDKVersion -JDKPath $jdkInfo.Path
            $ltsTag = if ($jdkInfo.LTS) {" (LTS)"} else {""}
            Write-Host "✅ JDK $version$ltsTag - $($jdkInfo.Path)" -ForegroundColor Green
            Write-Host " $versionInfo" -ForegroundColor Gray
            $installedCount++
        } else {
            Write-Host "❌ JDK $version - Not installed" -ForegroundColor Red
        }
    }
    Write-Host "`nTotal installed: $installedCount" -ForegroundColor Yellow
}

# 显示当前 JDK 状态
function Show-CurrentJDK {
    Write-Host "`n═══ Current JDK Status ═══" -ForegroundColor Cyan
    if ($env:JAVA_HOME) {
        Write-Host "JAVA_HOME: $env:JAVA_HOME" -ForegroundColor Green
        if (Test-JDKInstallation -JDKPath $env:JAVA_HOME) {
            $versionInfo = Get-JDKVersion -JDKPath $env:JAVA_HOME
            Write-Host "Version: $versionInfo" -ForegroundColor Green
        } else {
            Write-Host "❌ JAVA_HOME points to invalid JDK installation" -ForegroundColor Red
        }
    } else {
        Write-Host "❌ JAVA_HOME is not set" -ForegroundColor Red
    }
    # 检查 PATH 中的 Java
    $javaInPath = Get-Command java -ErrorAction SilentlyContinue
    if ($javaInPath) {
        Write-Host "Java in PATH: $($javaInPath.Source)" -ForegroundColor Green
    } else {
        Write-Host "❌ Java not found in PATH" -ForegroundColor Red
    }
}

# 切换 JDK 版本
function Switch-JDK {
    param([string]$TargetVersion)
    if (-not $JDK_VERSIONS.ContainsKey($TargetVersion)) {
        Write-Log "Invalid JDK version: $TargetVersion" "ERROR"
        Write-Host "Available versions: $($JDK_VERSIONS.Keys -join', ')" -ForegroundColor Yellow
        return $false
    }
    $jdkInfo = $JDK_VERSIONS[$TargetVersion]
    if (-not (Test-JDKInstallation -JDKPath $jdkInfo.Path)) {
        Write-Log "JDK $TargetVersion is not installed at $($jdkInfo.Path)" "ERROR"
        return $false
    }
    # 设置环境变量
    $env:JAVA_HOME = $jdkInfo.Path
    $env:PATH = "$( $jdkInfo.Path )\bin;" + ($env:PATH -replace [regex]::Escape("$( $jdkInfo.Path )\bin;"), "")
    Write-Log "Switched to JDK $TargetVersion at $($jdkInfo.Path)" "SUCCESS"
    # 显示版本信息
    & "$( $jdkInfo.Path )\bin\java.exe" -version
    # 保存当前配置
    Save-Configuration -CurrentVersion $TargetVersion
    return $true
}

# 永久设置 JAVA_HOME
function Set-PermanentJavaHome {
    param([string]$JDKPath)
    try {
        # 尝试设置系统环境变量
        [Environment]::SetEnvironmentVariable("JAVA_HOME", $JDKPath, "Machine")
        Write-Log "JAVA_HOME set permanently for all users" "SUCCESS"
        return $true
    } catch {
        try {
            # 设置用户环境变量
            [Environment]::SetEnvironmentVariable("JAVA_HOME", $JDKPath, "User")
            Write-Log "JAVA_HOME set permanently for current user" "SUCCESS"
            return $true
        } catch {
            Write-Log "Failed to set JAVA_HOME permanently: $($_.Exception.Message)" "ERROR"
            return $false
        }
    }
}

# 保存配置
function Save-Configuration {
    param([string]$CurrentVersion)
    $config = @{"LastUsed" = $CurrentVersion; "LastUpdate" = Get-Date -Format "yyyy-MM-dd HH:mm:ss"; "JDKBasePath" = $JDK_BASE_PATH}
    $config | ConvertTo-Json | Set-Content -Path $CONFIG_FILE
}

# 加载配置
function Load-Configuration {
    if (Test-Path $CONFIG_FILE) {
        try {
            return Get-Content -Path $CONFIG_FILE | ConvertFrom-Json
        } catch {
            Write-Log "Failed to load configuration: $($_.Exception.Message)" "WARN"
        }
    }
    return $null
}

# 自动检测已安装的 JDK
function Find-InstalledJDKs {
    Write-Host "`n🔍 Scanning for JDK installations..." -ForegroundColor Cyan
    $commonPaths = @("C:\Program Files\Java", "C:\Program Files (x86)\Java", "C:\Java", "C:\jdk*", "$env:USERPROFILE\Java")
    $foundJDKs = @()
    foreach ($basePath in $commonPaths) {
        if (Test-Path $basePath) {
            $jdkDirs = Get-ChildItem -Path $basePath -Directory | Where-Object { $_.Name -match "jdk" }
            foreach ($dir in $jdkDirs) {
                if (Test-JDKInstallation -JDKPath $dir.FullName) {
                    $version = Get-JDKVersion -JDKPath $dir.FullName
                    $foundJDKs += @{"Path" = $dir.FullName; "Version" = $version; "Name" = $dir.Name}
                }
            }
        }
    }
    if ($foundJDKs.Count -gt 0) {
        Write-Host "`n✅ Found $($foundJDKs.Count) JDK installation(s):" -ForegroundColor Green
        foreach ($jdk in $foundJDKs) {
            Write-Host " $($jdk.Name) - $($jdk.Path)" -ForegroundColor White
            Write-Host " $($jdk.Version)" -ForegroundColor Gray
        }
    } else {
        Write-Host "`n❌ No JDK installations found" -ForegroundColor Red
    }
    return $foundJDKs
}

# 显示帮助信息
function Show-Help {
    Write-Host @"
JDK Manager for Windows - PowerShell Edition
USAGE: .\JDKManager.ps1 [OPTIONS]
OPTIONS:
-Action <action> Action to perform (menu, switch, list, current, scan)
-Version <version> JDK version to switch to (8, 11, 17, 21)
-List List all configured JDK versions
-Current Show current JDK status
-Install Install JDK (interactive)
-Remove Remove JDK configuration
-Permanent Set JAVA_HOME permanently
-Help Show this help message
EXAMPLES:
.\JDKManager.ps1 # Show interactive menu
.\JDKManager.ps1 -Action switch -Version 17 # Switch to JDK 17
.\JDKManager.ps1 -List # List all JDK versions
.\JDKManager.ps1 -Current # Show current JDK
.\JDKManager.ps1 -Action scan # Scan for JDK installations
CONFIGURATION:
Config file: $CONFIG_FILE
Log file: $LOG_FILE
JDK base path: $JDK_BASE_PATH
"@ -ForegroundColor Green
}

# 交互式菜单
function Show-InteractiveMenu {
    do {
        Clear-Host
        Write-Host "╔══════════════════════════════════════╗" -ForegroundColor Cyan
        Write-Host "║ JDK Version Manager ║" -ForegroundColor Cyan
        Write-Host "║ PowerShell Edition ║" -ForegroundColor Cyan
        Write-Host "╚══════════════════════════════════════╝" -ForegroundColor Cyan
        Write-Host ""
        # 显示当前状态
        Show-CurrentJDK
        Write-Host "`n📋 Available Actions:" -ForegroundColor Yellow
        Write-Host "[1] Switch JDK Version" -ForegroundColor White
        Write-Host "[2] List All JDK Versions" -ForegroundColor White
        Write-Host "[3] Scan for JDK Installations" -ForegroundColor White
        Write-Host "[4] Set JAVA_HOME Permanently" -ForegroundColor White
        Write-Host "[5] View Switch History" -ForegroundColor White
        Write-Host "[6] Configuration Management" -ForegroundColor White
        Write-Host "[7] Help" -ForegroundColor White
        Write-Host "[0] Exit" -ForegroundColor Red
        Write-Host ""
        $choice = Read-Host "Select option (0-7)"
        switch ($choice) {
            "1" {
                Write-Host "`nAvailable JDK versions:" -ForegroundColor Yellow
                foreach ($version in $JDK_VERSIONS.Keys | Sort-Object) {
                    $isInstalled = Test-JDKInstallation -JDKPath $JDK_VERSIONS[$version].Path
                    $status = if ($isInstalled) {"✅"} else {"❌"}
                    Write-Host "$status JDK $version" -ForegroundColor White
                }
                $targetVersion = Read-Host "`nEnter JDK version to switch to"
                if ($targetVersion) {
                    Switch-JDK -TargetVersion $targetVersion
                    Read-Host "`nPress Enter to continue"
                }
            }
            "2" {
                Show-JDKList
                Read-Host "`nPress Enter to continue"
            }
            "3" {
                Find-InstalledJDKs
                Read-Host "`nPress Enter to continue"
            }
            "4" {
                if ($env:JAVA_HOME) {
                    Write-Host "`nCurrent JAVA_HOME: $env:JAVA_HOME" -ForegroundColor Green
                    $confirm = Read-Host "Set this as permanent JAVA_HOME? (y/n)"
                    if ($confirm -eq "y" -or $confirm -eq "Y") {
                        Set-PermanentJavaHome -JDKPath $env:JAVA_HOME
                    }
                } else {
                    Write-Host "`n❌ JAVA_HOME is not set. Please switch to a JDK version first." -ForegroundColor Red
                }
                Read-Host "`nPress Enter to continue"
            }
            "5" {
                if (Test-Path $LOG_FILE) {
                    Write-Host "`n═══ Switch History ═══" -ForegroundColor Cyan
                    Get-Content $LOG_FILE | Select-Object -Last 20
                } else {
                    Write-Host "`n❌ No history found" -ForegroundColor Red
                }
                Read-Host "`nPress Enter to continue"
            }
            "6" {
                Write-Host "`n═══ Configuration ═══" -ForegroundColor Cyan
                Write-Host "Config file: $CONFIG_FILE" -ForegroundColor White
                Write-Host "Log file: $LOG_FILE" -ForegroundColor White
                Write-Host "JDK base path: $JDK_BASE_PATH" -ForegroundColor White
                $config = Load-Configuration
                if ($config) {
                    Write-Host "Last used: JDK $($config.LastUsed)" -ForegroundColor Green
                    Write-Host "Last update: $($config.LastUpdate)" -ForegroundColor Green
                }
                Read-Host "`nPress Enter to continue"
            }
            "7" {
                Show-Help
                Read-Host "`nPress Enter to continue"
            }
            "0" {
                Write-Host "`n👋 Goodbye!" -ForegroundColor Green
                return
            }
            default {
                Write-Host "`n❌ Invalid option. Please try again." -ForegroundColor Red
                Start-Sleep 2
            }
        }
    } while ($true)
}

# 主执行逻辑
function Main {
    # 创建必要的目录
    if (-not (Test-Path $JDK_BASE_PATH)) {
        New-Item -ItemType Directory -Path $JDK_BASE_PATH -Force | Out-Null
    }
    # 处理命令行参数
    if ($Help) {
        Show-Help
        return
    }
    if ($List) {
        Show-JDKList
        return
    }
    if ($Current) {
        Show-CurrentJDK
        return
    }
    # 根据 Action 参数执行相应操作
    switch ($Action.ToLower()) {
        "switch" {
            if ($Version) {
                Switch-JDK -TargetVersion $Version
            } else {
                Write-Host "❌ Version parameter required for switch action" -ForegroundColor Red
                Show-Help
            }
        }
        "list" { Show-JDKList }
        "current" { Show-CurrentJDK }
        "scan" { Find-InstalledJDKs }
        "menu" { Show-InteractiveMenu }
        default { Show-InteractiveMenu }
    }
}

# 执行主函数
Main

# Microsoft.PowerShell_profile.ps1
# 添加到 $PROFILE 文件中
# 💡 实用技巧：将这些函数添加到 PowerShell 配置文件，实现全局 JDK 管理命令

# JDK 管理函数
function jdk {
    param([string]$Version = "",[switch]$List,[switch]$Current)
    $JDK_MANAGER_SCRIPT = "$env:USERPROFILE\Scripts\JDKManager.ps1"
    if ($List) {
        & $JDK_MANAGER_SCRIPT -List
    } elseif ($Current) {
        & $JDK_MANAGER_SCRIPT -Current
    } elseif ($Version) {
        & $JDK_MANAGER_SCRIPT -Action switch -Version $Version
    } else {
        & $JDK_MANAGER_SCRIPT
    }
}

# JDK 快捷切换函数
function jdk8 { jdk 8 }
function jdk11 { jdk 11 }
function jdk17 { jdk 17 }
function jdk21 { jdk 21 }

# 启动时显示当前 JDK 状态
if ($env:JAVA_HOME) {
    Write-Host "Current JDK: " -NoNewline -ForegroundColor Yellow
    Write-Host $env:JAVA_HOME -ForegroundColor Green
}

# 自动补全
Register-ArgumentCompleter -CommandName jdk -ParameterName Version -ScriptBlock {
    param($commandName,$parameterName,$wordToComplete,$commandAst,$fakeBoundParameters)
    $versions = @('8','11','17','21')
    $versions | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object {
        [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_)
    }
}

# 安装 scoop (包管理器)
# 💡 实用技巧：Scoop 是 Windows 下的包管理器，类似于 Linux 的 apt 或 yum
Set-ExecutionPolicy RemoteSigned -Scope CurrentUser
iwr -useb get.scoop.sh | iex
# 安装 jenv
scoop bucket add java
scoop install jenv
# 添加 JDK 版本到 jenv
jenv add C:\Java\jdk-8
jenv add C:\Java\jdk-11
jenv add C:\Java\jdk-17
jenv add C:\Java\jdk-21
# 查看可用版本
jenv versions
# 设置全局 JDK 版本
jenv global 17
# 设置项目本地 JDK 版本
cd your-project
jenv local 11
# 查看当前版本
jenv version

# 在 WSL 中安装 SDKMAN
curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"
# 列出可用的 Java 版本
sdk list java
# 安装多个 JDK 版本
sdk install java8.0.392-tem
sdk install java11.0.21-tem
sdk install java17.0.9-tem
sdk install java21.0.1-tem
# 切换 JDK 版本
sdk use java17.0.9-tem
# 设置默认版本
sdk default java17.0.9-tem
# 查看当前版本
sdk current java

# 安装 Chocolatey
Set-ExecutionPolicy Bypass -Scope Process-Force
[System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072
iex((New-Object System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))
# 搜索可用的 JDK 包
choco search jdk
# 安装多个 JDK 版本
choco install openjdk8 -y
choco install openjdk11 -y
choco install openjdk17 -y
choco install openjdk21 -y
# 列出已安装的 JDK
choco list jdk -l
# 创建 JDK 切换脚本
@echo off
echo Available JDK versions:
echo 1. OpenJDK 8
echo 2. OpenJDK 11
echo 3. OpenJDK 17
echo 4. OpenJDK 21
set/p choice="Select JDK version: "
if "%choice%"=="1"(
    set JAVA_HOME=C:\Program Files\Eclipse Adoptium\jdk-8.0.392.8-hotspot
) elseif "%choice%"=="2"(
    set JAVA_HOME=C:\Program Files\Eclipse Adoptium\jdk-11.0.21.9-hotspot
) elseif "%choice%"=="3"(
    set JAVA_HOME=C:\Program Files\Eclipse Adoptium\jdk-17.0.9.9-hotspot
) elseif "%choice%"=="4"(
    set JAVA_HOME=C:\Program Files\Eclipse Adoptium\jdk-21.0.1.12-hotspot
)
set PATH=%JAVA_HOME%\bin;%PATH%
echo Switched to: %JAVA_HOME%
java -version

1. 打开 File → Project Structure
2. 在 Platform Settings → SDKs 中添加 JDK
3. 点击 + 号，选择 Add JDK
4. 浏览到 JDK 安装目录，例如：C:\Java\jdk-17
5. 重命名为便于识别的名称，如 "JDK 17"
6. 重复步骤添加其他 JDK 版本

1. 打开 File → Project Structure
2. 在 Project Settings → Project 中
3. 设置 Project SDK 为所需的 JDK 版本
4. 设置 Project language level 对应 JDK 版本
5. 点击 Apply 和 OK 保存设置

1. 打开 File → Project Structure
2. 在 Project Settings → Modules 中
3. 选择要配置的模块
4. 在 Dependencies 选项卡中
5. 设置 Module SDK 为特定 JDK 版本

1. 打开 Window → Preferences
2. 导航到 Java → Installed JREs
3. 点击 Add 按钮
4. 选择 Standard VM，点击 Next
5. 在 JRE home 中浏览到 JDK 目录
6. JRE name 设置为识别名称，如 "JDK 17"
7. 点击 Finish 完成添加

1. 在 Installed JREs 列表中
2. 勾选要设为默认的 JDK 版本
3. 点击 Apply and Close

1. 右键项目 → Properties
2. 选择 Java Build Path
3. 在 Libraries 选项卡中
4. 展开 Modulepath 或 Classpath
5. 选择 JRE System Library，点击 Remove
6. 点击 Add Library → JRE System Library
7. 选择 Workspace default JRE 或 Alternate JRE
8. 如果选择 Alternate JRE，选择所需的 JDK 版本
9. 点击 Finish 和 Apply and Close

// settings.json
// 🔧 重点提示：VS Code 的 Java 扩展配置，支持多 JDK 版本管理
{
    "java.configuration.runtimes": [
        {"name": "JavaSE-1.8", "path": "C:\\Java\\jdk-8", "default": false},
        {"name": "JavaSE-11", "path": "C:\\Java\\jdk-11", "default": false},
        {"name": "JavaSE-17", "path": "C:\\Java\\jdk-17", "default": true},
        {"name": "JavaSE-21", "path": "C:\\Java\\jdk-21", "default": false}
    ],
    "java.home": "C:\\Java\\jdk-17",
    "java.compile.nullAnalysis.mode": "automatic"
}

{
    "java.configuration.runtimes": [
        {"name": "JavaSE-11", "path": "C:\\Java\\jdk-11", "default": true}
    ],
    "java.home": "C:\\Java\\jdk-11"
}

echo %JAVA_HOME% # 显示空白或旧路径

# 1. 检查环境变量设置
echo %JAVA_HOME%
# 2. 重新打开命令提示符窗口
# 3. 或者刷新环境变量
set JAVA_HOME=C:\Java\jdk-17
# 4. 验证设置
echo %JAVA_HOME%
java -version

where java # 显示多个 Java 路径或错误的路径

# 1. 查看完整 PATH
echo %PATH%
# 2. 清理 PATH 中的重复 Java 路径
# 手动编辑系统环境变量，删除重复或错误的路径
# 3. 确保%JAVA_HOME%\bin 在最前面
# PATH 应该类似：%JAVA_HOME%\bin;C:\Windows\System32;...

访问被拒绝，无法修改系统环境变量

# 1. 以管理员身份运行 PowerShell
# 2. 设置系统环境变量
[Environment]::SetEnvironmentVariable("JAVA_HOME", "C:\Java\jdk-17", "Machine")
# 3. 或者设置用户环境变量
[Environment]::SetEnvironmentVariable("JAVA_HOME", "C:\Java\jdk-17", "User")

java -version # 显示的版本与 JAVA_HOME 不匹配

# 1. 检查 JAVA_HOME 设置
echo %JAVA_HOME%
# 2. 直接运行 JAVA_HOME 中的 java
%JAVA_HOME%\bin\java -version
# 3. 检查 PATH 中 java 的位置
where java
# 4. 确保 PATH 中%JAVA_HOME%\bin 在最前面

1. 重启 IDE
2. 清理 IDE 缓存
3. 重新配置 JDK 路径
4. 检查 JDK 安装完整性

<!-- pom.xml 中指定 JDK 版本 -->
<!-- 🚀 实用技巧：在 pom.xml 中明确指定 JDK 版本，避免环境差异导致的构建问题 -->
<properties>
    <maven.compiler.source>17</maven.compiler.source>
    <maven.compiler.target>17</maven.compiler.target>
    <java.version>17</java.version>
</properties>
<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-compiler-plugin</artifactId>
            <version>3.11.0</version>
            <configuration>
                <source>17</source>
                <target>17</target>
            </configuration>
        </plugin>
    </plugins>
</build>

// build.gradle
java {
    sourceCompatibility = JavaVersion.VERSION_17
    targetCompatibility = JavaVersion.VERSION_17
}

// gradle.properties
org.gradle.java.home=C:\\Java\\jdk-17

C:\Java\
 ├── jdk-8\ # JDK 8 LTS
 ├── jdk-11\ # JDK 11 LTS
 ├── jdk-17\ # JDK 17 LTS (主力)
 ├── jdk-21\ # JDK 21 LTS (新版)
 ├── current -> jdk-17\ # 当前版本符号链接
 └── tools\ # Java 相关工具
     ├── maven\
     ├── gradle\
     └── scripts\ # 切换脚本

场景	推荐版本	理由
新项目开发	JDK 17	当前主流 LTS 版本，特性丰富
企业级应用	JDK 11	稳定的 LTS 版本，广泛支持
维护旧项目	JDK 8	兼容性最好，使用最广泛
尝鲜新特性	JDK 21	最新 LTS 版本，新特性体验
Android 开发	JDK 8/11	Android Studio 推荐版本

REM auto_switch.bat - 放在项目根目录
REM 🔧 重点提示：智能检测项目类型，自动切换到项目所需的 JDK 版本
@echo off
REM 检查项目类型和 JDK 要求
if exist "pom.xml" (
    REM Maven 项目，检查 pom.xml 中的 Java 版本
    findstr /C:"<java.version>" pom.xml > nul
    if not errorlevel 1 (
        for /f "tokens=2 delims=<>" %%a in ('findstr /C:"<java.version>" pom.xml') do (
            set PROJECT_JAVA_VERSION=%%a
        )
    )
) else if exist "build.gradle" (
    REM Gradle 项目，检查 build.gradle 中的 Java 版本
    findstr /C:"sourceCompatibility" build.gradle > nul
    if not errorlevel 1 (
        for /f "tokens=3" %%a in ('findstr /C:"sourceCompatibility" build.gradle') do (
            set PROJECT_JAVA_VERSION=%%a
        )
    )
)
REM 根据项目要求切换 JDK
if defined PROJECT_JAVA_VERSION (
    echo Detected project Java version: %PROJECT_JAVA_VERSION%
    call switch_jdk.bat %PROJECT_JAVA_VERSION%
) else (
    echo No specific Java version detected, using default
)
REM 启动开发环境
cmd /k

#!/bin/sh
# .git/hooks/post-checkout
# Git 切换分支后自动切换 JDK 版本
# 🚀 实用技巧：Git Hook 自动化，每次切换分支自动设置对应的 JDK 版本
if [-f .jdkversion ]; then
    JDK_VERSION=$(cat .jdkversion)
    echo "Switching to JDK $JDK_VERSION for this project"
    # Windows 环境调用批处理脚本
    if ["$OS"="Windows_NT"]; then
        cmd //c "switch_jdk.bat $JDK_VERSION"
    fi
fi

# JDK Configuration for Project
[project]
name=MyProject
required_jdk=17
fallback_jdk=11
[paths]
windows=C:\Java\jdk-17
linux=/usr/lib/jvm/java-17-openjdk
macos=/usr/local/java/jdk-17
[maven]
java.version=17
maven.compiler.source=17
maven.compiler.target=17

# 项目名称
## JDK 要求
本项目需要 **JDK 17** 或更高版本。
### Windows 环境 JDK 配置
1. 下载并安装 JDK 17：
   - Oracle JDK: https://www.oracle.com/java/technologies/downloads/
   - OpenJDK: https://adoptium.net/
2. 设置环境变量：
```cmd
set JAVA_HOME=C:\Java\jdk-17
set PATH=%JAVA_HOME%\bin;%PATH%

java -version
javac -version

# 切换到 JDK 17
switch_jdk.bat 17
# 验证版本
java -version


#### 9.5 性能优化建议

##### 9.5.1 JVM 参数优化

根据不同 JDK 版本优化 JVM 参数：

```batch
REM JDK 8 优化参数
set JAVA_OPTS=-Xms2g -Xmx4g -XX:+UseG1GC -XX:+UseStringDeduplication
REM JDK 11 优化参数
set JAVA_OPTS=-Xms2g -Xmx4g -XX:+UseG1GC -XX:+UnlockExperimentalVMOptions -XX:+UseJVMCICompiler
REM JDK 17 优化参数
set JAVA_OPTS=-Xms2g -Xmx4g -XX:+UseZGC -XX:+UnlockExperimentalVMOptions

<!-- Maven 并行构建 -->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <configuration>
        <fork>true</fork>
        <meminitial>128m</meminitial>
        <maxmem>512m</maxmem>
    </configuration>
</plugin>

Windows 环境下 Java 多版本管理与切换指南

🎯 前言

1. JDK 版本管理方案对比

1.1 方案概览

1.2 选择建议

2. 准备工作：安装多个 JDK 版本

2.1 JDK 版本选择策略

2.2 JDK 安装规划

2.3 下载和安装 JDK

2.3.1 Oracle JDK 安装

2.3.2 OpenJDK 安装

2.3.3 手动下载安装

2.4 安装验证

3. 方案一：手动环境变量管理

3.1 理解 Windows 环境变量

3.2 图形界面配置步骤

3.2.1 打开环境变量设置

3.2.2 配置 JAVA_HOME

3.2.3 配置 PATH 变量

3.3 命令行验证

3.4 切换 JDK 版本

3.5 用户变量 vs 系统变量

4. 方案二：批处理脚本快速切换

4.1 基础切换脚本

4.2 高级批处理脚本

4.3 创建桌面快捷方式

4.4 项目级 JDK 配置

5. 方案三：PowerShell 高级脚本

5.1 PowerShell JDK 管理器

5.2 PowerShell 配置文件集成

6. 方案四：专业工具管理

6.1 使用 jEnv (Windows 版本)

6.2 使用 SDKMAN (Windows Subsystem for Linux)

6.3 使用 Chocolatey 管理 JDK

7. IDE 中的 JDK 配置

7.1 IntelliJ IDEA 配置

7.1.1 全局 JDK 配置

7.1.2 项目级 JDK 配置

7.1.3 模块级 JDK 配置

7.2 Eclipse 配置

7.2.1 添加 JDK 到 Eclipse

7.2.2 设置默认 JDK

7.2.3 项目特定 JDK 配置

7.3 Visual Studio Code 配置

7.3.1 安装 Java 扩展包

7.3.2 项目级配置

8. 常见问题与解决方案

8.1 环境变量问题

8.1.1 JAVA_HOME 未生效

8.1.2 PATH 中 Java 路径冲突

8.2 权限问题

8.2.1 无法设置系统环境变量

8.3 版本识别问题

8.3.1 Java 版本显示不正确

8.4 IDE 识别问题

8.4.1 IDE 无法识别新 JDK

8.5 构建工具问题

8.5.1 Maven 使用错误的 JDK 版本

8.5.2 Gradle 使用错误的 JDK 版本

9. 最佳实践与建议

9.1 目录结构规划

9.2 版本选择策略

9.3 自动化建议

9.3.1 项目自动切换脚本

9.3.2 Git Hook 集成

9.4 团队协作建议

9.4.1 统一配置文件

9.4.2 README 文档模板

快速切换 JDK 版本

9.5.2 构建性能优化

💡 总结

🎯 核心技能

🚀 最佳实践

🔧 工具推荐

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具