小编shr*_*000的帖子

对于Sun/Oracle的JVM,我读过GC algo将新一代划分为一个Eden区域和两个幸存区域.我想知道的是,为什么两个幸存者地区而不仅仅是一个？算法可以在伊甸园和一个幸存者区域之间保持乒乓(目前两个幸存者区域之间的方式); 或者这种方法有什么缺点吗？

为什么这种比较会让我"假"？我查看了源代码并将Float.NaN定义为

/** 
 * A constant holding a Not-a-Number (NaN) value of type
 * <code>float</code>.  It is equivalent to the value returned by
 * <code>Float.intBitsToFloat(0x7fc00000)</code>.
 */
public static final float NaN = 0.0f / 0.0f;

编辑:令人惊讶的是,如果我这样做:

System.out.println("FC " + (Float.compare(Float.NaN, Float.NaN)));

它给了我0.因此,Float.compare()不认为NaN的是等于本身!

Javadoc提到Object类有一个public no-arg构造函数.但是Object的源代码中没有任何显式的构造函数.显然编译器为它生成了一个.但是,如果我在构造函数即将返回时看到调用堆栈跟踪(如下所示),我Object.<init>在该跟踪中看不到任何调用.

所以问题是,Object类是否有一个默认的构造函数,正如doc所说的那样？如果是,为什么我在调用堆栈跟踪中看不到它？

public ConTest()
{
    new Throwable().printStackTrace();
}

结果:

java.lang.Throwable
    at ConTest.<init>(ConTest.java:8)
    at ConTest.main(ConTest.java:16)

我在网上读到的关于Singleton设计模式的许多文章都提到该类应该覆盖'clone()'方法,并在其中抛出'CloneNotSupported'异常.这真的有必要吗？

默认情况下,clone()方法是受保护的,因此没有类(同一个包中的类除外)能够在该Singleton实例上调用它.另外,如果此Singleton没有实现Cloneable,那么即使调用此方法,它也会产生运行时异常.另外,构造函数是私有的,我们将无法对其进行子类化,从而允许进行克隆.那么我还应该为我的Singleton类实现这个建议吗？

编辑:只是澄清:我不是在寻找实现Singleton的最佳方法.我只是询问上面提到的建议的有效性,以及"正常"的Singleton模式(而不是基于Enum的Singleton).

我读过很多关于这个主题的书籍和文章,以及我用'Unsafe'编写的一个小程序,表明Java中的1-d数组在内存中总是连续的.它是由JLS规定还是实施惯例？要求提出这个问题.

如果我的Dao层抛出Dao特定异常,那么在我的服务层处理它们是否会引起关注？如果是,那么我应该使异常通用且独立于任何层来解决它,还是有其他方法？

同样的问题适用于服务层抛出的UI层处理异常.

我知道适用于一般不可变类的通常原因,即

1. 不能改变作为副作用
2. 很容易理解他们的状态
3. 固有的线程安全
4. 无需提供克隆/复制构造函数/工厂复制方法
5. 实例缓存
6. 不需要防御性副本.

但是,包装类表示基本类型,基本类型是可变的.那么为什么封装类不可变？

据说Java的默认序列化机制效率不高,因为a)它发现通过反射写入/读取的字段通常很慢b)它将额外的数据写入流.

提高效率的一种方法是实现Externalizable及其writeExternal/readExternal方法.

这里的问题是:如果我改为提供'writeObject/readObject'方法并且不在其中调用deafiltWriteObject/defaultReadObject,那么这个机制将不会使用反射来确定要写入/读取的字段,而且它不会写入额外的要流式传输的数据(还是不确定)？那么从效率的角度来看,实现上面提到的writeObject/readObject与实现Externalizable一样吗？或者后一种选择是否会带来一些前者不具备的实际效益？

编辑:当然,差异是当实现readObject/writeObject的Serializable类被子类化时,如果子类有自己的readObject/writeObject,则它们不需要调用super的readObject/writeObject.如果超级/子类改为实现Externalizable,则不是这样.在这种情况下,需要显式调用super的writeExternal/readExternal.然而,从效率的角度来看,这种差异是无关紧要的.

我有以下java类:

class Outer
{
    private Integer a;
    private Long b;

    class Inner
    {
        public void foo()
        { 
            System.out.println("a and b are " + a + " " + b);
        }
    }
}

当我在Outer和Outer $ Inner上运行javap时,我得到以下内容:

C:\test>javap Outer
Compiled from "Outer.java"
class Outer extends java.lang.Object{
    Outer();
    static java.lang.Integer access$000(Outer);
    static java.lang.Long access$100(Outer);
}

C:\test>javap Outer$Inner
Compiled from "Outer.java"
class Outer$Inner extends java.lang.Object{    
    final Outer this$0;
    Outer$Inner(Outer);
    public void foo();
}

我有两个问题:

1)为什么java编译器生成静态方法,在外层使用'Outer'参数来访问其私有变量？为什么不是内部类可以通过它的这个$ 0成员轻松调用的实例方法？

2)为什么内部班级的0美元成为最终？如果不是最终会发生什么？

感谢致敬.

我有Outer一个private Inner班级.

在我的Outer类方法中,我Inner按如下方式实例化该类:

Outer outer = new Outer();
Inner inner = outer.new Inner();

编译器将此代码转换为:

Outer outer = new Outer();
Inner inner = new Inner(outer, null);

使用反射显示Inner该类具有以下合成构造函数:

private Outer$Inner(Outer)
Outer$Inner(Outer,Outer$Inner)

由于Inner类是private,编译器将该private构造函数添加到它,因此没有人可以实例化该类.但显然Outer该类应该能够实例化它,因此编译器会添加其他包私有构造函数,后者又调用私有构造函数.此外,由于package-private构造函数$在其名称中具有该名称,因此普通Java代码无法调用它.

问题:为什么要合成一个私有和一个包私有构造函数？为什么不合成package-private构造函数并完成呢？