这是我多年来一直想到的事情,但我从来没有花时间问过.
许多(伪)随机数生成器生成0.0到1.0之间的随机数.在数学上,此范围内有无限数,但是double是浮点数,因此具有有限的精度.
所以问题是:
double在0.0和1.0之间有多少个数字？注意:如果它有所不同,我double特别感兴趣的是Java的定义.
我很惊讶在Java源代码中看到System.arraycopy是一个本机方法.
当然原因是因为它更快.但是什么原生技巧是能够使用的代码使其更快？
为什么不循环遍历原始数组并将每个指针复制到新数组 - 当然这不是那么缓慢和麻烦？
因此,对于在布尔二元运算符,Java有&,|,^,&&和||.
让我们简要总结一下他们在这里简要介绍的内容:
对于
&,结果值是true两个操作数值是否为true; 否则,结果是false.对于
|,结果值是false两个操作数值是否为false; 否则,结果是true.对于
^,结果值是true操作数值是否不同; 否则,结果是false.该
&&操作是一样&,但是评估其右边的操作数只有在其左侧操作数的值true.该
||操作是一样|的,但评估其右边的操作数只有在其左侧操作数的值false.
现在,所有5间,那些3有复合赋值版本,分别为|=,&=和^=.所以我的问题是显而易见的:为什么不是Java提供&&=和||=呢？我发现我需要那些比我更需要更多的&=和|=.
而且我不认为"因为它太长"是一个很好的答案,因为Java有>>>=.这个遗漏必须有更好的理由.
java conditional-operator short-circuiting assignment-operator compound-assignment
我希望这行JavaScript:
"foo bar baz".match(/^(\s*\w+)+$/)
返回类似的东西:
["foo bar baz", "foo", " bar", " baz"]
但它只返回最后捕获的匹配:
["foo bar baz", " baz"]
有没有办法获得所有捕获的匹配？
我注意到在Java 6的String源代码中,hashCode只缓存0以外的值.下面的代码片段展示了性能上的差异:
public class Main{
static void test(String s) {
long start = System.currentTimeMillis();
for (int i = 0; i < 10000000; i++) {
s.hashCode();
}
System.out.format("Took %d ms.%n", System.currentTimeMillis() - start);
}
public static void main(String[] args) {
String z = "Allocator redistricts; strict allocator redistricts strictly.";
test(z);
test(z.toUpperCase());
}
}
在ideone.com中运行此命令将提供以下输出:
Took 1470 ms.
Took 58 ms.
所以我的问题是:
为了您的娱乐,这里的每一行都是一个散列为0的字符串:
pollinating sandboxes
amusement & hemophilias
schoolworks = perversive
electrolysissweeteners.net
constitutionalunstableness.net
grinnerslaphappier.org
BLEACHINGFEMININELY.NET
WWW.BUMRACEGOERS.ORG
WWW.RACCOONPRUDENTIALS.NET …合同equals与问候null,如下所示:
对于任何非空引用值
x,x.equals(null)应该return false.
这是相当奇特的,因为如果o1 != null和o2 == null,那么我们有:
o1.equals(o2) // returns false
o2.equals(o1) // throws NullPointerException
这o2.equals(o1) throws NullPointerException是一件好事,因为它提醒我们程序员错误.然而,如果出于各种原因我们只是将其切换到了那个错误就不会被捕获o1.equals(o2),而这只会"默默地失败".
所以问题是:
o1.equals(o2)不应该return false投掷而不是一个好主意NullPointerException？anyObject.equals(null)总是扔掉,那会NullPointerException不是一个坏主意？Comparable相反,这就是Comparable合同所说的:
请注意,这
null不是任何类的实例,并且e.compareTo(null)应该抛出一个NullPointerException偶数e.equals(null)返回false.
如果NullPointerException适合compareTo,为什么不适合equals？
写不好
if (b == false) //...
while (b != true) //...
是不是总是更好,而不是写:
if (!b) //...
while (!b) //...
据推测,性能没有差异(或者存在？),但是如何衡量两者之间的显性,简洁性,清晰度,可读性等？
为了限制主观性,我还要感谢来自权威编码风格指南的任何引用,这些引用始终是优选的,或者在何时使用.
注意:变量名称b仅用作示例,ala foo和bar.
高度重复的代码通常是一件坏事,并且有一些设计模式可以帮助减少这种情况.然而,由于语言本身的限制,有时它是不可避免的.以下示例来自java.util.Arrays:
/**
* Assigns the specified long value to each element of the specified
* range of the specified array of longs. The range to be filled
* extends from index <tt>fromIndex</tt>, inclusive, to index
* <tt>toIndex</tt>, exclusive. (If <tt>fromIndex==toIndex</tt>, the
* range to be filled is empty.)
*
* @param a the array to be filled
* @param fromIndex the index of the first element (inclusive) to be
* filled with the specified value
* @param toIndex …我最近被问到这个面试问题:
您将获得一个几乎已排序的数组,因为每个
N元素可能被错放的k位置不超过正确排序顺序的位置.找到一种节省空间和时间的算法来对数组进行排序.
我有一个O(N log k)解决方案如下.
让我们表示arr[0..n)从索引0(包括)到N(不包括)的数组元素.
arr[0..2k)
arr[0..k)它们处于最终的排序位置......arr[k..2k)可能仍然被错放了k!arr[k..3k)
arr[k..2k)它们处于最终的排序位置......arr[2k..3k)可能仍然被错放了karr[2k..4k)arr[ik..N),然后你就完成了!
2k剩下的元素少于其他元素,那么最后一步可能比其他步骤便宜在每个步骤中,您对大多数2k元素进行排序,在每个步骤O(k log k)结束时将至少k元素放在最终排序位置.有O(N/k)步骤,所以整体复杂性O(N log k).
我的问题是:
O(N log k)最佳的？这可以改进吗？假设我有这段代码:
val string = "one493two483three"
val pattern = """two(\d+)three""".r
pattern.findAllIn(string).foreach(println)
我希望findAllIn只返回483,但相反,它返回了two483three.我知道我可以使用unapply只提取那部分,但我必须有一个整个字符串的模式,如:
val pattern = """one.*two(\d+)three""".r
val pattern(aMatch) = string
println(aMatch) // prints 483
有没有另一种方法来实现这一点,而不使用java.util直接的类,而不使用unapply？