Gradle不认识Java 10+；方法

因此，我尝试使用方法

List.copyOf

和

collector.toUnmodifiableList

，但gradle无法识别这两种方法，因此编译失败，但在IDE中可以识别它们

我检查了一切，一切都在使用Java11；项目字节码、sdk、gradle jvm。。。我还尝试升级Gradle（版本5.6.2），但没有解决问题。我正在使用OpenJDK运行Java11.0.4

使用这两种方法的示例：

返回getGuilds（）.stream（）
.filter（guild->users.stream（）.allMatch（guild:：isMember））
.collect（Collectors.toUnmodifiableList（））；
return List.copyOf（bucket.values（））//这两种方法都无法识别

gradle正在抛出以下错误：

            return List.copyOf(buckets.values());
                       ^
  symbol:   method copyOf(Collection<IBucket>)
  location: interface List

return List.copyOf（bucket.values（））；
^
符号：复制方法（集合）
位置：接口列表

以下是我的gradle文件的内容：

import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
import com.jfrog.bintray.gradle.BintrayExtension
import com.jfrog.bintray.gradle.tasks.BintrayUploadTask
import org.apache.tools.ant.filters.ReplaceTokens
import java.util.*

plugins {
    signing
    `java-library`
    `maven-publish`

    id("com.jfrog.bintray") version "1.8.4"
    id("com.github.ben-manes.versions") version "0.24.0"
    id("com.github.johnrengelman.shadow") version "5.1.0"
}

val versionObj = Version(major = "2", minor = "1", revision = "6")

project.group = "me.canelex"
project.version = "$versionObj"
val archivesBaseName = "JDA"

java {
    sourceCompatibility = JavaVersion.VERSION_11
    targetCompatibility = JavaVersion.VERSION_11
}

configure<SourceSetContainer> {
    register("examples") {
        java.srcDir("src/examples/java")
        compileClasspath += sourceSets["main"].output
        runtimeClasspath += sourceSets["main"].output
    }
}

repositories {
    jcenter()
}

dependencies {
    /* ABI dependencies */

    //Code safety
    api("com.google.code.findbugs:jsr305:3.0.2")
    api("org.jetbrains:annotations:17.0.0")

    //Logger
    api("org.slf4j:slf4j-api:2.0.0-alpha0")

    //Web Connection Support
    api("com.neovisionaries:nv-websocket-client:2.9")
    api("com.squareup.okhttp3:okhttp:4.1.1")

    /* Internal dependencies */

    //General Utility
    implementation("org.apache.commons:commons-collections4:4.4")
    implementation("net.sf.trove4j:trove4j:3.0.3")
    implementation("com.fasterxml.jackson.core:jackson-databind:2.10.0.pr2")

    //Sets the dependencies for the examples
    configurations.asMap["examplesCompile"] = configurations["apiElements"]
    configurations.asMap["examplesRuntime"] = configurations["implementation"]

    testImplementation("org.junit.jupiter:junit-jupiter:5.5.1")
}

val bintrayUpload: BintrayUploadTask by tasks
val compileJava: JavaCompile by tasks
val shadowJar: ShadowJar by tasks
val javadoc: Javadoc by tasks
val jar: Jar by tasks
val build: Task by tasks
val test: Test by tasks
val check: Task by tasks

shadowJar.classifier = ""

val sourcesForRelease = task<Copy>("sourcesForRelease") {
    from("src/main/java") {
        include("**/JDAInfo.java")
        val tokens = mapOf(
                "versionMajor" to versionObj.major,
                "versionMinor" to versionObj.minor,
                "versionRevision" to versionObj.revision
        )
        filter<ReplaceTokens>(mapOf("tokens" to tokens))
    }
    into("build/filteredSrc")

    includeEmptyDirs = false
}

val generateJavaSources = task<SourceTask>("generateJavaSources") {
    val javaSources = sourceSets["main"].allJava.filter {
        it.name != "JDAInfo.java"
    }.asFileTree

    source = javaSources + fileTree(sourcesForRelease.destinationDir)

    dependsOn(sourcesForRelease)
}

val sourcesJar = task<Jar>("sourcesJar") {
    classifier = "sources"
    from("src/main/java") {
        exclude("**/JDAInfo.java")
    }
    from(sourcesForRelease.destinationDir)

    dependsOn(sourcesForRelease)
}

