小编Bas*_*ass的帖子

请考虑以下界面:

public interface I {
    default String getProperty() {
        return "...";
    }
}

和刚刚重用默认实现的实现类:

public final class C implements I {
    // empty
}

每当C在JSP EL脚本上下文中使用实例时:

<jsp:useBean id = "c" class = "com.example.C" scope = "request"/>
${c.property}

- 我收到了PropertyNotFoundException:

javax.el.PropertyNotFoundException: Property 'property' not found on type com.example.C
    javax.el.BeanELResolver$BeanProperties.get(BeanELResolver.java:268)
    javax.el.BeanELResolver$BeanProperties.access$300(BeanELResolver.java:221)
    javax.el.BeanELResolver.property(BeanELResolver.java:355)
    javax.el.BeanELResolver.getValue(BeanELResolver.java:95)
    org.apache.jasper.el.JasperELResolver.getValue(JasperELResolver.java:110)
    org.apache.el.parser.AstValue.getValue(AstValue.java:169)
    org.apache.el.ValueExpressionImpl.getValue(ValueExpressionImpl.java:184)
    org.apache.jasper.runtime.PageContextImpl.proprietaryEvaluate(PageContextImpl.java:943)
    org.apache.jsp.index_jsp._jspService(index_jsp.java:225)
    org.apache.jasper.runtime.HttpJspBase.service(HttpJspBase.java:70)
    javax.servlet.http.HttpServlet.service(HttpServlet.java:729)
    org.apache.jasper.servlet.JspServletWrapper.service(JspServletWrapper.java:438)
    org.apache.jasper.servlet.JspServlet.serviceJspFile(JspServlet.java:396)
    org.apache.jasper.servlet.JspServlet.service(JspServlet.java:340)
    javax.servlet.http.HttpServlet.service(HttpServlet.java:729)
    org.apache.tomcat.websocket.server.WsFilter.doFilter(WsFilter.java:52)

我最初的想法Tomcat 6.0对于Java 1.8功能来说太旧了,但我很惊讶Tomcat 8.0也受到了影响.当然,我可以通过显式调用默认实现来解决这个问题:

    @Override
    public String getProperty() {
        return I.super.getProperty();
    }

- …

Java java.util.regex.Matcher replaceFirst(...)/ replaceAll(...)API返回字符串,如果使用默认堆大小,则可能导致OOME输入大小为20-50M字符.这2种方法可以容易地重写为写至Writer做得相当比构建叮咬,有效地消除了一个故障点.

该Matcher的工厂方法,但是只接受CharSequences,这也有可能,如果我使用抛出一个OOME StringS/StringBufferS/StringBuilder秒.

如何包装a java.io.Reader来实现一个CharSequence接口(假设我的regexp可能包含反向引用)？是否有任何其他解决方案可以替换文件中的正则表达式而不是大型输入上的OOME？

换句话说,我如何sed在Java中实现类似于GNU的功能(sed众所周知,处理大到几TB的文件,同时支持扩展的正则表达式)？

在Java 1.8中,以下lambda表达式符合两个Runnable和Callable功能接口:

() -> {
    throw new RuntimeException("FIXME");
}

尽管如此,如果我将它提交给ExecutorService使用单参数方法,并忽略返回值(即没有可用的类型推断信息),ExecutorService#submit(Callable)则在编译时选择,除非我明确地将我的lambda转换为Runnable.

在上述情况下,编译器如何在重载方法之间进行选择,前提是Runnable并且Callable不共享任何公共层次结构,并且大多数特定类型规则不适用于此处？

我以前以为

System.console() != null

是一种可靠的方法来确定启动我的Java应用程序的shell是否是交互式的.这允许我使用ANSI转义序列中的互动模式,普通System.out/ System.err每当程序的输出被重定向到文件或管道输送到其他进程的标准输入,类似--color=auto的许多GNU工具模式.

System.console()但是,Windows中的行为是不同的.虽然方法不返回非null当JVM从启动值cmd.exe(这是无用的我,cmd.exe不理解转义序列),返回值总是 null当我从任何终端模拟器,可在启动我的程序的Cygwin - xterm,mintty或cygwin(最后一个只是一个cmd.exe正在运行的bash子进程).

如何在Java中测试交互式shell,无需读取$-shell脚本并将命令行参数传递给我的Java程序？PS1从Java 测试环境变量不是一种选择,因为Java是从shell脚本启动的,因此父进程是非交互式shell,并且PS1未设置.

请考虑下表,其中一列的类型为nullable NVARCHAR:

CREATE TABLE CHARACTER_SET_MISMATCH_TEST (
    ID NUMBER(10) NOT NULL,
    VALUE NVARCHAR2(32)
);

