小编flo*_*oon的帖子

如何比较Java之间的日期？

例:

date1是22-02-2010
date2,07-04-2010今天
是date325-12-2010

date3总是大于date1而且date2永远是今天.如何验证今天的日期是否在date1和date3之间？

我想为我正在进行的游戏实现一个检查点系统,为此我需要复制一个级别内的所有可变对象,以便创建一个级别的独立副本.在一个简化的例子中,我的类看起来像这样:

public class GameObject
{
    ...
    private Level level;
    ...
}

public class Level
{
    ...
    private List<GameObject> gameObjects;
    ...
}

但是有一个问题:当我想要复制一个级别及其对象时,引用变得不一致.例如,我可以深度复制我的Level-instance并深度复制所有gameObjects.但是当我这样做时,GameObject中的Level-reference不再指向"正确"(新)级别.在这种情况下,我可以为每个对象调用一个方法并重置其级别.但随着越来越多类型的对象被包含,这将变得越来越复杂,因为对象可能或可能没有自己创建的对象集,然后这些引用也必须更新等等.

是否存在类似于这种情况的设计模式,或任何特定于Java的问题,使这个问题变得更容易？

编辑

我刚才有一个想法:如何为每个GameObject创建一些包装类,如下所示:

public class GameObjectWrapper
{
    ...
    private long gameObjectID;
    private Level level;
    ...
}

这将作为对需要引用的所有对象的引用.每个GameObject都会获得一个唯一的id,而level将有一个地图将每个id链接到一个真实的GameObject(类似的东西GameObject Level.getObject(long id)).虽然这可能会奏效,但我仍然觉得必须有更好的解决方案.

编辑:进一步澄清

似乎我没有让我的问题足够清楚,所以我将简化并概括一点:

我有两个示例对象(objectA和objectB):objectA包含对它的引用objectB并objectB包含对它的引用objectA.

像这样的东西:

public class MyObject
{
   private MyObject partner;

   ...

   public MyObject shallowCopy()
   {
        return new MyObject(partner);
   }
}

我想复制两者.使用浅拷贝,我得到两个新对象:newObjectA和newObjectB …

在下面的代码中,它在使用类名传递方法引用变量时起作用,但是当使用用户对象传递引用变量时会出现错误.

public class User {
    private String name;

    public User(String name) {
        this.name = name;
    }

    public void printName() {
        System.out.println(name);
    }    
}


public class Main {
    public static void main(String[] args) {
        User u1 = new User("AAA");
        User u2 = new User("BBB");
        User u3 = new User("ZZZ");

        List<User> userList = Arrays.asList(u1, u2, u3);        

        userList.forEach(User::printName); // works
        userList.forEach(u1::printName); // compile error
    }
}

今天我意识到一些对我来说很奇怪的事情:当我这样做时,我注意到了

try {
    doSomething();
} catch (Exception e) {
}

它并不比我刚刚做的慢

doSomething();

所以我运行了一个测试并写下了一些快速代码来证明我所看到的,代码基本上只是循环遍历一个名为doS​​omething()的函数很多次,一次没有,一次是try-catch包围它.如果您想自己测试它,那么这里是代码:

public class Main {

private static final long LOOPS = 1000000L;

public static final void main(String[] args)
{
    System.out.println("Loop without try catch: "+loopWithoutTryCatch(LOOPS));
    System.out.println("Loop with try catch: "+loopWithTryCatch(LOOPS));
}

public static long loopWithoutTryCatch(long loops)
{
    long startTime = System.currentTimeMillis();

    for (long i = 0L; i < loops; i++)
    {
        doSomething();
    }

    return System.currentTimeMillis()-startTime;
}

public static long loopWithTryCatch(long loops)
{
    long startTime = System.currentTimeMillis();

    for (long i …

我最初想用Java中的浮点性能优化来测试一些不同的东西,即除法5.0f和乘法之间的性能差异0.2f(乘法似乎在没有预热的情况下更慢,但分别在1.5倍左右更快).

在研究结果后,我注意到我忘记添加一个预热阶段,正如在进行性能优化时经常建议的那样,所以我添加了它.而且,令我完全惊讶的是,在多次测试运行中,平均速度提高了约25倍.

我用以下代码测试了它:

public static void main(String args[])
{
    float[] test = new float[10000];
    float[] test_copy;

    //warmup
    for (int i = 0; i < 1000; i++)
    {
        fillRandom(test);

        test_copy = test.clone();

        divideByTwo(test);
        multiplyWithOneHalf(test_copy);
    }

    long divisionTime = 0L;
    long multiplicationTime = 0L;

    for (int i = 0; i < 1000; i++)
    {
        fillRandom(test);

        test_copy = test.clone();

        divisionTime += divideByTwo(test);
        multiplicationTime += multiplyWithOneHalf(test_copy);
    }

    System.out.println("Divide by 5.0f: " + divisionTime);
    System.out.println("Multiply with 0.2f: " + multiplicationTime);
} …

所以我有这个测试程序,它检查一个整数的二进制值是正的而另一个是负的.

int i = 100;
int i2 = -100;

System.out.println(Integer.toBinaryString(i));
System.out.println(Integer.toBinaryString(i2));

结果:

1100100
11111111111111111111111110011100

正如你可以看到负数比正数有更多的位数,这是否意味着负数比正数消耗更多的内存？