小编Vla*_*eev的帖子

就像java.util.Optional<T>在Java 8中(有点)等同于Scala的Option[T]类型,是否有相当于Scala的Either[L, R]？

我想使用Docker来启动我的应用程序和Cassandra数据库,我想使用Docker Compose.不幸的是,Cassandra的启动比我的应用程序慢得多,而且由于我的应用程序急切地初始化了Cluster对象,因此我得到以下异常:

com.datastax.driver.core.exceptions.NoHostAvailableException: All host(s) tried for query failed (tried: cassandra/172.18.0.2:9042 (com.datastax.driver.core.exceptions.TransportException: [cassandra/172.18.0.2:9042] Cannot connect))
    at com.datastax.driver.core.ControlConnection.reconnectInternal(ControlConnection.java:233)
    at com.datastax.driver.core.ControlConnection.connect(ControlConnection.java:79)
    at com.datastax.driver.core.Cluster$Manager.init(Cluster.java:1454)
    at com.datastax.driver.core.Cluster.init(Cluster.java:163)
    at com.datastax.driver.core.Cluster.connectAsync(Cluster.java:334)
    at com.datastax.driver.core.Cluster.connectAsync(Cluster.java:309)
    at com.datastax.driver.core.Cluster.connect(Cluster.java:251)

根据堆栈跟踪和一些调试,似乎Cassandra Java驱动程序不会将重试策略应用于初始启动.这对我来说似乎有点奇怪.有没有办法让我配置驱动程序,以便它继续尝试连接到服务器,直到成功为止？

如何创建实现此接口的Clojure对象,然后从Java代码调用？

public interface Doer {
   public String doSomethin(String input);
}

Doer clojureDoer = ?;

String output = clojureDoer.doSomethin(input);

我正在研究Java NIO.2及其文件操作,目前我正在使用filetree-walking函数和类.

NIO.2 FileVisitorAPI非常棒,很遗憾,最近才将这种东西添加到Java SE中,而不是十年前.然而,有些东西让我感到困扰:制作FileVisitor界面通用的重点是什么？

网上的每个例子都显示了如何使用它,Files.walkFileTree()这意味着我们正在使用FileVisitor<Path>类型.但我只是看不到任何用于此接口的用途Path.好吧,有可能用它FileVisitor来走其他类型的树(内存中的那些？),但这感觉不对:这个接口和相关的类在语义上与文件绑定了非常具体的名称,还有FileVisitor方法扔IOException秒.

那么,参数化FileVisitor类型有什么原因吗？

我有一个List<Foo>并且想要一个番石榴Multimap<String, Foo>,我们Foo按照它们的Collection<String> getTags()功能的每个标签对它们进行分组.

我正在使用java 8,所以lambdas和方法引用很好/鼓励.

例如,如果我有:

foo1, tags=a,b,c
foo2, tags=c,d
foo3, tags=a,c,e

我会得到一个Multimap<String, Foo>:

a -> foo1, foo3
b -> foo1
c -> foo1, foo2, foo3
d -> foo2
e -> foo3

我正在使用Go语言并发,发现了一些对我来说不透明的东西.

我写了并行矩阵乘法,也就是说,每个任务计算产品矩阵的单行,乘以源矩阵的相应行和列.

这是Java程序

