小编GA1*_*GA1的帖子

Scala foldLeft在Java 8中的优势是什么？

我很想想它reduce,但是减少必须返回与它减少的相同类型的东西.

例:

import java.util.List;

public class Foo {

    // this method works pretty well
    public int sum(List<Integer> numbers) {
        return numbers.stream()
                      .reduce(0, (acc, n) -> (acc + n));
    }

    // this method makes the file not compile
    public String concatenate(List<Character> chars) {
        return chars.stream()
                    .reduce(new StringBuilder(""), (acc, c) -> acc.append(c)).toString();
    }
}

上面代码中的问题是accumulator:new StringBuilder("")

因此,任何人都可以指出我正确的foldLeft/修复我的代码？

我从A班上返回一份清单.我想从列表中删除第一个元素,并将其作为最后一个元素添加到同一列表中.我是这样做的.

myList.add(myList.get(0));
myList.remove(0);

目标硬件是Android OS.我应该A以一种它返回的方式编写我的类ArrayList,或者LinkedList？哪种情况对以下情况更好:

1. myList总是有100个元素

2. myList总是有10个元素

也许我看到一个没有问题的问题.你认为在这种情况下我不应该关心性能,因为问题的大小(对于1和2都很小)？

我知道"过早优化是万恶之源"的说法.这就是为什么我在改变我的实现之前犹豫不决(现在,我的A对象返回一个ArrayList).

很久以前,我观看了普林斯顿Coursera MOOC:算法简介的视频讲座,可以在这里找到.它解释了ArrayList在添加或删除元素时调整类似结构的成本.事实证明,如果我们想要为我们的数据结构提供调整大小,我们将从for O(n)到amortized O(n)for add和removeoperation.

我已经使用Java ArrayList几年了.我一直都很确定它们会自动增长和缩小.就在最近,令我惊讶的是,我在这篇文章中被证明是错误的.Java ArrayList不会自动缩小(当然,它们会增长).

这是我的问题:

1. 在我看来,提供ArrayLists 缩小不会造成任何伤害,因为性能已经存在amortized O(n).为什么Java创建者没有将此功能包含在设计中？

2. 我知道像HashMaps 这样的其他数据结构也不会自动收缩.Java中是否有其他数据结构构建在支持自动收缩的数组之上？

3. 其他语言的趋势是什么？如果列表,字典,映射,集合在Python/C#等中,自动收缩怎么样？如果它们与Java的作用方向相反,那么我的问题是:为什么？

Git 允许使用以下命令检索提交的哈希值：

git rev-parse HEAD

这给出33b316c 或

git rev-parse --short HEAD

这让33b316cbeeab3d69e79b9fb659414af4e7829a32 我知道实践中长哈希永远不会发生冲突。

在实践中，短哈希值的使用更为频繁。我想知道短的碰撞的概率是多少？git 是否采取任何措施来克服可能的冲突（例如使用时git checkout）？

注意!!知道波兰语或任何其他具有强烈屈曲的自然语言将有很大帮助,最好是使用案例系统(例如德语)来回答这个问题.特别是,波兰语的变形系统非常类似于其他斯拉夫语言的系统,如:俄语,捷克语,塞尔维亚语等.

看看这个波兰语,未完成的,declinator: declinator.com 我打算将它扩展到其他语言,即俄语和拉丁语,但现在我正在与波兰语斗争.

除了拥有数百个名词的大型数据库,我还支持不存在的名词.我想到的最好的解决方案是简单地检查名词的结尾,以便相应地拒绝它们.

在我的代码中,它归结为这种calculateDeclination方法.如果名词不在数据库中,我会调用它.该方法的内脏如下所示:

 if (areLast2Letters(word, "il"))
        declinator = new KamilDeclinator(word);
 else if (areLast2Letters(word, "sk"))
        declinator = new DyskDeclinator(word);
 else if (isLastLetter(word, 'm'))
        declinator = new RealizmDeclinator(word);

这些只是else if这种方法的几十个条款中的前三个.

示例性下降器的代码如下所示:

import static declining.utils.StringUtils.*;

public class RealizmDeclinator extends realizm_XuXowiX_XemXieXieDeclinator{

    public RealizmDeclinator(String noun) {
        super(noun);
    }

    @Override
    protected String calculateStem() {
        return word;
    }

    @Override
    public String calculateLocative() {
        return swap2ndFromEnd(stem, "?") + "ie";
    }

    @Override
    public String calculateVocative() {
        return swap2ndFromEnd(stem, "?") …

看看这些scala片段:如果我们有这样的东西:

List(List(1, 2), List(3, 4), List(5)) map (x => (x.size))

我们可以缩短到:

List(List(1, 2), List(3, 4), List(5)) map ((_.size))

但是,如果我们有这样的事情:

List(List(1, 2), List(3, 4), List(5)) map (x => (x.size, x.size))

为什么我们不能缩短它:

List(List(1, 2), List(3, 4), List(5)) map ((_.size, _.size))

？

如何在其他几个属性中重用配置属性？我简化的现实世界示例如下所示：

myApp {

  host = "www.myfoohost.com"

  urls {
    url1 = host + "/b" // this...
    url2 = host + "/a" // ... and this do not work
  }
}

所以,我想把这个文本分成句子.

s = "You! Are you Tom? I am Danny."

所以我得到:

["You!", "Are you Tom?", "I am Danny."]

这是我想通过正则表达式拆分文本'[.!\?]'而不删除分隔符.在python中实现这个目的的最pythonic方法是什么？

我知道这些问题:

JS string.split()没有删除分隔符

Python split()而不删除分隔符

但我的问题有各种分隔符(.?!)使问题复杂化.

我正在学习 Oracle 的 Stream API Java 1.8 课程，在阅读讲义时偶然发现了这一点：

无序（）：

– 继承自 BaseStream

– 返回一个无序的流（内部使用）

– 可以提高distinct()和groupingBy()等操作的效率

这是我的问题。无序的属性如何导致更有效的计算distinct()和groupingBy()

在 python 中做这个简单的文本修复的干净方法是什么 - 检查每个句号（除了最后一个）后面是否跟有空格。假设点后面没有空格是我们在输入字符串中唯一可能得到的错误。

我正在这样做：

def textFix(text):
    result = re.sub('\.(?!\s)', '. ', text)
    if (result[len(result) - 1]) == ' ':
        return result[:-1]
    return result

用scala查找给定字符串多少次是另一个字符串的子字符串的优雅方法是什么？

以下测试用例应明确要求是什么：

import org.scalatest.FunSuite

class WordOccurrencesSolverTest extends FunSuite {

  private val solver = new WordOccurrencesSolver()

  test("solve for a in a") {
    assert(solver.solve("a", "a") === 1)
  }

  test("solve for b in a") {
    assert(solver.solve("b", "a") === 0)
  }

  test("solve for a in aa") {
    assert(solver.solve("a", "aa") === 2)
  }

  test("solve for b in ab") {
    assert(solver.solve("b", "ab") === 1)
  }

  test("solve for ab in ab") {
    assert(solver.solve("ab", "ab") === 1)
  }

  test("solve for ab in abab") {
    assert(solver.solve("ab", "abab") === 2) …