val javadocJar = task<Jar>("javadocJar") {
    dependsOn(javadoc)
    classifier = "javadoc"
    from(javadoc.destinationDir)
}

tasks.withType<JavaCompile> {
    val arguments = mutableListOf("-Xlint:deprecation", "-Xlint:unchecked")
    options.encoding = "UTF-8"
    options.isIncremental = true
    if (JavaVersion.current().isJava9Compatible) doFirst {
        arguments += "--release"
        arguments += "8"
    }
    doFirst {
        options.compilerArgs = arguments
    }
}

compileJava.apply {
    source = generateJavaSources.source
    dependsOn(generateJavaSources)
}

jar.apply {
    baseName = project.name
    manifest.attributes(mapOf(
            "Implementation-Version" to version,
            "Automatic-Module-Name" to "me.canelex.jda"))
}

javadoc.apply {
    isFailOnError = false
    options.memberLevel = JavadocMemberLevel.PUBLIC
    options.encoding = "UTF-8"

    if (options is StandardJavadocDocletOptions) {
        val opt = options as StandardJavadocDocletOptions
        opt.author()
        opt.tags("incubating:a:Incubating:")
        opt.links(
                "https://docs.oracle.com/javase/8/docs/api/",
                "https://takahikokawasaki.github.io/nv-websocket-client/",
                "https://square.github.io/okhttp/3.x/okhttp/")
        if (JavaVersion.current().isJava9Compatible) {
            opt.addBooleanOption("html5", true)
            opt.addStringOption("-release", "8")
        }
        if (JavaVersion.current().isJava11Compatible) {
            opt.addBooleanOption("-no-module-directories", true)
        }
    }

    //jda internals
    exclude("me/canelex/jda/internal")
}

build.apply {
    dependsOn(jar)
    dependsOn(javadocJar)
    dependsOn(sourcesJar)
    dependsOn(shadowJar)

    javadocJar.mustRunAfter(jar)
    sourcesJar.mustRunAfter(javadocJar)
    shadowJar.mustRunAfter(sourcesJar)
}

bintrayUpload.apply {
    dependsOn(build)
}

test.apply {
    useJUnitPlatform()
    failFast = true
}

publishing {
    publications {
        register("BintrayRelease", MavenPublication::class) {
            from(components["java"])

            artifactId = archivesBaseName
            groupId = project.group as String
            version = project.version as String

            artifact(javadocJar)
            artifact(sourcesJar)
        }
    }
}

class Version(
        val major: String,
        val minor: String,
        val revision: String) {
    override fun toString() = "$major.$minor.$revision"
}