public static double[][] parallelMultiply(int nthreads, final double[][] m1, final double[][] m2) {
    final int n = m1.length, m = m1[0].length, l = m2[0].length;
    assert m1[0].length == m2.length;

    double[][] r = new double[n][];

    ExecutorService e = Executors.newFixedThreadPool(nthreads);
    List<Future<double[]>> results = new LinkedList<Future<double[]>>();
    for (int ii = 0; ii < n; ++ii) {
        final int i = ii;
        Future<double[]> result = e.submit(new Callable<double[]>() {
            public double[] call() throws Exception {
                double[] row = new double[l];
                for (int j = …

为什么新的JDK8 Stream类只包含以下reduce方法:

T reduce(BinaryOperator<T> reducer)
T reduce(T identity, BinaryOperator<T> reducer)
U reduce(U identity, BiFunction<U, ? super T, U> reducer, 
    BinaryOperator<U> combiner)

但不是一个明显的方法,它对应于其他语言(例如Haskell )中的reduce/ foldfunctions foldl :: (a -> b -> a) -> a -> [b] -> a,它们看起来像这样:

U reduce(U identity, BiFunction<U, ? super T, U> reducer)

？

相反,有一个类似的方法有一个额外的combiner参数.我甚至不确定如何使用它,因为我链接到上面的API文档在示例中没有使用此参数,它只提到了它所需的属性.

为什么JDK8方法是这样制作的,我如何fold用它们模拟标准行为？

正如库文档所说CString创建的newCString必须通过free函数释放.我一直在期待CString创建它时需要一些内存,当它被释放时free内存使用会下降,但它没有!这是示例代码:

module Main where

import Foreign
import Foreign.C.String
import System.IO

wait = do
  putStr "Press enter" >> hFlush stdout
  _ <- getLine
  return ()

main = do
  let s = concat $ replicate 1000000 ['0'..'9']
  cs <- newCString s
  cs `seq` wait   -- (1)

  free cs
  wait   -- (2)

当程序停在(1)时,htop程序显示内存使用量大约为410M - 这没关系.我按回车键,程序在第(2)行停止,但内存使用率仍为410M,尽管cs已经是freed!

这怎么可能？用C编写的类似程序就像它应该的那样.我在这里错过了什么？

我尝试在我的项目中使用蛋糕模式并且非常喜欢它,但是有一个困扰我的问题.

当所有组件具有相同的生命周期时,蛋糕模式易于使用.您只需定义多个traits-components,通过traits-implementation扩展它们,然后将这些实现组合在一个对象中,并通过自我类型自动解析所有依赖项.

但是假设您有一个组件(具有自己的依赖项),可以根据用户操作创建该组件.无法在应用程序启动时创建此组件,因为它尚无数据,但在创建时应具有自动依赖性解析.这种组件关系的一个例子是主GUI窗口及其复杂的子项(例如笔记本窗格中的选项卡),它们是根据用户请求创建的.主窗口是在应用程序启动时创建的,当用户执行某些操作时会创建其中的一些子窗格.

这很容易在像Guice这样的DI框架中完成:如果我想要一些类的多个实例,我只需注入一个Provider<MyClass>; 然后我get()在该提供程序上调用方法,并MyClass自动解析所有依赖项.如果MyClass需要一些动态计算的数据,我可以使用辅助注入扩展,但结果代码仍然归结为提供者/工厂.相关概念,范围,也有帮助.

但我想不出用蛋糕模式做这件事的好方法.目前我正在使用这样的东西:

trait ModelContainerComponent {  // Globally scoped dependency
    def model: Model
}

trait SubpaneViewComponent {  // A part of dynamically created cake
    ...
}

trait SubpaneControllerComponent {  // Another part of dynamically created cake
    ...
}

trait DefaultSubpaneViewComponent {  // Implementation
    self: SubpaneControllerComponent with ModelContainerComponent =>
    ...
}

trait DefaultSubpaneControllerComponent {  // Implementation
    self: SubpaneViewComponent with ModelContainerComponent =>
    ...
}

trait SubpaneProvider {  // A component which …

&[T] 令我困惑.

我天真地认为像&T,&[T]是一个指针,这就是说,一个数字指针地址.

但是,我已经看到了一些像这样的代码,我看到工作正常(为了演示目的而简化;但是你在许多'as_slice()'实现中看到这样的代码)我感到非常惊讶:

extern crate core;
extern crate collections;

use self::collections::str::raw::from_utf8;
use self::core::raw::Slice;
use std::mem::transmute;

fn main() {
  let val = "Hello World";
  {
    let value:&str;
    {
      let bytes = val.as_bytes();
      let mut slice = Slice { data: &bytes[0] as *const u8, len: bytes.len() };
      unsafe {
        let array:&[u8] = transmute(slice);
        value = from_utf8(array);
      }
      // slice.len = 0;
    }
    println!("{}", value);
  }
}

所以.

我最初认为这是无效的代码.

也就是说,在Slice块作用域内创建的实例将返回到块作用域之外(通过转换),尽管代码运行,但println!实际上是通过不安全指针访问不再有效的数据.坏!

......但似乎并非如此.

考虑评论该行 …