小编vac*_*ach的帖子

一般问题:反转流的正确方法是什么？假设我们不知道流包含哪种类型的元素,那么反转任何流的通用方法是什么？

具体问题:

IntStream提供范围方法来生成特定范围内的整数IntStream.range(-range, 0),现在我要反转它切换范围从0到负不起作用,我也不能使用Integer::compare

List<Integer> list = Arrays.asList(1,2,3,4);
list.stream().sorted(Integer::compare).forEach(System.out::println);

与IntStream我会得到这个编译器错误

错误:(191,0)ajc:sorted()类型中的方法IntStream不适用于参数(Integer::compare)

我在这里想念的是什么？

我只是潜入这种神奇的语言,这一件事让我感到沮丧.为什么没有用于同步的关键字？

到目前为止,我的研究放弃了一个解决方案,你包装一些高级类并使用它们来处理并发...

给定一个关于纯kotlin的项目,如果需要一个处理并发性等的小型高度优化组件,那么该怎么办...我的印象是kotlin是Java的一种辅助语言,在kotlin中编写90%的代码但是有一些用kotlin无法表达的java代码.

这是正确的吗？这是它的目的是什么？

在java中,我们为类提供了包受保护(默认)修饰符,它允许在单个包中包含许多类,但只暴露少量类并保持逻辑封装.

使用kotlin似乎并非如此,如果我想要几个其他类可以彼此可见但不进一步我必须使用私有修饰符限制单个文件的可见性...所以基本上如果你有10一个包中的类,只有一个是公共的,现在你将有一个包含所有类的大文件(以及private所有的地方)......

这是正常的做法还是有办法在kotlin中实现一些类似的模块化？

我不明白他们是否有包装的概念为什么他们摆脱了包受保护的访问...

更新:大家可能都封装保护的知名度毕竟
看到这里的讨论

我有一个java 8流循环,其中包含以下内容:

    void matchSellOrder(Market market, Order sellOrder) {
        System.out.println("selling " + market.pair() + " : " + sellOrder);

        market.buyOrders()
                .stream()
                .filter(buyOrder -> buyOrder.price >= sellOrder.price)
                .sorted(BY_ASCENDING_PRICE)
                .forEach((buyOrder) -> {
                    double tradeVolume = Math.min(buyOrder.quantity, sellOrder.quantity);
                    double price = buyOrder.price;

                    buyOrder.quantity -= tradeVolume;
                    sellOrder.quantity -= tradeVolume;

                    Trade trade = new Trade.Builder(market, price, tradeVolume, Trade.Type.SELL).build();
                    CommonUtil.convertToJSON(trade);

                    if (sellOrder.quantity == 0) {
                        System.out.println("order fulfilled");
                        // break loop there
                    }
                });
    }

当满足某些条件时,如何摆脱循环？什么是正确的关闭流的方式？

UPDATE

我误用了流tecnique,假设它是一个循环,它不是为此而设计的.这是我最终使用以下答案提供的代码:

        List<Order> applicableSortedBuyOrders = market.buyOrders()
                .stream()
                .filter(buyOrder -> buyOrder.price >= sellOrder.price) …

我知道CompletableFuture设计不能通过中断来控制它的执行,但我想你们中的一些人可能会遇到这个问题.CompletableFutures是组合异步执行的非常好的方法,但考虑到你希望在取消未来时中断或停止底层执行的情况,我们该怎么做？或者我们必须接受任何取消或手动完成CompletableFuture不会影响在那里完成它的线程？

也就是说,在我看来,显然是一项无用的工作需要时间来执行工人.我想知道在这种情况下哪种方法或设计可能有用？

UPDATE

这是一个简单的测试

public class SimpleTest {

  @Test
  public void testCompletableFuture() throws Exception {
    CompletableFuture<Void> cf = CompletableFuture.runAsync(()->longOperation());

    bearSleep(1);

    //cf.cancel(true);
    cf.complete(null);

    System.out.println("it should die now already");
    bearSleep(7);
  }

  public static void longOperation(){
    System.out.println("started");
    bearSleep(5);
    System.out.println("completed");
  }

  private static void bearSleep(long seconds){
    try {
      TimeUnit.SECONDS.sleep(seconds);
    } catch (InterruptedException e) {
      System.out.println("OMG!!! Interrupt!!!");
    }
  }
}

如果您正在寻找示例gradle protobuf项目,请查看此处.

我有困难时期gradle这个和protobuf的,我想创建一个简单的项目的Gradle,将采取从默认的任何原文件src/main/proto,src/test/proto并编译它们src/main/java,src/test/java因此,再包到这一个罐子,发布到本地回购.

不幸的是,我是新手,无法弄清楚原始项目的组成方式.

这是我未完成的build.gradle文件

apply plugin: 'java'
apply plugin: "com.google.protobuf"

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'com.google.protobuf:protobuf-gradle-plugin:0.7.0'
    }
}

repositories {
    mavenCentral()
}

dependencies {
    compile 'com.google.protobuf:protobuf-java:3.0.0-beta-1'
}

sourceSets {
    main {
        proto {
            srcDir 'src/main/proto'
        }
        java {
            srcDir 'src/main/java'
        }
    }
    test {
        proto {
            srcDir 'src/test/proto'
        }
        proto {
            srcDir 'src/test/java'
        }
    }
}

protobuf {
    // Configure the protoc executable
    protoc { …

在log4j2中,我们有一个方便的功能,描述为

// Java-8 style optimization: no need to explicitly check the log level:
// the lambda expression is not evaluated if the TRACE level is not enabled
logger.trace("Some long-running operation returned {}", () -> expensiveOperation());

我试图在kotlin中使用它

log.debug("random {}", { UUID.randomUUID() })

这将打印

random Function0<java.util.UUID>

我们如何使用kotlin使用lambda参数记录？或者我们如何明确告诉kotlin要调用哪种方法？

在一小部分sbt项目中,我们需要一个protobuf/grpc编译,因为只有gradle有正常的支持,我们用它来执行与protobuf相关的任务.

有时它会随机地失败编译同样的东西并且会在重试时成功,我们确定它是因为增量的java编译.

我想禁用各种孵化功能和增量编辑,我希望这个东西是确定性的.

为此我试过

compileJava {
    //enable compilation in a separate daemon process
    options.fork = false

    //enable incremental compilation
    options.incremental = false
}

但gralde仍会提供这样的输出(显然忽略了那些标志)

Parallel execution is an incubating feature.
Incremental java compilation is an incubating feature.
:deleteGeneratedSource
:clean
:extractIncludeProto
:extractProto UP-TO-DATE
:generateProto
:recompileProto

那么我们如何禁用并行执行和增量java编译呢？

我见过几个类似的问题,但没有人解释为什么委托仅限于接口？

在实践中大多数时候我们都有一些实际上根本没有接口的东西,它是一个不实现任何功能但只提供一些功能或实现抽象类的类.

是否有任何基本限制迫使其仅限于接口,或者我们是否可以期望kotlin将来能够不受限制地授权？

如果我们想要使用组合而不是继承来扩展类的功能,这将特别有用.

class A {}
class B(val a: A) : A by a {}

Coroutine async返回Deferred<T>,有懒惰执行和等待用法的例子.

但是,我们如何等待任何一个Deffered实例完成？

简而言之

  // whats the equivalent of CompletableFuture.anyOf(...)?
  // is this how we do it? if so how costly is this?
  select<Unit> {
     deffered1.onAwait {}
     deffered2.onAwait {}
  }