小编Ale*_*x R的帖子

我是Eclipse的长期用户,我现在决定为Scala尝试IntelliJ IDEA 9(免费版).

几个愚蠢的问题:

• 如何判断我修改过的文件是否已保存？
• 如何判断我保存的文件是否已经签入CVS了？

当我没有看到Eclipse中熟悉的视觉提示表明文件已被保存和/或签入时,我感到难以置信地"暴露"到某种迫在眉睫的危险.

谢谢

底部的实际问题......首先是一些背景信息:

我正在研究一种将PHP代码转换为Scala的工具.作为最后的尝试之一,我需要一个非常好(呃,有点偏见)的基准.

通过愚蠢的运气,我的第一次基准尝试是使用了一些广泛使用bcmath的代码,遗憾的是,它在Java中慢了1000倍,使得Scala代码总体上比原始PHP慢22倍.

所以我正在寻找一些具有以下特征的有意义的PHP基准测试:

• PHP源需要在一个文件中.
• 它应该解决现实世界或科学问题.没有愚蠢的循环空方法等.
• 我需要它设置简单 - 没有数据库,难以找到输入文件等.
• 它需要是单线程的(不幸的是,CLBG中的大多数基准测试现在都是多线程的)
• 简单的文本输入和输出首选.
• 它不应该使用Java中较慢的功能(BigInteger,三角函数等).
• 它不应该使用开放的或动态的PHP函数(例如,没有"eval"或"variable vars").
• 它不应该过度依赖内置库,例如MD5,crypt等 - 因为我想对PHP-to-Scala转换的质量进行基准测试,而不是库实现的质量.
• 它不应该受I/O限制.需要CPU限制内存的算法.
• 基本上,密集的OO操作,整数和字符串操作,递归等都会很棒.

我已经检查了两个流行的来源,但没有任何符合标准:

• CLBG:http://shootout.alioth.debian.org/ - 一切都是多线程的 - 没有好处.
• PHP Bench:http://www.phpbench.com/ - 微基准,没有真实世界 - 没有好处
• PHP.NET RFC:更好的基准:http://wiki.php.net/rfc/better_benchmarks - 这里有一些很好的信息,但最终没有找到.

所以,不用多说,实际问题:

是否存在符合上述标准的现有开源代码体系作为性能基准？

谢谢

我有一个与此类似的问题(java.lang.ClassNotFoundException:org.springframework.web.context.ContextLoaderListener),我的情况的区别在于,常见的修复(将Maven依赖项添加到部署程序集)只是暂时的,它会破坏每一个时间我做Maven更新,这不是太频繁,但足以成为一个真正的麻烦.

有永久性修复吗？

细节

这是我得到的错误

我通过这里解决它:

然后在这里:

最后在这里......

这是修复后的样子:

这是我的pom.xml:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>ctc.web.proyect</groupId>
  <artifactId>front.web</artifactId>
  <packaging>war</packaging>
  <version>0.2.5</version>
  <name>front.web</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <javax.servlet.version>3.1.0</javax.servlet.version>
        <javax.servlet.jstl>1.2</javax.servlet.jstl>
        <org.springframework.version>4.1.5.RELEASE</org.springframework.version>
        <thymeleaf.version>2.1.4.RELEASE</thymeleaf.version>
        <jackson.version>2.5.3</jackson.version>
        <mysql.version>5.1.30</mysql.version>
        <c3p0.version>0.9.1.2</c3p0.version>
        <logback.version>1.1.1</logback.version>
        <slf4j.version>1.7.7</slf4j.version>
        <testng.version>6.8.8</testng.version>
        <commons-lang3.version>3.3.2</commons-lang3.version>
        <mockito.version>1.9.5</mockito.version>
        <cglib.version>2.2.2</cglib.version>
        <guava.version>18.0</guava.version>
        <commons-collections.version>3.2.1</commons-collections.version>
        <commons-validator.version>1.4.1</commons-validator.version>
        <javax.mail.version>1.4.7</javax.mail.version>
        <org.aspectj.version>1.8.6</org.aspectj.version>
        <apache.lucene.version>5.3.0</apache.lucene.version>
    </properties>

  <dependencies>

<!--   JAVAX SERVLET LIB DEPENDENCY -->
    <dependency>
       <groupId>javax.servlet</groupId>
       <artifactId>jstl</artifactId>
       <version>${javax.servlet.jstl}</version>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>${javax.servlet.version}</version>
    </dependency>

        <!--
                SPRING DEPENDENCIES
        -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>${org.springframework.version}</version>
      <exclusions>
        <exclusion>
            <artifactId>commons-logging</artifactId>
            <groupId>commons-logging</groupId>
        </exclusion>
      </exclusions>
    </dependency>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-expression</artifactId>
          <version>${org.springframework.version}</version> …

我有这个：

Stream<CompletableFuture<List<Item>>>

我怎样才能将它转换为

Stream<CompletableFuture<Item>>

其中：第二个流由第一个流中每个列表内的每个项目组成。

我研究了一下thenCompose，但这解决了一个完全不同的问题，也称为“扁平化”。

