精华内容
下载资源
问答
  • 如何获取到Java对象地址

    万次阅读 多人点赞 2019-02-02 16:15:31
    final修饰实例时,表示该实例不可以被修改,但是具体是指实例的内存地址不可以被修改? 还是实例里的值不可以被修改?还是实例的内存地址和值都不可以被修改? 其实是蛮简单的一个问题,当fin...

    最近在整理final相关的测试用例,所以对final进行了重新思考,final 可以修饰类、方法、实例、参数!

    1. final修饰类时,表示该类不可以被继承
    2. final修饰方法时,表示该方法不可以被(子类)重写
    3. final修饰实例时,表示该实例不可以被修改,但是具体是指实例的内存地址不可以被修改? 还是实例里的值不可以被修改?还是实例的内存地址和值都不可以被修改?

    其实是蛮简单的一个问题,当final修饰到对象实例时, 表示什么意义,你有真正思考过吗?

    所以我写了一个测试类:

    import com.alibaba.fastjson.JSONObject;
    
    /**
     * final 修饰对象 
     * 
     * @author zhoufy
     * @date 2019年1月24日 下午6:35:26
     */
    public class FinalTest {
    	
    	public static void main(String[] args){
    		FinalTest t = new FinalTest();
    		t.test();
    	}
    	private void test(){
    		final Inner inner = new Inner();
    		print(inner);
    		inner.setId(1);
    		inner.setName("xiao ming");
    		print(inner);
    		inner.setId(2);
    		inner.setName("xiao hong");
    		print(inner);
    	}
    	
    	private void print(Inner inner){
    		System.out.println(inner.hashCode()+" : "+System.identityHashCode(inner)+" : "+JSONObject.toJSONString(inner));
    	}
    	
    	class Inner{
    		private int id;
    		private String name;
    		public int getId() {
    			return id;
    		}
    		public void setId(int id) {
    			this.id = id;
    		}
    		public String getName() {
    			return name;
    		}
    		public void setName(String name) {
    			this.name = name;
    		}
    	}
    }
    

    输出

    366712642 : 366712642 : {“id”:0}
    366712642 : 366712642 : {“id”:1,“name”:“xiao ming”}
    366712642 : 366712642 : {“id”:2,“name”:“xiao hong”}

    走到这里就已经证明了一点:final修饰的对象里的值是可以改变的,那地址呢? 而且还引起了我思考的一个问题haseCode()方法跟System.identityHashCode() 能代表对象的内存地址吗?

    先看一下haseCode()的源码:

    /**
     * Returns a hash code value for the object. This method is
     * supported for the benefit of hash tables such as those provided by
     * {@link java.util.HashMap}.
     * <p>
     * The general contract of {@code hashCode} is:
     * <ul>
     * <li>Whenever it is invoked on the same object more than once during
     *     an execution of a Java application, the {@code hashCode} method
     *     must consistently return the same integer, provided no information
     *     used in {@code equals} comparisons on the object is modified.
     *     This integer need not remain consistent from one execution of an
     *     application to another execution of the same application.
     * <li>If two objects are equal according to the {@code equals(Object)}
     *     method, then calling the {@code hashCode} method on each of
     *     the two objects must produce the same integer result.
     * <li>It is <em>not</em> required that if two objects are unequal
     *     according to the {@link java.lang.Object#equals(java.lang.Object)}
     *     method, then calling the {@code hashCode} method on each of the
     *     two objects must produce distinct integer results.  However, the
     *     programmer should be aware that producing distinct integer results
     *     for unequal objects may improve the performance of hash tables.
     * </ul>
     * <p>
     * As much as is reasonably practical, the hashCode method defined by
     * class {@code Object} does return distinct integers for distinct
     * objects. (This is typically implemented by converting the internal
     * address of the object into an integer, but this implementation
     * technique is not required by the
     * Java&trade; programming language.)
     *  * @return  a hash code value for this object.
     * @see     java.lang.Object#equals(java.lang.Object)
     * @see     java.lang.System#identityHashCode
      */
      public native int hashCode();
    

    这其中有几句话要细细斟酌

    • Returns a hash code value for the object. 返回对象的hash值
    • If two objects are equal according to the equals(Object) method, then calling the hashCode() method on each of the two objects must produce the same value. 如果两个对象相等(根据equals()方法判断),则hashCode()方法返回的值相同
    • It is not required that if two objects are unequal according to the equals(java.lang.Object) method, then calling the hashCode method on each of the two objects must produce distinct integer results. However, developers should be aware that producing distinct integer results for unequal objects improves the performance of hash tables. 当equals()方法返回的不相等,则没有要求hashCode()方法必须返回不同的int值,但是开发人员应该为不相等的对象生成不同的整数结果,这样可以提高hash表的性能

    当看到这已经知道了hashCode()方法返回值不能代表对象的内存地址!!!

    顺便再看一下identityHashCode()方法的源码:

       /**
        * Returns the same hash code for the given object as
        * would be returned by the default method hashCode(),
        * whether or not the given object's class overrides
        * hashCode().
        * The hash code for the null reference is zero.
        *
        * @param x object for which the hashCode is to be calculated
        * @return  the hashCode
        * @since   JDK1.1
        */
       public static native int identityHashCode(Object x);
    

    从方法注释已经看出来,该方法默认返回的跟hashCode()方法同样的值

    如果查看jdk的源码:
    java.lang.System.java类对应的本地c语言的实现——System.c,在 openjdk-8u\jdk\src\share\native\java\lang 目录下

    JNIEXPORT jint JNICALL
    Java_java_lang_System_identityHashCode(JNIEnv *env, jobject this, jobject x)
    {
        return JVM_IHashCode(env, x);
    }
    

    java.lang.Object.java类对应的本地c语言的实现——Object.c,在 openjdk-8u\jdk\src\share\native\java\lang 目录下

    static JNINativeMethod methods[] = {
        {"hashCode",    "()I",                    (void *)&JVM_IHashCode},
        {"wait",        "(J)V",                   (void *)&JVM_MonitorWait},
        {"notify",      "()V",                    (void *)&JVM_MonitorNotify},
        {"notifyAll",   "()V",                    (void *)&JVM_MonitorNotifyAll},
        {"clone",       "()Ljava/lang/Object;",   (void *)&JVM_Clone},
    };
    

    看jdk源说明hashCode()和identityHashCode() 调用的是同一个方法:JVM_IHashCode()
    所以两个方法返回的值相等就对了!

    那如何获取到Java对象的地址呢? 几经查询资料,原来还是有办法的,要通过sun.misc.Unsafe类来实现:

    package com.zhoufy.sun.unsafe.e3;
    
    public class A {
    	private long a;		// not initialized value
    	
    	public A() {
    		this.a = 1;		// initialization
    	}
    	
    	public long a() { return this.a; }
    }
    
    package com.zhoufy.sun.unsafe.e3;
    
    import java.lang.reflect.Field;
    import sun.misc.Unsafe;
    
    /**
     * @author zhoufy
     * @date 2019年2月2日 上午10:29:15
     */
    @SuppressWarnings("restriction")		//取消显示的警告集
    public class ObjectsAddressDemo {
    
    	static final Unsafe unsafe = getUnsafe();
    	static final boolean is64bit = true; // auto detect if possible.
    
    	public static void main(String... args) {
    		A a = new A();
    		
    		//GC前
    		System.out.println("-----------GC前------------");
    		print(a);
    		
    		System.gc();
    		
    		//GC后
    		System.out.println("-----------GC后------------");
    		print(a);
    	}
    
    	private static void print(A a) {
    		// hashcode
    		System.out.println("Hashcode :       " + a.hashCode());
    		System.out.println("Hashcode :       " + System.identityHashCode(a));
    		System.out.println("Hashcode (HEX) : " + Integer.toHexString(a.hashCode()));// Integer.toHexString(int)是将一个整型转成一个十六进制数
    
    		// toString
    		System.out.println("toString :       " + String.valueOf(a));
    
    		//通过sun.misc.Unsafe;
    		printAddresses("Address", a);
    	}
    
    	@SuppressWarnings("deprecation")
    	public static void printAddresses(String label, Object... objects) {
    		System.out.print(label + ":         0x");
    		long last = 0;
    		int offset = unsafe.arrayBaseOffset(objects.getClass());
    		int scale = unsafe.arrayIndexScale(objects.getClass());
    		switch (scale) {
    		case 4:
    			long factor = is64bit ? 8 : 1;
    			final long i1 = (unsafe.getInt(objects, offset) & 0xFFFFFFFFL) * factor;
    			System.out.print(Long.toHexString(i1));
    			last = i1;
    			for (int i = 1; i < objects.length; i++) {
    				final long i2 = (unsafe.getInt(objects, offset + i * 4) & 0xFFFFFFFFL) * factor;
    				if (i2 > last)
    					System.out.print(", +" + Long.toHexString(i2 - last));
    				else
    					System.out.print(", -" + Long.toHexString(last - i2));
    				last = i2;
    			}
    			break;
    		case 8:
    			throw new AssertionError("Not supported");
    		}
    		System.out.println();
    	}
    
    	private static Unsafe getUnsafe() {
    		try {
    			Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
    			theUnsafe.setAccessible(true);
    			return (Unsafe) theUnsafe.get(null);
    		} catch (Exception e) {
    			throw new AssertionError(e);
    		}
    	}
    }
    

    输出:

     -----------GC------------
    Hashcode :       1829164700
    Hashcode :       1829164700
    Hashcode (HEX) : 6d06d69c
    toString :       com.zhoufy.sun.unsafe.e3.A@6d06d69c
    Address:         0x76b4635b8
    -----------GC------------
    Hashcode :       1829164700
    Hashcode :       1829164700
    Hashcode (HEX) : 6d06d69c
    toString :       com.zhoufy.sun.unsafe.e3.A@6d06d69c
    Address:         0x6c1a0a338
    

    当然也可以通过jol工具包里的工具类实现获取对象的内存信息,使用jol工具包需要在maven里引入:

    <dependency>
    	<groupId>org.openjdk.jol</groupId>
    	<artifactId>jol-core</artifactId>
    	<version>0.9</version>
    </dependency>
    

    Java例子:

    package com.zhoufy.sun.unsafe.e3;
    
    import java.lang.reflect.Field;
    
    import org.openjdk.jol.info.GraphLayout;
    import org.openjdk.jol.vm.VM;
    
    import sun.misc.Unsafe;
    
    /** 
     * @author zhoufy
     * @date 2019年2月2日 上午10:29:15
     */
    @SuppressWarnings("restriction")		//取消显示的警告集
    public class ObjectsAddressDemo {
    
    	static final Unsafe unsafe = getUnsafe();
    	static final boolean is64bit = true; // auto detect if possible.
    
    	public static void main(String... args) {
    		A a = new A();
    		
    		//GC前
    		System.out.println("-----------GC前------------");
    		print(a);
    		
    		System.gc();
    		
    		//GC后
    		System.out.println("-----------GC后------------");
    		print(a);
    	}
    
    	private static void print(A a) {
    		//通过sun.misc.Unsafe;
    		printAddresses("Address", a);
    		
    		//通过jol工具包打印对象的地址
    		System.out.println(GraphLayout.parseInstance(a).toPrintable());
    		System.out.println("Current address: " + VM.current().addressOf(a));
    	}
    
    	@SuppressWarnings("deprecation")
    	public static void printAddresses(String label, Object... objects) {
    		System.out.print(label + ":         0x");
    		long last = 0;
    		int offset = unsafe.arrayBaseOffset(objects.getClass());
    		int scale = unsafe.arrayIndexScale(objects.getClass());
    		switch (scale) {
    		case 4:
    			long factor = is64bit ? 8 : 1;
    			final long i1 = (unsafe.getInt(objects, offset) & 0xFFFFFFFFL) * factor;
    			System.out.print(Long.toHexString(i1));
    			last = i1;
    			for (int i = 1; i < objects.length; i++) {
    				final long i2 = (unsafe.getInt(objects, offset + i * 4) & 0xFFFFFFFFL) * factor;
    				if (i2 > last)
    					System.out.print(", +" + Long.toHexString(i2 - last));
    				else
    					System.out.print(", -" + Long.toHexString(last - i2));
    				last = i2;
    			}
    			break;
    		case 8:
    			throw new AssertionError("Not supported");
    		}
    		System.out.println();
    	}
    
    	private static Unsafe getUnsafe() {
    		try {
    			Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
    			theUnsafe.setAccessible(true);
    			return (Unsafe) theUnsafe.get(null);
    		} catch (Exception e) {
    			throw new AssertionError(e);
    		}
    	}
    }
    

    输出:

    -----------GC------------
    Address:         0x76b463440
    com.zhoufy.sun.unsafe.e3.A@119d7047d object externals:
              ADDRESS       SIZE TYPE                       PATH                           VALUE
            76b463440         24 com.zhoufy.sun.unsafe.e3.A                                (object)
    
    
    Current address: 31864534080
    -----------GC------------
    Address:         0x6c1a0aab0
    com.zhoufy.sun.unsafe.e3.A@119d7047d object externals:
              ADDRESS       SIZE TYPE                       PATH                           VALUE
            6c1a0aab0         24 com.zhoufy.sun.unsafe.e3.A                                (object)
    
    
    Current address: 29018335920
    

    从输出信息来看,printAddresses()方法和jol工具类打印的对象的内存地址是一致的,当然如果去深入研究jol工具类,它底层也是通过sun.misc.Unsafe实现的!

    展开全文
  • Java获取对象内存地址

    千次阅读 2020-10-09 21:50:38
    haseCode()方法获取并非...java直接打印对象,结果是十六进制的散列地址值 public class ObjectTest { public static void main(String[] args) { Object obj = new Object(); System.out.println(obj); System.

    haseCode()方法获取并非对象内存地址

    hashCode方法的主要作用是为了配合基于散列的集合一起正常运行,获取对象散列的地址,并非实际内存地址。

    java直接打印对象,结果是十六进制的散列地址值

    public class ObjectTest {
        public static void main(String[] args) {
            Object obj = new Object();
            System.out.println(obj);
            System.out.println(Integer.toHexString(obj.hashCode();
        }
    }
    

    在这里插入图片描述

    haseCode()方法无法证明两个对象是否为同一个对象

    public class ObjectTest {
        public static void main(String[] args) {
            String s1 = "hello";
            String s2 = new String("hello");
            System.out.println(s1.hashCode());
            System.out.println(s2.hashCode());
        }
    }
    

    打印的值都相等,无法区分两个不同的对象
    在这里插入图片描述

    Java 如何获取对象内存地址

    maven引入jol工具包

    <dependency>
        <groupId>org.openjdk.jol</groupId>
        <artifactId>jol-core</artifactId>
        <version>0.9</version>
    </dependency>
    

    示例代码

    public class ObjectTest {
        public static void main(String[] args) {
            String s1 = "hello";
            String s2 = new String("hello");
            System.out.println(s1==s2);
            System.out.println(s1.equals(s2));
            System.out.println("--获取内存地址--");
            System.out.println(VM.current().addressOf(s1));
            System.out.println(VM.current().addressOf(s2));
        }
    }
    

    在这里插入图片描述

    展开全文
  • java对象的内存地址与hashcode值关系

    千次阅读 2020-05-19 12:44:57
    为了比较java对象的内存地址与hashcode的关系,必须想办法获取这两个值 Java不能直接访问操作系统底层,而是通过本地方法来访问。Unsafe类提供了硬件级别的原子操作,在java中内存中的对象地址是可变的,所以获得的...

     

            为了比较java对象的内存地址与hashcode的关系,必须想办法获取这两个值

             Java不能直接访问操作系统底层,而是通过本地方法来访问。Unsafe类提供了硬件级别的原子操作,在java中内存中的对象地址是可变的,所以获得的内存地址有可能会变化。要获得内存地址也只能通过Unsafe的方法来获得,具体下看的代码

     

    package com.test.democlass;
    
    import sun.misc.Unsafe;
    
    import java.lang.reflect.Field;
    
    /**
     * Created by 15002 on 2020/5/19.
     */
    public class AddresserTest {
            private static Unsafe unsafe;
            static {
                try {
                    Field field = Unsafe.class.getDeclaredField("theUnsafe");
                    field.setAccessible(true);
                    unsafe = (Unsafe) field.get(null);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
    
            public static long addressOf(Object o) throws Exception {
                Object[] array = new Object[] { o };
                long baseOffset = unsafe.arrayBaseOffset(Object[].class);
                //arrayBaseOffset方法是一个本地方法,可以获取数组第一个元素的偏移地址
                int addressSize = unsafe.addressSize();
                long objectAddress;
                switch (addressSize) {
                    case 4:
                        objectAddress = unsafe.getInt(array, baseOffset);
                        //getInt方法获取对象中offset偏移地址对应的int型field的值
                        break;
                    case 8:
                        objectAddress = unsafe.getLong(array, baseOffset);
                        //getLong方法获取对象中offset偏移地址对应的long型field的值
                        break;
                    default:
                        throw new Error("unsupported address size: " + addressSize);
                }
                return (objectAddress);
            }
    
            public static void main(String... args) throws Exception {
                String str ="Hello world";
                Object mine = str.toCharArray(); //先把字符串转化为数组对象
                long address = addressOf(mine);
                System.out.println("str的内存地址: " + address);
                System.out.println("str的hashcode: " + str.hashCode());
                // Verify address works - should see the characters in the array in the output
                printBytes(address, 27);
            }
    
            public static void printBytes(long objectAddress, int num) {
                for (long i = 0; i < num; i++) {
                    int cur = unsafe.getByte(objectAddress + i);
                    System.out.print((char) cur);
                }
                System.out.println();
            }
        }
    
    

    运行结果

    str的内存地址: 3804983656
    str的hashcode: -832992604

    所以内存地与hashcode完全不同

     

     

    展开全文
  • 获得java对象的内存地址

    千次阅读 2018-10-24 12:17:31
    Unsafe类提供了硬件级别的原子操作,在java中内存中的对象地址是可变的,所以获得的内存地址有可能会变化。要获得内存地址也只能通过Unsafe的方法来获得,下面类提供了获取java对象内存地址的方法 package ...

        Java不能直接访问操作系统底层,而是通过本地方法来访问。Unsafe类提供了硬件级别的原子操作,在java中内存中的对象地址是可变的,所以获得的内存地址有可能会变化。要获得内存地址也只能通过Unsafe的方法来获得,下面类提供了获取java对象内存地址的方法

    package com.example.demo.othertest;
    import java.lang.reflect.Field;
    import sun.misc.Unsafe;
    
    public class Addresser {
        private static Unsafe unsafe;
    
        static {
            try {
                Field field = Unsafe.class.getDeclaredField("theUnsafe");
                field.setAccessible(true);
                unsafe = (Unsafe) field.get(null);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        public static long addressOf(Object o) throws Exception {
    
            Object[] array = new Object[] { o };
    
            long baseOffset = unsafe.arrayBaseOffset(Object[].class);
            //arrayBaseOffset方法是一个本地方法,可以获取数组第一个元素的偏移地址
            int addressSize = unsafe.addressSize();
            long objectAddress;
            switch (addressSize) {
                case 4:
                    objectAddress = unsafe.getInt(array, baseOffset);
                    //getInt方法获取对象中offset偏移地址对应的int型field的值
                    break;
                case 8:
                    objectAddress = unsafe.getLong(array, baseOffset);
                    //getLong方法获取对象中offset偏移地址对应的long型field的值
                    break;
                default:
                    throw new Error("unsupported address size: " + addressSize);
            }
            return (objectAddress);
        }
    
        public static void main(String... args) throws Exception {
            Object mine = "Hello world".toCharArray(); //先把字符串转化为数组对象
            long address = addressOf(mine);
            System.out.println("Addess: " + address);
    
            // Verify address works - should see the characters in the array in the output
            printBytes(address, 27);
        }
    
        public static void printBytes(long objectAddress, int num) {
            for (long i = 0; i < num; i++) {
                int cur = unsafe.getByte(objectAddress + i);
                System.out.print((char) cur);
            }
            System.out.println();
        }
    }
    

     

    展开全文
  • Java中如何获取对象(引用)地址

    万次阅读 多人点赞 2017-10-31 00:42:02
    如何获取Java中一个对象地址? 首先我们来看第一个问题——对象的hashcode是否是它的地址,这个问题的答案是这个取决于具体的实现,一般来说,它常常是对象的初始地址的整数表示。我们可以从JDK中Object类中...
  • Java中打印对象内存地址

    千次阅读 2019-02-23 20:06:56
    Java一般使用HashCode来代表对象地址,但是两个相同的对象就不行了,两个相同的对象的hashcode是相同的。 如果要对比两个相同的对象地址可以使用,System.identityHashCode(传输进去的参数是一个对象) Date d ...
  • Java 打印一个对象却输出地址

    千次阅读 多人点赞 2019-03-20 15:32:15
    有时候使用System.out.println()方法输出一个类的对象,得到的结果却是该对象地址:类名@12aa35151 这个结果是怎么来的呢? System.out的println()方法只能在控制台输出字符串,有时候比如自己写的person类实例...
  • java对象存储在哪里?

    千次阅读 2020-02-29 14:29:17
    1、寄存器 寄存器是速度最快的存储区域,...常用于存放对象引用与基本数据类型,不存放Java对象。栈内存被要求存放在其中的数据的大小、生命周期必须是已经确定的。 3、堆 通用的内存池,位于RAM中,用于存放所有的...
  • Java基础知识面试题(2020最新版)

    万次阅读 多人点赞 2020-02-19 12:11:27
    文章目录Java概述何为编程什么是Javajdk1.5之后的三大版本JVM、JRE和JDK的关系什么是跨平台性?原理是什么Java语言有哪些特点什么是字节码?采用字节码的最大好处是什么什么是Java程序的主类?应用程序和小程序的...
  • 例如: Dog a=new Dog(); 引用变量a的作用是获得new Dog()所创建对象的位置或者说是地址
  • 使用sun.misc.Unsafe获取java对象地址

    千次阅读 2013-11-13 15:21:26
    当你在论坛上讨论这一点,提出的第一个问题是为什么你需要知道Java对象地址? 它是一种有效的问题。 但以往,我们保留进行试验的权利。探索未知领域的问题并没有什么错。我想出了一个使用sun公司包的实验。Unsafe...
  • java中如何获取对象的内存地址

    千次阅读 2019-08-01 10:59:02
    java中如何查看对象地址:使用System.identityHashCode(“对象”) 即可 eg: Integer i = new Integer(5); System.identityHashCode(i)
  • java对象相等问题

    万次阅读 多人点赞 2019-07-31 19:17:15
    输出结果是true和3,这理解起来很简单,java对象直接"="赋值其实就是将引用传给对方,让他也指向同一个内存地址。 所以如果a改变了里面属性的值,那这个地址存储的内容就变了,当aa去拿的时候就是变了之后的,...
  • Java面试题大全(2020版)

    万次阅读 多人点赞 2019-11-26 11:59:06
    发现网上很多Java面试题都没有答案,所以花了很长时间搜集整理出来了这套Java面试题大全,希望对大家有帮助哈~ 本套Java面试题大全,全的不能再全,哈哈~ 一、Java 基础 1. JDK 和 JRE 有什么区别? JDK:Java ...
  • JVM成神之路-Java对象模型

    千次阅读 2018-07-23 15:01:17
    一个Java对象可以分为三部分存储在内存中,分别是:对象头(Header)、实例数据(Instance Data)和对齐填充(Padding)。 对象头(包含锁状态标志,线程持有的锁等标志) 实例数据 对齐填充 oop-klass model(...
  • java的Object.hashCode()返回的到底是不是对象的内存地址?相信大家都曾对此问题有所怀疑,本文通过实验探究 和 ART(Android Runtime)、OpenJDK的源码分析为大家(和我自己)回答了这个问题。对Java、算法感兴趣或...
  • java面向对象

    万次阅读 多人点赞 2018-08-21 16:51:59
    包括面向对象概念、类与对象的关系、封装、构造函数、this关键字、static关键字、单例设计模式、继承、多态、内部类、异常、包等java基础知识。 1、面向对象 面向对象是相对面向过程而言 面向对象和面向过程都是...
  • java对象结构

    万次阅读 多人点赞 2017-04-19 22:31:57
    在HotSpot虚拟机中,对象在内存中存储的布局可以分为3块区域:对象头(Header)、实例数据(Instance Data)和对齐填充(Padding)。下图是普通对象实例与数组对象实例的数据结构: 对象头 HotSpot虚拟机的...
  • 我们利用JDK中的sun.misc.Unsafe来计算下字段的偏移地址,一则验证下之前文章中的结论,再则跟jol输出结果对比下。...有了字段的偏移地址,在加上对象的起始地,我们就能够通过Unsafe直接获取字段的值了。
  • 浅谈一下JAVA对象,对象引用以及对象赋值

    万次阅读 多人点赞 2013-09-19 00:50:29
    浅谈一下JAVA对象,对象引用以及对象赋值   今天有班级同学问起JAVA对象的引用是什么。正好趁着这次机会,自己总结一下JAVA对象,对象引用以及对象赋值。自己总结了所看到的网上相关方面的不少帖子,整理汇总形成...
  • 如何获得java对象的内存地址

    万次阅读 2018-03-18 12:59:00
    java中内存中的对象地址是可变的,所以获得的内存地址有可能会变化。要获得内存地址也只能通过Unsafe的方法来获得,如下代码片段:Java代码 package com.bijian.study; import java.lang.reflect.Field; ...
  • 解析一个Java对象占用多少内存空间

    千次阅读 2019-07-13 16:02:15
    说明: alignment, 对齐, 比如8字节的数据类型long, 在内存中的起始地址必须是8的整数倍。 padding, 补齐; 在对象所占据空间的末尾,如果有空白, 需要使用padding来补齐, 因为下一个对象的起始位置必须是4/8字节(32bit...
  • JAVA获取对象内存地址

    千次阅读 2018-08-21 17:18:53
    为了观察JVM的GC过程中各个对象所处的位置,需要观察JVM各个对象的内存地址,与年轻代与老年代进行比对,确定对象位置。 package com.memory.tools; import sun.misc.Unsafe; import java.lang.reflect.Field; ...
  • Java面向对象学习】一张图搞定Java面向对象

    千次阅读 多人点赞 2017-09-13 07:56:41
    Java面向对象学习】一张图搞定Java面向对象,分享一些归纳总结后的技术干货,一张图能搞定的事,绝对不长篇大论。 大家都知道,Java面向对象Java的一个核心,也是初学者的一个难点,所以我们从这里开始,Let...
  • 今天闲来无事,有空闲的时间,所以想坐下来聊一聊Java的GC以及Java对象在内存中的分配。 和标题一样,本篇绝对是用最直接最通俗易懂的大白话来聊 文章中基本不会有听起来很高大上专业术语,也不会有太多概念性的...
  • Java对象创建的流程

    千次阅读 2019-05-07 22:05:39
    Java对象创建的流程 文章目录Java对象创建的流程1.Java普通对象的创建1.1new指令1.2分配内存1.3初始化1.4对象的初始设置1.5\方法2.Java对象内存布局2.1对象头2.2实例数据2.3对齐填充 1.Java普通对象的创建 这里讨论...
  • java对象的创建过程

    万次阅读 多人点赞 2018-09-03 20:54:02
    大家都知道,java使用new 关键字进行对象的创建,但这只是从语言层次上理解了对象的创建,下边我们从jvm的角度来看看,对象是怎么被创建出来的,即对象的创建过程。 对象的创建大概分为以下几步: 1:检查类是否...
  • 吃人的那些 Java 名词:对象、引用、堆、栈

    万次阅读 多人点赞 2019-09-05 15:57:09
    作为一个有着 8 年 Java 编程经验的 IT 老兵,说起来很惭愧,我被 Java 当中的四五个名词一直困扰着:**对象、引用、堆、栈、堆栈**(栈可同堆栈,因此是四个名词,也是五个名词)。每次我看到这几个名词,都隐隐...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 832,112
精华内容 332,844
关键字:

java对象的地址

java 订阅