小编Dur*_*dal的帖子

背景:我需要能够以"禁用"外观创建图像.通常建议的方法是将图像转换为灰度并显示灰度图像.缺点是它只适用于图像,因此显示图形很麻烦,因为您无法立即访问处于禁用状态的图像.现在我认为这可以使用java.awt.Composite动态完成(然后我不需要知道如何实现一个Icon来禁用它).似乎没有实现转换为灰度,所以我必须创建自己的......

也就是说,我将一个实现混合在一起(并且它呈现了我所期望的).但我不确定它是否真的适用于所有情况(复合/ CompositeContext的Javadocs对于这样一个复杂的操作看起来非常薄).正如你从我的实现中看到的那样,我采用了一种迂回的方式来逐像素处理,因为似乎没有简单的方法来批量读取/写入像素,而这种格式不是由所涉及的栅格决定的.

欢迎任何指向更广泛的文档/示例/提示的指针.

这是SSCCE - 它通过DisabledComposite渲染(彩色)GradientPaint,将渐变转换为灰度.请注意,在现实世界中,您将无法知道通过哪些调用呈现的内容.Gradient实际上只是一个例子(对不起,但是人们常常没有这样做,所以这次我会明确说明).

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Composite;
import java.awt.CompositeContext;
import java.awt.Dimension;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.ColorModel;
import java.awt.image.Raster;
import java.awt.image.WritableRaster;

import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.SwingUtilities;

public class CompositeSSCE implements Runnable {

    static class DisabledComposite implements Composite {
        @Override
        public CompositeContext createContext(
            final ColorModel srcColorModel,
            final ColorModel dstColorModel,
            final RenderingHints hints) {
            return new DisabledCompositeContext(srcColorModel, dstColorModel);
        }
    } 

    static class DisabledCompositeContext implements CompositeContext {

        private …

考虑这个简单的方法:

public ResultSet getByOwnerId(final Connection connection, final Integer id) throws SQLException {
    PreparedStatement statement = connection.prepareStatement("SELECT * FROM MyTable WHERE MyColumn = ?");
    statement.setObject(1, id);
    return statement.executeQuery();
}

示例方法应该从列的值匹配的某个表中选择所有内容,这应该是简单的.丑陋的细节是,为id传递NULL将导致一个空的ResultSet,无论数据库中有多少行,因为SQL定义NULL而不是euqaling anying,甚至不是NULL.选择我知道的那些行的唯一方法是使用不同的where子句:

SELECT * FROM MyTable WHERE MyColumn IS NULL

不幸的是,在所有情况下使方法正常工作的唯一方法似乎是有两个完全不同的执行路径,一个用于id参数为null而另一个用于常规值的情况.

这非常难看,当你有多个可以被删除的列时,很快就会变得非常混乱.如何使用相同的代码路径/语句处理NULL和普通值？

我认为这很容易找到premade,但似乎我在网上找到的任何解决方案只能解决部分问题.

我想对用户提供的文件名列表(文件大多以人和/或地址命名),有时用不同的语言(大多数是德语,有点法语和意大利语混合在一起) ,很少有任何其他西方语言).

我们的想法是以(德国)用户普遍认为理智的方式呈现此列表.这意味着顺序应该遵循Locale.GERMAN的java.text.Collat​​or,但同时期望是对字符串中的数字进行异常,因此"10"在"2"之后.

我找到了在网上进行自然排序的代码,但它依赖于逐字符比较(而Collat​​or不支持).我可以使用子字符串来破解某些内容,但在比较器内部,我认为在每次比较调用时创建多个子字符串并不是最明智的想法.

任何想法如何有效地实现这一点(在执行时间和实现时间),或者更好的是经过测试和随时可用的实现？

我想使用指定的CharSet将一个CharSequence写入OutputStream.基本上,当调用write(String)时,使用相同CharSet初始化的Writer会做什么.

问题是,有很多CharSequences要写,有些很大.更复杂的是,可以将所有内容写入多个OutputStream.我可以通过使用(实际上我目前已经以这种方式实现)轻松实现它:

byte[] rawBytes = CharSequence.toString().getBytes(CharSet)
for (OutputStream out : outputTargets) {
    out.write(rawBytes);
}

但显然String在这里是完全不需要的垃圾对象,byte []数组也是如此.我正在寻找一种方法,允许我直接进行编码而不需要中间对象.令人惊讶的是,这似乎是不可能的 - 无论我在JRE中看到CharSequence被接受的地方,它都会在任何工作完成之前迅速转换为字符串.

CharSet的大部分(全部？)转换工作似乎都是在非公共类中完成的,所以我没有找到任何方式以透明和合法的方式访问任何一个.

如何避免垃圾/ JRE的CharSet编码设施直接使用？

为(例如)集合创建支持数组时,您并不真正关心所创建数组的确切大小,它只需要至少与您计算的一样大.

但是由于内存分配和VM的数组头,在某些情况下可以创建一个更大的阵列而不消耗更多的内存 - 对于Oracle 32位VM(至少这是互联网上的几个来源声称),内存粒度为8(意味着任何内存分配向上舍入到下一个8字节边界),并且数组头开销为12个字节.

这意味着在分配Object [2]时,它应该消耗20个字节(12 + 2*4),但由于粒度,它实际上需要24个字节.可以为相同的内存成本创建一个Object [3],这意味着集合必须稍后调整其后备阵列的大小.相同的原理可以应用于primitve数组,例如用于I/O缓冲区的byte [],字符串生成器中的char []等.

虽然这种优化不会产生明显的效果,但在最极端的情况下,调用静态方法来"优化"数组大小并不会太麻烦.

问题是,JDK中没有这种"圆形阵列大小直至内存粒度".并且自己编写这样的方法需要确定VM的一些关键参数:内存粒度,数组头开销以及最终每种类型的大小(主要是引用的问题,因为它们的大小可能随架构和VM选项而变化).

那么有没有一种方法来确定这些参数,或通过其他方式实现所需的"向上舍入"？

我正在尝试将项目切换到Java8,并且遇到Eclipse Luna和javac类型推断之间的奇怪差异.使用JDK 1.7.0_65 javac,这段代码编译得很好.JDK 1.8.0_11抱怨toString(char [])和toString(Throwable)都匹配"toString(getKey(code,null));" 线.Eclipse Luna 4.4(I20140606-1215)使用JDK快乐地编译它:

public class TypeInferenceTest {
    public static String toString(Object obj) {
        return "";
    }