如何以流方式高效地完成此操作，而不阻塞或过早消耗不必要的流项目？

这是迄今为止我最好的尝试：

    ExecutorService pool = Executors.newFixedThreadPool(PARALLELISM);
    Stream<CompletableFuture<List<IncomingItem>>> reload = ... ;

    @SuppressWarnings("unchecked")
    CompletableFuture<List<IncomingItem>> allFutures[] = reload.toArray(CompletableFuture[]::new);
    CompletionService<List<IncomingItem>> queue = new ExecutorCompletionService<>(pool);
    for(CompletableFuture<List<IncomingItem>> item: allFutures) {
        queue.submit(item::get);
    }
    List<IncomingItem> THE_END = new ArrayList<IncomingItem>();
    CompletableFuture<List<IncomingItem>> ender = CompletableFuture.allOf(allFutures).thenApply(whatever -> {
        queue.submit(() -> THE_END);
        return THE_END;
    });
    queue.submit(() -> ender.get());
    Iterable<List<IncomingItem>> iter = () -> new Iterator<List<IncomingItem>>() {
        boolean checkNext = true;
        List<IncomingItem> next = null;
        @Override
        public boolean hasNext() {
            if(checkNext) {
                try { …

使用 Java 将 DynamoDB JSON 转换为标准 JSON问题的答案将于 2022 年过时。

问题是这两个导入都不再起作用：

import com.amazonaws.services.dynamodbv2.document.internal.InternalUtils;

import com.amazonaws.services.dynamodbv2.document.ItemUtils;

会发生什么：导入失败。

您还可以在文档中进行验证，此处：https://sdk.amazonaws.com/java/api/latest/index.html ?software/amazon/awssdk/services/dynamodb/package-summary.html

问题是，在 SDK 2.x 中用什么类来替代这两个类呢？

当然,这个简单的测试按预期工作:

scala> var b = 2
b: Int = 2

scala> b += 1   

scala> b
res3: Int = 3

现在我将其纳入范围:

class A(var x: Int) { def +=(y:Int) { this.x += y } }
implicit def int2A(i:Int) : A = new A(i)             

我正在定义一个新类和一个+ =操作,并且当我想要将Int添加到A的Int值时,这是一个方便的隐式转换.

当"A"类不是表达式的所有部分时,我从未想到这会影响我的常规Int操作的行为方式.

但它确实:

scala> var b:Int = 0
b: Int = 0

scala> b += 1

scala> b  
res29: Int = 0

scala> b += 2

scala> b
res31: Int = 0

这里似乎发生的是b:Int被隐式转换为"A",它不绑定到任何变量,然后在其上调用+ =,丢弃结果.

Scala似乎高度优先于已经定义为Ints的自然+ =行为(编译器魔法,而不是实际方法)的隐式转换.常识以及C++背景告诉我,只有在编译失败时才应该作为最后的手段调用implicits.这导致了几个问题......

• 为什么？这是一个错误吗？它是按设计的吗？ …

我的意思是,从同样的意义上说,C/Java for只是一个while循环的时髦语法.

我还记得第一次学习forC语言中的循环时,必须深入理解三个控制表达式相对于循环语句的执行顺序.在我看来,同样的努力必须应用于理解Continuations(在Scala中,我猜可能是其他语言).

然后是明显的后续问题......如果是这样,那么重点是什么？似乎很多痛苦(语言复杂性,程序员错误,不可读的程序等)没有任何好处.

我正在编写一个生成Scala输出的代码生成器.

我需要模仿一个三元运算符,使得令牌导致'？' 保持不变.

例如,将表达式转换c ? p : q为c something.简单if(c) p else q不符合我的标准,因为它需要放在if(前面c.

我的第一次尝试(仍然使用上面的c/p/q)是

c match { case(true) => p; case _ => q }

我找到的另一个选择是:

class ternary(val g: Boolean => Any) { def |: (b:Boolean) = g(b) }

implicit def autoTernary (g: Boolean => Any): ternary = new ternary(g)

这让我写:

c |: { b: Boolean => if(b) p else q }

我喜欢第二个选项的整体外观,但有没有办法让它更简洁？

谢谢

将lambda应用于列表中的每个项目的最惯用机制是什么,返回由结果组成的列表？

例如:

List<Integer> listA = ... imagine some initialization code here ...

List<Integer> listB = listA.apply(a -> a * a);   // pseudo-code (there is no "apply")

/* listB now contains the square of every value in listA */

我查看了API javadocs并查看了Apache Commons,但没有找到任何内容.

简单的REPL测试......

def g(a:Int)(implicit b:Int) = {a+b}

为什么这些尝试用法都不起作用？

1.

scala> class A { var b:Int =8; var c = g(2) }
:6: error: could not find implicit value for parameter b: Int
       class A { var b:Int =8; var c = g(2) }

2.

scala> class A(var b:Int) { var c = g(2) }  
:6: error: could not find implicit value for parameter b: Int
       class A(var b:Int) { var c = g(2) }
                                     ^

谢谢