我知道随机UUID在理论上具有非常非常非常低的碰撞概率,但我想知道,在实践中,Java 5 randomUUID()在没有碰撞方面有多好？有没有人有经验可以分享？
所以，我只是在阅读访问者模式，我发现访问者和元素之间的来回非常奇怪！
基本上我们称之为元素，我们将其传递给访问者，然后元素将自身传递给访问者。然后访问者操作元素。什么？为什么？感觉太没必要了。我称之为“来回疯狂”。
因此，当需要在所有元素上实施相同的操作时，访问者的意图是将元素与其操作分离。这样做是为了防止我们需要用新动作扩展我们的元素，我们不想进入所有这些类并修改已经稳定的代码。所以我们在这里遵循开放/封闭原则。
为什么会有这一切来回，如果我们没有这些，我们会失去什么？
例如，我编写的这段代码记住了这个目的，但跳过了访问者模式的疯狂交互。基本上我有会跳跃和进食的动物。我想将这些动作与对象分离，所以我将动作移到了访客。吃和跳会增加动物的健康（我知道，这是一个非常愚蠢的例子......）
public interface AnimalAction { // Abstract Visitor
public void visit(Dog dog);
public void visit(Cat cat);
}
public class EatVisitor implements AnimalAction { // ConcreteVisitor
@Override
public void visit(Dog dog) {
// Eating increases the dog health by 100
dog.increaseHealth(100);
}
@Override
public void visit(Cat cat) {
// Eating increases the cat health by 50
cat.increaseHealth(50);
}
}
public class JumpVisitor implements AnimalAction { // ConcreteVisitor
public void visit(Dog dog) {
// Jumping increases the dog …我在看android开发文档,我看到了这个:
public abstract class Buffer
extends Object
Known Direct Subclasses:
ByteBuffer, CharBuffer, DoubleBuffer, FloatBuffer, IntBuffer, LongBuffer, ShortBuffer
Known Indirect Subclasses:
MappedByteBuffer
Buffer是一个无法实例化的抽象类.它继承(extends)Object.
但我对Direct和Indirect子类感到困惑.我最好的猜测是:
Buffer直接从超类扩展.
Object它从一个直接扩展所讨论的类的超类扩展而来.
非常感谢任何建议,
当我在Workbench窗口外拖动视图时,视图将变为分离视图.
eclipse帮助说(Workbench用户指南 - >任务 - >使用视图和编辑器 - >分离视图和编辑器):"要恢复要在Workbench窗口内显示的视图,请将视图选项卡拖到Workbench窗口中."
使用我的配置(Windows 7; 2个屏幕;按下最大化按钮可以在两个屏幕之一中最大化eclipse),这不起作用.
我必须使用"Windows - > Restore Perspective ..."来获取Workbench内部的视图.
是否还有其他方法可以重新附加分离视图？
我有一堆@ParameterizedTest从 a 接收参数的s@MethodSource具有非常详细的toString()结果（例如 Selenium 的WebDriver）。这些默认情况下用于组成相应的显示名称。从JUnit 5 用户指南：
默认情况下，参数化测试调用的显示名称包含调用索引和该特定调用的所有参数的字符串表示。但是，您可以通过注释的
name属性自定义调用显示名称@ParameterizedTest[…]
虽然这允许在一定程度上自定义显示名称，但似乎我无法调整各个参数的字符串表示形式。不幸的是，指定生成器@DisplayNameGeneration只能在类级别应用，并且不会影响参数化测试调用的显示名称。
有没有办法使用DisplayNameGeneratorfor@ParameterizedTest或自定义给定参数的字符串表示？
想象一下以下的树:
A
/ \
B C
/ \ \
D E F
我正在寻找一种方法来查询例如F是否是A的后代(注意:F不需要是F 的直接后代),在这种情况下,这将是真的.只需要针对较大的潜在后代节点池测试有限数量的潜在父节点.
更新:在测试节点是否是潜在父池中节点的后代时,需要针对所有潜在父节点对其进行测试.
这是一个想法:
将多路树转换为trie,即将以下前缀分配给上述树中的每个节点:
A = 1
B = 11
C = 12
D = 111
E = 112
F = 121
然后,为每个可能的前缀大小保留一个位数组,并添加要测试的父节点,即如果将C添加到潜在的父节点池,请执行以下操作:
1 2 3 <- Prefix length
*[1] [1] ...
[2] *[2] ...
[3] [3] ...
[4] [4] ...
... ...
当测试节点是否是潜在父节点的后代时,取其trie前缀,查找第一个"前缀数组"中的第一个字符(见上文),如果存在,则在第二个"前缀中查找第二个前缀字符数组"依此类推,即测试F导致:
F = 1 2 1
*[1] [1] ...
[2] *[2] ...
[3] [3] ...
[4] [4] ...
... ...
所以是的,F是C.的后代.
这个测试似乎是最坏的情况O(n),其中n …
在java中我们假设我们有两个类和A,这样B继承A和A有3个私有字段和构造函数有三个参数
public class A {
private int a ;
private int b ;
private int c ;
public A(int a, int b, int c) {
this.a = a;
this.b = b;
this.c = c;
}
}
这是B级
public class B extends A {
public B() {
super(1,2,3);
}
}
我们考虑以下测试类
public class TestA {
public static void main(String[] args) {
A a = new A(1,2,3);
B b = new B();
}
}
问题是在创建具有私有字段的类A并由类B继承它时,堆中的有序进程是什么？在创建这两个类的实例时,堆中会发生什么？内存分配是如何发生的以及类如何在计算机memry中进行交互？
我们也知道子类不能继承其超类的私有字段,那么在A调用构造函数时会发生什么呢？
我有一些对象.我需要从Set中获取两个min对象.
我的例子如下:
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class Example {
public static void main( String[] args ) {
SomeObject obj1 = new SomeObject(1);
SomeObject obj2 = new SomeObject(2);
SomeObject obj3 = new SomeObject(3);
Set<SomeObject> set = Stream.of(obj1,obj2,obj3)
.collect(Collectors.toSet());
SomeObject minObject= set.stream()
.min(Comparator.comparingInt(object->object.getValue()))
.get();
System.out.println(minObject);
}
}
class SomeObject{
private int value;
SomeObject(int value){
this.value=value;
}
public int getValue() {
return value;
}
@Override
public String toString() {
return this.value+"";
}
}
在我的例子中,我可以根据value属性从这个Set中获取min对象.
所以,我需要使用java流操作获取两个最小值.
awnser应该很快,因为在我的真实程序中,我多次调用此方法,我的集合非常大.
我有一个域模型类，该类具有toString实现，如下所示：
public String toString() {
try {
return getX() + "\n"
getY() + "\n"
getZ(); //etc.
} catch(Exception e) {
throw new RuntimeException(e);
}
}
的方法getX()，getY()和getZ()不是简单的吸气剂，它们可以在后台预定义的键-值对的静态地图执行查找，通常查找。他们throws SomeCheckedException中有些人签名。
我的印象是，这是不好的做法，并且有“代码异味”。toString()甚至需要进行此检查的事实对我来说都是不良设计的征兆。但我的一位同事，究竟是错捕的一般要求Exception在toString()，因为抓住了Exception进一步传播。
我认为它至少违反了KISS原则，因为这样的简单方法toString()表示需要特殊的异常处理。
那么在toString（）中包含一个包罗万象的块是否有代码味道？
我发现的答案是针对捕获通用的一般情况，Exception而我大多数人都同意，如果您正在执行通用错误处理机制或批处理，那么它有望适用于通用异常。这个论点在我们的讨论中没有说服力，所以我很好奇其他观点。
所以,我一直在用lambdas学习Kotlin和Java.尽管我对函数式编程知之甚少,但我还是尝试使用大部分功能性编程.
我正在使用HackerRank的问题来研究(和Koans一起研究Kotlin).我目前正在使用Kotlin和Java 8解决问题.
我正在尝试解决MiniMax-Sum问题https://www.hackerrank.com/challenges/mini-max-sum/.
基本上,描述是这样的:
给定五个正整数,找到可以通过对五个整数中的四个进行求和来计算的最小值和最大值.然后将相应的最小值和最大值打印为两个以空格分隔的长整数的单行.
我正在尝试使用Java中的大部分流API.简单的问题是:如何在排序之后将int数组首先减少到它的四个(以及最后一个,在不同的场景中)并将其值相加？我试图使用IntStream,但似乎没有使用List是非常困难的.我想知道是否可以直接使用int []数组与IntStream来排序和减少元素,并将它们相加.
使用Kotlin我这样解决了:
val minSum: Long = arr.sortedArray().copyOfRange(0, 4).sum().toLong()
val maxSum: Long = arr.sortedArray().copyOfRange(1, 5).sum().toLong()
println("$minSum $maxSum")
我正在尝试使用范围方法,与sort和sum一起使用.有用.问题是sum总是返回一个int,有时sum是一个long值.这是我的代码:
long min = IntStream.range(0, arr.length)
.sorted()
.sum();
long max = IntStream.range(1, arr.length + 1)
.sorted()
.sum();
结果是输入的10(min)和15(max) IntStream
非常感谢花时间提供帮助的每个人!猜猜我没有看到List方法:DI使用2种不同的方式解决(由@ Aomine,@ nullpointer和@Holger指出):
// using Arrays and Stream
Arrays.sort(arr);
long min = Arrays.stream(arr, 0, 4).sum();
long max = Arrays.stream(arr, 1, 5).sum();
System.out.println(min + " " + max);
// and using LongSummaryStatistics (thanks …