标签: idiomatic

你会如何Map在Java中初始化静态？

方法一:静态初始化
方法二:实例初始化(匿名子类)还是其他一些方法？

各自的优点和缺点是什么？

这是一个说明两种方法的示例:

import java.util.HashMap;
import java.util.Map;

public class Test {
    private static final Map<Integer, String> myMap = new HashMap<Integer, String>();
    static {
        myMap.put(1, "one");
        myMap.put(2, "two");
    }

    private static final Map<Integer, String> myMap2 = new HashMap<Integer, String>(){
        {
            put(1, "one");
            put(2, "two");
        }
    };
}

我试图在Java中反转一个int数组.

此方法不会反转数组.

for(int i = 0; i < validData.length; i++)
{
    int temp = validData[i];
    validData[i] = validData[validData.length - i - 1];
    validData[validData.length - i - 1] = temp;
}

这有什么问题？

我只是想知道我应该使用std::size_tfor循环和东西而不是int？例如:

#include <cstdint>

int main()
{
    for (std::size_t i = 0; i < 10; ++i) {
        // std::size_t OK here? Or should I use, say, unsigned int instead?
    }
}

一般来说,何时使用的最佳做法是什么std::size_t？

在这个问题中,出现了一个问题,可以通过改变将泛型类型参数用于关联类型的尝试来解决.这引发了一个问题"为什么相关类型在这里更合适？",这让我想知道更多.

引入相关类型的RFC说:

此RFC通过以下方式阐明特征匹配:

• 将所有特征类型参数视为输入类型,和
• 提供相关类型,即输出类型.

RFC使用图形结构作为激励示例,这也在文档中使用,但我承认不完全理解相关类型版本相对于类型参数化版本的好处.主要的是该distance方法不需要关心Edge类型.这很好,但似乎有一点点关联类型的原因.

我发现在实践中使用相关类型非常直观,但在决定在我自己的API中何时何地使用它们时,我发现自己很挣扎.

在编写代码时,何时应该在泛型类型参数上选择关联类型,何时应该相反？

我有一个容纳数据的容器类.创建容器时,有不同的方法来传递数据.

1. 传递包含数据的文件
2. 通过参数直接传递数据
3. 不要传递数据; 只需创建一个空容器

在Java中,我将创建三个构造函数.以下是在Python中可能出现的情况:

class Container:

    def __init__(self):
        self.timestamp = 0
        self.data = []
        self.metadata = {}

    def __init__(self, file):
        f = file.open()
        self.timestamp = f.get_timestamp()
        self.data = f.get_data()
        self.metadata = f.get_metadata()

    def __init__(self, timestamp, data, metadata):
        self.timestamp = timestamp
        self.data = data
        self.metadata = metadata

在Python中,我看到了三个明显的解决方案,但它们都不是很漂亮:

答:使用关键字参数:

def __init__(self, **kwargs):
    if 'file' in kwargs:
        ...
    elif 'timestamp' in kwargs and 'data' in kwargs and 'metadata' in kwargs:
        ...
    else:
        ... create empty container

B:使用默认参数:

def …

我正在尝试在scala集合中搜索与某个谓词匹配的列表中的项目.我不一定需要返回值,只测试列表是否包含它.

在Java中,我可能会这样做:

for ( Object item : collection ) {
    if ( condition1(item) && condition2(item) ) {
       return true;
    }
}
return false;

在Groovy中,我可以做类似的事情:

return collection.find { condition1(it) && condition2(it) } != null

在Scala中执行此操作的惯用方法是什么？我当然可以将Java循环样式转换为Scala,但我觉得有一种更实用的方法可以做到这一点.

我经常在这里看到某人的代码以及看起来像是"单行"的内容,这是一个单行语句,以传统的'if'语句或'for'循环的标准方式执行.

我已经google了,无法真正找到你能演出的那种？任何人都可以提出建议并最好举一些例子吗？

例如,我可以在一行中执行此操作:

example = "example"
if "exam" in example:
    print "yes!"

要么:

for a in someList:
    list.append(splitColon.split(a))

只是想知道是否有一个Ruby习惯用法从索引中提取子字符串直到字符串结尾.我知道str[index..-1]它在一个范围内的对象传递给工作String的[]方法,但它是一个有点笨拙.例如,在python中,您可以编写str[index:]哪些内容可以隐式地获取字符串的其余部分.

例:

s = "hello world"
s[6..-1] # <-- "world"

还有什么比这更好的s[6..-1]吗？

为了学习和进一步解决这个问题,我一直很好奇一种算法的显式递归的惯用替代方法,该算法检查列表(或集合)是否有序.(我在这里通过使用运算符进行比较和Int作为类型来保持简单;我想在深入研究它的泛型之前先查看算法)

基本的递归版本将是(由@Luigi Plinge提供):

def isOrdered(l:List[Int]): Boolean = l match {
  case Nil => true
  case x :: Nil => true
  case x :: xs => x <= xs.head && isOrdered(xs)
}

表现不佳的惯用方法是:

def isOrdered(l: List[Int]) = l == l.sorted

使用fold的替代算法:

def isOrdered(l: List[Int]) =
  l.foldLeft((true, None:Option[Int]))((x,y) =>
    (x._1 && x._2.map(_ <= y).getOrElse(true), Some(y)))._1

它的缺点是它将比较列表中的所有n个元素,即使它在找到第一个无序元素之后可以提前停止.有没有办法"停止"折叠,从而使这个更好的解决方案？

还有其他(优雅的)替代品吗？

List和cons运算符(:)在Haskell中非常常见.缺点是我们的朋友.但有时我想添加到列表的末尾.

xs `append` x = xs ++ [x]

遗憾的是,这不是实施它的有效方式.

我在Haskell中写了Pascal的三角形,但我不得不使用++ [x]反成语:

ptri = [1] : mkptri ptri
mkptri (row:rows) = newRow : mkptri rows
    where newRow = zipWith (+) row (0:row) ++ [1]

imho,这是一个可爱的可读Pascal的三角形和所有,但反成语让我烦恼.有人可以向我解释(并且,理想情况下,指向一个很好的教程)关于您想要有效追加到最后的情况下的惯用数据结构吗？我希望这个数据结构及其方法具有近似列表般的美感.或者,或者,向我解释为什么这种反成语对于这种情况实际上并不坏(如果你认为是这种情况).

[编辑]我最喜欢的答案是Data.Sequence,它确实具有"近似列表般的美丽".不确定我对操作所要求的严格程度.随时欢迎进一步的建议和不同的想法.

import Data.Sequence ((|>), (<|), zipWith, singleton)
import Prelude hiding (zipWith)

ptri = singleton 1 : mkptri ptri

mkptri (seq:seqs) = newRow : mkptri seqs
    where newRow = zipWith (+) seq (0 <| seq) |> 1 …