小编Ser*_*nov的帖子

Spring支持两种不同的验证方法:Spring验证和JSR-303 bean验证.两者都可以通过定义一个Spring验证器来使用,该验证器委托给其他委托者,包括bean验证器.到现在为止还挺好.

但是当注释实际请求验证的方法时,这是另一个故事.我可以像这样注释

@RequestMapping(value = "/object", method = RequestMethod.POST)
public @ResponseBody TestObject create(@Valid @RequestBody TestObject obj, BindingResult result) {

或者像这样

@RequestMapping(value = "/object", method = RequestMethod.POST)
public @ResponseBody TestObject create(@Validated @RequestBody TestObject obj, BindingResult result) {

这里,@ Valid是javax.validation.Valid,而@Validated是org.springframework.validation.annotation.Validated.后者的文档说

JSR-303的变体有效,支持验证组的规范.设计方便使用Spring的JSR-303支持,但不支持JSR-303特定.

这没有多大帮助,因为它没有确切地说明它是如何不同的.如果有的话.两者似乎都对我很好.

我正在使用gcc的-fno-rtti标志来编译我的C++而没有运行时类型信息.

假设我没有使用dynamic_cast<>或typeid(),有什么东西可以引导我以后出现问题吗？

我在这里看到了很多关于Java lambdas性能的问题,但是大多数问题都像"Lambdas稍快一点,但在使用闭包时变慢"或"预热与执行时间不同"或其他类似的东西.

但是,我在这里遇到了一件相当奇怪的事情.考虑这个LeetCode问题:

给定一组非重叠间隔,在间隔中插入新间隔(必要时合并).

您可以假设间隔最初是根据其开始时间排序的.

问题被标记为难,所以我认为线性方法不是他们想要的.所以我决定想出一种聪明的方法将二进制搜索与修改结合到输入列表中.现在问题在修改输入列表时并不是很清楚 - 它表示"插入",即使签名需要返回对列表的引用,但现在也不用担心.这是完整的代码,但只有前几行与此问题相关.我在这里保留其余部分,以便任何人都可以尝试:

public List<Interval> insert(List<Interval> intervals, Interval newInterval) {
    int start = Collections.binarySearch(intervals, newInterval,
                                         (i1, i2) -> Integer.compare(i1.start, i2.start));
    int skip = start >= 0 ? start : -start - 1;
    int end = Collections.binarySearch(intervals.subList(skip, intervals.size()),
                                       new Interval(newInterval.end, 0),
                                       (i1, i2) -> Integer.compare(i1.start, i2.start));
    if (end >= 0) {
        end += skip; // back to original indexes
    } else {
        end -= skip; // ditto
    }
    int newStart = newInterval.start;
    int headEnd; …

当我们说mvn test时,通常的方式是maven会查找src/test/java文件夹中的测试.但是我在一些不同的文件夹中进行了测试,即src/integration-test/java.如何通过命令行运行此文件夹中的测试？

提前致谢,

马诺.

我知道从构造函数中调用可覆盖的方法是个坏主意.但我也看到它在Swing中随处可见,其中代码一直add(new JLabel("Something"));出现在构造函数中.

以NetBeans IDE为例.关于构造函数中的可覆盖调用非常挑剔.然而,当它生成Swing代码时,它会将所有这些add()方法调用放入一个initializeComponents()方法中......然后从构造函数中调用它!隐藏问题并禁用警告的好方法(NetBeans没有"从构造函数调用可调覆可覆盖方法的私有方法"警告).但实际上并不是解决问题的方法.

这里发生了什么？我已经做了很多年了,但总是对此感到不安.有没有更好的方法来初始化Swing容器,除了制作一个额外的init()方法(并且不要忘记每次都调用它,这有点无聊)？

例

这是一个非常人为的例子,说明事情可能出错:

public class MyBasePanel extends JPanel {
    public MyBasePanel() {
        initializeComponents();
    }

    private void initializeComponents() {
        // layout setup omitted
        // overridable call
        add(new JLabel("My label"), BorderLayout.CENTER);
    }
}

public class MyDerivedPanel extends MyBasePanel {
    private final List<JLabel> addedLabels = new ArrayList<>();

    @Override
    public void add(Component comp, Object constraints) {
        super.add(comp);
        if (comp instanceof JLabel) {
            JLabel label = (JLabel) comp;
            addedLabels.add(label); // NPE here
        } …

Qt 4是一种编程语言吗？它可以被视为Java和Python的替代品吗？它可以用于在Linux中开发用户交互软件吗？

我以为我理解序列点在C++中是如何工作的,但是这个GeeksQuiz问题困惑了我:

int f(int &x, int c) {
    c = c - 1;
    if (c == 0) return 1;
    x = x + 1;
    return f(x, c) * x;
}

int main() {
    int p = 5;
    cout << f(p, p) << endl;
    return 0;
}

这个问题的"正确"答案是它打印6561.事实上,在VS2013中确实如此.但是不管它是UB,因为没有保证会首先评估:f(x, c)或者x.如果f(x, c)首先被评估,我们得到6561 :整个事情变成五个递归调用:前四个(c = 5, 4, 3, 2)继续,最后一个(c = 1)终止并返回1,这9 ** 4最终相当于.

但是,如果x首先进行评估,那么我们就会得到6 * 7 * 8 * 9 * …

有没有一种方法可以同时测试类（如您可以在JUnit 4中使用Parameterized和进行参数化@Parameters）和测试方法（如您可以在JUnit 4或@ParameterizedTestJUnit 5中使用JUnitParams进行参数化）的参数？我需要最后获取参数的笛卡尔积。

java.nio.ByteBuffer使用所需方法的部分测试示例：

public class ByteBufferTest {
    private static final int BUFFER_SIZE = 16384;
    private final ByteOrder byteOrder;
    private ByteBuffer sut;

    @Factory(dataProvider = "byteOrders")
    public ByteBufferTest(ByteOrder byteOrder) {
        this.byteOrder = byteOrder;
    }

    @DataProvider
    public static Object[][] byteOrders() {
        return new Object[][] {
                {ByteOrder.BIG_ENDIAN},
                {ByteOrder.LITTLE_ENDIAN}
        };
    }

    @BeforeMethod
    public void setUp() {
        sut = ByteBuffer.allocate(BUFFER_SIZE);
        sut.order(byteOrder);
    }

    @Test(dataProvider = "validPositions")
    public void position(int position) {
        System.out.println(byteOrder + " position " + position); …

按位运算符处理位,逻辑运算符计算布尔表达式.只要表达式返回bool,为什么我们不使用按位运算符而不是逻辑？

在这个例子中,我使用按位而不是逻辑:

#include <iostream>


int main(){

    int age;
    std::cin >> age;

    if( (age < 0) | (age > 100) ) // eg: -50: 1 | 0 = 1
        std::cout << "Invalid age!" << std::endl;

//  if( (age < 0) || (age > 100) )
//      std::cout << "Invalid age!" << std::endl;

  return 0;
}

考虑这个愚蠢的域名:

namespace TryHibernate.Example
{
    public class Employee
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }

    public class WorkItem
    {
        public int Id { get; set; }
        public string Description { get; set; }
        public DateTime StartDate { get; set; }
        public DateTime EndDate { get; set; }
    }

    public class Task
    {
        public int Id { get; set; }
        public Employee Assignee { get; set; }
        public WorkItem WorkItem { get; set; …