import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
导入com.jfrog.bintray.gradle.BintrayExtension
导入com.jfrog.bintray.gradle.tasks.BintrayUploadTask
导入org.apache.tools.ant.filters.replaceToken
导入java.util*
插件{
签字
`java库`
`马文出版社`
id（“com.jfrog.bintray”）版本“1.8.4”
id（“com.github.ben manes.versions”）版本“0.24.0”
id（“com.github.johnrengelman.shadow”）版本“5.1.0”
}
val versionObj=版本（主要为“2”，次要为“1”，修订为“6”）
project.group=“me.canelex”
project.version=“$versionObj”
val archivesBaseName=“JDA”
爪哇{
sourceCompatibility=JavaVersion.VERSION\u 11
targetCompatibility=JavaVersion.VERSION_11
}
配置{
登记册（“示例”）{
srcDir（“src/examples/java”）
compileClasspath+=sourceSets[“main”]。输出
runtimeClasspath+=sourceSets[“main”]。输出
}
}
存储库{
jcenter（）
}
依赖关系{
/*ABI依赖项*/
//代码安全
api（“com.google.code.findbugs:jsr305:3.0.2”）
api（“org.jetbrains:annotations:17.0.0”）
//记录器
api（“org.slf4j:slf4j api:2.0.0-alpha0”）
//网络连接支持
api（“com.neovisioniers:NVWebSocket客户端：2.9”）
api（“com.squareup.okhttp3:okhttp:4.1.1”）
/*内部依赖关系*/
//一般用途
实现（“org.apache.commons:commons-collections4:4.4”）
实现（“net.sf.trove4j:trove4j:3.0.3”）
实现（“com.fasterxml.jackson.core:jackson-databind:2.10.0.pr2”）
//设置示例的依赖项
configurations.asMap[“examplesCompile”]=配置[“apilements”]
configurations.asMap[“examplesRuntime”]=配置[“实现”]
测试实现（“org.junit.jupiter:junit-jupiter:5.5.1”）
}
val bintrayUpload：按任务分类的bintrayUpload任务
val compileJava:javacompilebytasks
val shadowJar：按任务划分的shadowJar
val javadoc：按任务划分的javadoc
val-jar:jar-by-tasks
val构建：逐个任务
val测试：按任务进行测试
val检查：逐个任务
shadowJar.classifier=“”
val sourcesforelease=任务（“sourcesforelease”）{
from（“src/main/java”）{
包括（“**/JDAInfo.java”）
val tokens=mapOf(
“versionMajor”到versionObj.major，
“versionMinor”到versionObj.minor，
“versionRevision”至versionObj.revision
)
过滤器（将（“令牌”映射到令牌））
}
进入（“构建/筛选数据库”）
includeEmptyDirs=假
}
val generateJavaSources=任务（“generateJavaSources”）{
val javaSources=sourceset[“main”].allJava.filter{
it.name！=“JDAInfo.java”
}.asFileTree
source=javaSources+fileTree（sourcesforelease.destinationDir）
dependsOn（来源再租赁）
}
val sourcesJar=任务（“sourcesJar”）{
分类器=“源”
from（“src/main/java”）{
排除（“**/JDAInfo.java”）
}
from（sourcesforelease.destinationDir）
dependsOn（来源再租赁）
}
val javadocJar=task（“javadocJar”）{
dependsOn（javadoc）
分类器=“javadoc”
from（javadoc.destinationDir）
}
tasks.withType{
val arguments=mutableListOf（“-Xlint:deprecation”，“-Xlint:unchecked”）
options.encoding=“UTF-8”
options.isIncremental=true
if（JavaVersion.current（）.isJava9Compatible）doFirst{
参数+=“--release”
参数+=“8”
}
首先{
options.compilerArgs=参数
}
}
编译ejava.apply{
source=generateJavaSources.source
dependsOn（生成资源）
}
jar.apply{
baseName=project.name
属性（mapOf(
“实施版本”到版本，
“自动模块名称”到“me.canelex.jda”））
}
javadoc.apply{
isFailOnError=false
options.memberLevel=JavadocMemberLevel.PUBLIC
options.encoding=“UTF-8”
if（选项为StandardJavaDocletOptions）{
val opt=作为标准javadocletoptions的选项
opt.author（）
opt.tags（“孵化：a:孵化：”）
选择链接(
"https://docs.oracle.com/javase/8/docs/api/",
"https://takahikokawasaki.github.io/nv-websocket-client/",
"https://square.github.io/okhttp/3.x/okhttp/")
if（JavaVersion.current（）.isJava9Compatible）{
opt.addBooleanOption（“html5”，true）
opt.addStringOption（“-release”，“8”）
}
if（JavaVersion.current（）.isjava11兼容）{
opt.addBooleanOption（“-无模块目录”，true）
}
}
//jda内部构件
排除（“me/canelex/jda/internal”）
}
构建。应用{
德彭森（罐子）
dependsOn（javadocJar）
dependsOn（sourcesJar）
德彭森（阴影罐）
javadocJar.mustRunAfter（jar）
sourcesJar.mustRunAfter（javadocJar）
shadowJar.mustRunAfter（sourcesJar）
}
bintrayUpload.apply{
德彭森（建筑）
}
测试。应用{
useJUnitPlatform（）
failFast=true
}
出版{
出版物{
寄存器（“BintrayRelease”
tasks.withType<JavaCompile> {
    val arguments = mutableListOf("-Xlint:deprecation", "-Xlint:unchecked")
    options.encoding = "UTF-8"
    options.isIncremental = true
    if (JavaVersion.current().isJava9Compatible) doFirst {
        arguments += "--release"
        arguments += "8"
    }
    doFirst {
        options.compilerArgs = arguments
    }
}