现在,我想使用多行INSERT(带子查询)语法将多个数据元组插入到此表中:

INSERT
    INTO CHARACTER_SET_MISMATCH_TEST (ID, VALUE)
    SELECT ?, ? FROM DUAL
    UNION ALL
    SELECT ?, ? FROM DUAL;

如果NVARCHAR值是两者NULL都是非NULL,或者两者都是非的,那么一切都运行正常,我确实插入了2行.但是,如果我在一个单独的混合NULL和非NULL值PreparedStatement,我立即收到一个ORA-12704: character set mismatch错误:

java.sql.SQLException: ORA-12704: character set mismatch
    at oracle.jdbc.driver.T4CTTIoer.processError(T4CTTIoer.java:452)
    at oracle.jdbc.driver.T4CTTIoer.processError(T4CTTIoer.java:400)
    at oracle.jdbc.driver.T4C8Oall.processError(T4C8Oall.java:884)
    at oracle.jdbc.driver.T4CTTIfun.receive(T4CTTIfun.java:471)
    at oracle.jdbc.driver.T4CTTIfun.doRPC(T4CTTIfun.java:199)
    at oracle.jdbc.driver.T4C8Oall.doOALL(T4C8Oall.java:535)
    at oracle.jdbc.driver.T4CPreparedStatement.doOall8(T4CPreparedStatement.java:238)
    at oracle.jdbc.driver.T4CPreparedStatement.executeForRows(T4CPreparedStatement.java:1385)
    at oracle.jdbc.driver.OracleStatement.doExecuteWithTimeout(OracleStatement.java:1709)
    at oracle.jdbc.driver.OraclePreparedStatement.executeInternal(OraclePreparedStatement.java:4364)
    at oracle.jdbc.driver.OraclePreparedStatement.executeUpdate(OraclePreparedStatement.java:4531)
    at …

当重构代码(例如:重构 - > 重命名)时,IntelliJ IDEA 14.x还会重新(重新格式化)我的代码以适应80列限制.

示例:这是重构之前的代码:

正在进行重构:

...按下后,代码重新包装Enter:

最令人烦恼的是,即使编辑器中当前未打开的Java类(但受重构影响)也会被重新格式化,从而增加了格式化更改未被注意到传播到我的VCS的可能性.

我想要实现的是:

• 将原始打印边距保持在80列,但仍然如此
• 在重命名变量/类/方法时,让IDEA保留我的原始格式.

我该如何实现这一目标？

ReadWriteLockReentrantReadWriteLock实现允许降级(tryLock()从下面的示例总是返回true):

void downgrade(final ReadWriteLock readWriteLock) {
    boolean downgraded = false;
    readWriteLock.writeLock().lock();
    try {
        // Always true, as we already hold a W lock.
        final boolean readLockAcquired = readWriteLock.readLock().tryLock();
        if (readLockAcquired) {
            // Now holding both a R and a W lock.
            assert ((ReentrantReadWriteLock) readWriteLock).getReadHoldCount() == 1;
            assert ((ReentrantReadWriteLock) readWriteLock).getWriteHoldCount() == 1;

            readWriteLock.writeLock().unlock();
            downgraded = true;
            try {
                // Now do some work with only a R lock held
            } finally {
                readWriteLock.readLock().unlock();

                assert ((ReentrantReadWriteLock) …

获取两个流的交集,或者查找它们的交集是否为空在Java中通常是不可能的,因为流只能使用一次,并且通用解决方案具有 复杂.

如果我们对底层供应商的性质一无所知,我们最多可以获得一个流和一个集合:

<T> boolean intersects(final Stream<T> c1, final Collection<T> c2) {
    return c1.filter(c2::contains).findAny().isPresent();
}

不过,如果有什么我们的供应商代表有序集合使用相同的比较器(在最简单的情况下,两个分类TreeSet第ComparableS)？在这种情况下,解决方案将具有线性复杂性(或者更确切地说,,看到这个答案).

现在的问题是:上述线性解决方案是否只能使用Stream API实现(即使用两个流作为输入)？

在Eclipse中,有可能突出显示循环断点:我可以将光标放在break;,并且突出显示的循环将突出显示:

仍然,IDEA似乎缺少这个功能:

是否有任何隐藏的偏好或第三方插件为IDEA启用相同的功能？

假设我有两个相邻的synchronized块,Thread.holdsLock()它们之间有一个调用:

final Object lock = new Object();
// ...
synchronized (lock) {
    // do stuff
}
if (Thread.holdsLock(lock)) {
    throw new IllegalStateException();
}
synchronized (lock) {
    // do more stuff
}

现在,如果在某些时候JVM决定粗化锁并合并上面的synchronized块呢？将Thread.holdsLock()调用仍然返回false,或者代码是否会因异常而失败？