    public static String toString(char[] ca) {
        return "";
    }

    public static String toString(Throwable t) {
        return "";
    }

    public static <U> U getKey(Object code, U defaultValue) {
        return defaultValue;
    }

    public static void test() {
        Object code = "test";
        toString(getKey(code, null));
    }
}

我认为唯一可能匹配的签名是toString(Object).

当然我可以简单地向Object添加一个强制转换,但我想知道为什么 javac不能自己推断类型(虽然eclipse确实如此),以及为什么heck javac认为Throwable和char []合适的匹配,而不是Object.

这是Eclipse或javac中的错误吗？(我的意思是只有一个编译器可以在这里,无论是编译还是不编译)

编辑:来自javac(JDK8)的错误消息:

C:\XXXX\Workspace\XXXX\src>javac -cp . TypeInferenceTest.java
TypeInferenceTest.java:22: error: reference …

在重构一些代码时,我偶然发现了这个奇怪的问题.在不影响整个类的情况下,似乎无法控制初始化程序的strictfp属性.例:

public class MyClass {

    public final static float[] TABLE;
    strictfp static { // this obviously doesn't compile
         TABLE = new float[...];
         // initialize table
    }

    public static float[] myMethod(float[] args) {
         // do something with table and args
         // note this methods should *not* be strictfp
    }

}

从JLS开始,第8.1.1.3节我认为如果使用strictfp修饰符声明类,初始化器将是strictfp .但它也说它使所有方法隐含严格:

strictfp修饰符的作用是使类声明中的所有float或double表达式(包括在变量初始化器,实例初始值设定项,静态初始化器和构造函数中)都是明确的FP-strict(第15.4节).

这意味着在类中声明的所有方法以及在类中声明的所有嵌套类型都是隐式strictfp.

因此,静态初始值设定项不接受修饰符,当应用于整个类时,一切都变为strictfp？由于strictfp关键字没有反面,这是不可能实现的？

那么,我是否使用静态方法来保持初始化程序块的主体以实现对strictfp'd​​ness的精确控制？

我正在对MPEG解码器进行一些优化.为了确保我的优化没有破坏任何东西,我有一个测试套件,对整个代码库(优化和原始代码库)进行基准测试,并验证它们是否产生相同的结果(基本上只是通过解码器和crc32提供几个不同的流)输出).

在Sun 1.6.0_18中使用"-server"选项时,测试套件在预热后的优化版本上运行速度降低约12%(与默认的"-client"设置相比),而原始代码库获得了良好的提升运行速度是客户端模式的两倍.

虽然起初这对我来说似乎只是一个热身问题,但我添加了一个循环来多次重复整个测试套件.然后,对于从测试的第3次迭代开始的每次传递,执行时间变为常量,优化版本仍然比客户端模式慢12%.

我也很确定它不是垃圾收集问题,因为代码在启动后绝对没有对象分配.代码主要包括一些位操作操作(流解码)和大量基本浮动数学(生成PCM音频).涉及的唯一JDK类是ByteArrayInputStream(将流提供给测试并从测试中排除磁盘IO)和CRC32(以验证结果).我也观察到与Sun JDK 1.7.0_b98相同的行为(只有15%而不是12%).哦,测试都是在同一台机器(单核)上完成的,没有运行其他应用程序(WinXP).虽然测量的执行时间存在一些不可避免的变化(使用System.nanoTime btw),但使用相同设置的不同测试运行之间的差异从未超过2%,通常低于1%(预热后),

