小编Cog*_*man的帖子

想象一下,我有一些看起来像这样的东西:

Stream<Integer> stream = Stream.of(2,1,3,5,6,7,9,11,10)
            .distinct()
            .sorted();

两者的javadocs distinct()并sorted()说它们是"有状态的中间操作".这是否意味着内部流将执行类似创建哈希集,添加所有流值,然后看到sorted()将这些值抛出到排序列表或排序集？或者它比那更聪明？

换句话说,是否.distinct().sorted()导致java遍历流两次或者java延迟直到执行终端操作(例如.collect)？

    boolean a = true;
    boolean b = true;
    boolean c = false;

    System.out.println(a || b && c); // true
    System.out.println(b && c || a); // true

我刚刚发现了我认为有点古怪的东西.为什么会这样,&&并且||处于不同的优先级？我原以为他们处于同一水平.以上说明了这一点.这两个陈述都是正确的,即使从左到右的评估对第一个给出错误而对第二个给出为真.

有谁知道这背后的原因？

(顺便说一下,我本来只是在这里使用了一大堆括号,但这是旧代码提出的问题)

所以我的代码目前看起来像这样

    public boolean in(TransactionType... types)
    {
        if (types == null || types.length == 0)
            return false;

        for (int i = 0; i < types.length; ++i)
            if (types[i] != null && types[i] == this)
                return true;
        return false;
    }

我把它改成了这个

    public boolean in(TransactionType... types)
    {
        if (types == null || types.length == 0)
            return false;

        for (int i = 0; i < types.length; ++i)
            if (types[i] == this)
                return true;
        return false;
    }

(TransactionType是一个包含大约30个值的枚举)

结果震惊了我.在我的所有测试中,第二个测试速度提高了一个数量级.我预计可能快2倍,但不是一个数量级.为什么不同？这是一个更慢的nullcheck,或者是额外的数组访问会发生什么奇怪的事情吗？

我的基准代码看起来像这样

public class App …

我有一个ListA,B,C.

C reduce A reduce B != A reduce B reduce C (但是,减少(B减少C)是可以的).

换句话说,我的还原操作是关联的,但不是可交换的.

java是否对有序顺序流(例如列表中的默认流)执行减少将始终根据遭遇顺序进行减少？也就是说,java会重新排序减少(这样B减少A而不是A减少B)？

(希望这很清楚).

编辑添加一个小演示,也许有助于澄清

Stream.of(" cats ", " eat ", " bats ")
  .reduce("", (a, b) -> a + b); // cats eat bats

有了上述,输出可能是"蝙蝠猫吃"​​或"吃蝙蝠猫"？是否在规范的某处保证了？

是否可以选择在匕首2中插入值？我尤其想做这样的事情。

@Inject A(Optional<B> b) {
  this.b = b;
}

如果B在模块中未定义，我想用匕首给出一个Optional.empty()，如果已定义则给定Optional.of(value)。

这是可行的，还是我需要一个定义这些可选值的模块？

我正在使用java.awt.Font,我怎样才能发现系统上是否安装了定义的字体？

具体来说,我有

Font font = new Font("FooBar", 0, 14);

我想发现"font"是否是系统上的有效字体,如果不可用,则默认为更通用的字体.

我有一张看起来像这样的桌子

CREATE TABLE bob
    (ID INT IDENTITY,
    blah VARBINARY(MAX),
    ts DATETIME2 DEFAULT GETUTCDATE())

我们假设这个陈述

INSERT INTO dbo.bob
        ( blah )
VALUES  (
          @blarg
          )

需要10秒钟才能完成.

如果插入开始的时间是t.ts会在新创建的行上有t或t + 10秒吗？换句话说,是在插入的开头或插入的结尾(或其他一些规则)生成的默认值？

我在做一些奇怪的事情.我想创建一个Set,但是我想忽略那些对象上的equals覆盖,而是我想为等于比较(真的)做obj1 == obj2.

所以想象一下,我有几个看起来像这样的物体

public static class BrokenEquals
{
    @Override
    public int hashCode()
    {
        return 1;
    }


    @Override
    public boolean equals(Object obj)
    {
        return true;
    }
}

如果我这样做

    Set<Object> objs = new HashSet<>();
    objs.add(new BrokenEquals());
    objs.add(new BrokenEquals()); // objs.size() == 1

显然,Set的大小为1(因为这两个对象是"相等的").相反,我希望该集合包含两个不同的对象.

但是,如果我这样做

    BrokenEquals obj = new BrokenEquals();
    Set<Object> objs = new HashSet<Object>();
    objs.add(obj);
    objs.add(obj); // objs.size() == 1

我希望集合的大小为1;

我没有权限更改.equals方法

我想要这个的原因是我正在遍历带有循环的对象图.我不想陷入其中.

如何衡量我的应用程序的HttpClients带宽使用情况？(HttpComponents 4.3)

我有一个使用HttpClient与服务器通信的客户端应用程序.所有请求都使用池化http连接管理器通过同一客户端完成.不幸的是,大多数请求直接使用httpclient(不是全部),因此在请求位置测量带宽是可行的,但很痛苦.

在客户端的构造函数或连接管理器中是否有一个位置,我可以简单地注入我自己的带宽监视器(或者是已经构建在我尚未发现的某个地方)？

我可以这样做吗？

    HttpClientBuilder.create().addInterceptorLast(new HttpResponseInterceptor()
    {

        @Override
        public void process(HttpResponse response, HttpContext context) throws HttpException, IOException
        {

        }
    }).build();