是否有任何已知的编码模式在服务器JIT上表现更差？如果做不到这一点,有什么选择可以"偷看"引擎盖并观察JIT在那里做什么？

• 也许我误解了我的"热身"描述.没有明确的预热代码.整个测试套件(包括12个不同的MPEG流,包含〜180K音频帧总)被执行10次,我认为该第一3个运行为"预热".在我的机器上进行一轮测试需要大约40秒的100%cpu.

• 我按照建议玩了JVM选项并使用"-Xms512m -Xmx512m -Xss128k -server -XX:CompileThreshold = 1 -XX:+ PrintCompilation -XX:+ AggressiveOpts -XX:+ PrintGC"我可以验证所有编译都发生在前3轮.垃圾收集每3-4轮踢一次,最多耗时40ms(512m非常超大,因为测试可以用16米就好了).由此我得出结论,垃圾收集在这里没有影响.不过,比较客户端与服务器(其他选项未改变)仍有12/15%的差异.

只是从包含二进制数据的旧数据库中导出一个导出,我偶然发现了一个实用程序方法中的异常:

java.lang.AbstractMethodError:net.sourceforge.jtds.jdbc.BlobImpl.free()

在检查了我们的代码库之后,我发现实用程序方法直到现在才被使用,基本上它看起来像这样:

public BinaryHolder getBinary(final int columnIndex) throws SQLException {
    Blob blob = null;
    try {
        blob = resultSet.getBlob(columnIndex);
        final BinaryHolder binary = BinaryHolderUtil.create(blob);
        return binary;
    } finally {
        if (blob != null)
            blob.free();
    }
}

BinaryHolder只是一个包装,holdes二进制数据(你问之前,代码执行罚款,直至到达最终条款- BinaryHolderUtil.create(BLOB)并没有试图释放BLOB).

进一步调查我发现在我们访问Blob的其他地方,blob只是使用getBlob()而不是完全免费获得(Javadoc说它会在结果集关闭时自动处理掉).

现在问题:blob 是否应该是free()'d'手动(在所有ResultSet之后可以保留不仅仅是访问blob),如果是,它怎么可以free()'d甚至可以使用没有实现它的驱动程序？

(我们正在使用带有JTDS1.25的SQL-Server,如果从例外中看不出来的话)

这个问题只是让我感到困惑,在重写方法时很容易忘记调用super().

在我的情况下,我正在重构一些现有的东西,其中已经有大约十个类覆盖了一个方法.直到昨天,该方法都有一个空的默认实现,所以如果子类称为super,则无关紧要.你可以在任何有价值的IDE中找到覆盖物,但是你知道它是怎么回事,电话铃声,同事们背后都有一个小小的东西......很容易忘记检查一个地方或者忽略它.理想情况下,@ Override注释会有一个对应物,如果基类方法被注释但是覆盖不会调用super,编译器会为这些位置生成警告.

什么是我能做的最好的事情？

我只是在重构时偶然发现了一段奇怪的代码.它似乎是一个候选因素,用于分解两个readString() - 方法的共同部分,只是它似乎是不可能的(这对我来说是一个令人讨厌的脑筋急转弯):

private final StringBuilder readStringBuilder = new StringBuilder(128);

@Override
public String readString() throws IOException {
    final int l = readInt();
    if (l <= 0) {
        switch (l) {
            case -1: return null;
            case 0: return "";
            default: throw new IOException("invalid string length encoding: " + l);
        }
    }
    readStringBuilder.setLength(0);
    for (int i=0; i<l; ++i) {
        readStringBuilder.append(readChar());
    }
    return readStringBuilder.toString();
}

@Override
public String readString(final StringCache cache) throws IOException {
    final int l = readInt();
    if (l <= 0) …

让我们说我有一个简单的地图,经常被查询,但只是偶尔修改.目前我正在使用synchronized块来防止在添加到地图时遇到竞争条件(简化示例):

public class MyRepository {

    private static HashMap<Integer, Object> MAP = new HashMap<Integer, Object>();

    public static Object getInstance(Integer key) {
        synchronized (MAP) {
            return MAP.get(key);
        }
    }

    public static void addInstance(Integer key, Object instance) {
        synchronized (MAP) {
            MAP.put(key, instance);
        }
    }

}

我遗漏了任何应用程序特定的废话,如处理关键冲突等.你得到的图片,非常简单.在运行时,映射在应用程序启动时填充实例.之后,地图很少被修改(一旦在蓝色的月亮,所以说).另一方面,经常查询地图,查询地图的多个线程相互阻塞.

是否有一种保护机制允许多个"读者"同时掌握地图,同时仍然只有一个"作家"？