精华内容
下载资源
问答
  • JAVA属性拷贝,属性为空不进行拷贝

    千次阅读 2019-10-17 20:22:45
    最近在写项目的过程中,由于分层关系,经常会进行对象间的属性拷贝。但是源对象有空属性的又不想拷贝,不管是Apache的还是springframework的都会直接将空值也赋值过去。所以自己写了一个工具来实现,仅供参考: ...

      最近在写项目的过程中,由于分层关系,经常会进行对象间的属性拷贝。但是源对象有空属性的又不想拷贝,不管是Apache的还是springframework的都会直接将空值也赋值过去。所以自己写了一个工具来实现,仅供参考:

    public class BeanUtil {
    
        /**
         * source属性为空的不赋值给target
         * @param source
         * @param target
         */
        public static void beanCopierNotNull(Object source,Object target){
            CopyConverter copyConverter = new CopyConverter(target);
            BeanCopier copier = BeanCopier.create(source.getClass(),target.getClass(),true);
            copier.copy(source,target,copyConverter);
        }
    }
    
    import org.apache.commons.lang.StringUtils;
    import org.apache.commons.lang.exception.ExceptionUtils;
    import org.apache.commons.lang.reflect.FieldUtils;
    import org.springframework.cglib.core.Converter;
    import org.springframework.util.ObjectUtils;
    
    /**
     * @author zhangweiqiang
     * @Description
     */
    public class CopyConverter implements Converter {
        private static Log log = LogFactory.getLog(CopyConverter.class);
    
        private Object targetObject;
    
        @Override
        public Object convert(Object value, Class targetClass, Object context) {
            try {
                if (ObjectUtils.isEmpty(value)) {
                    String name = StringUtils.substring(ObjectUtils.nullSafeToString(context), 3);
                    String fiedName = StringUtils.uncapitalize(name);
                    return FieldUtils.readField(targetObject, fiedName, true);
                }
    
            } catch (Exception e) {
                log.debug(ExceptionUtils.getFullStackTrace(e));
            }
    
            return value;
        }
    
        public CopyConverter(Object targetObject) {
            this.targetObject = targetObject;
        }
    }
    

     

    展开全文
  • java 属性拷贝工具类

    千次阅读 2015-06-10 11:08:16
    import java.lang.reflect.Method; import java.util.Arrays; import java.util.Collection; import java.util.List;... * 属性拷贝的 工具类 * @author zhangtengda * @version 1.0 * @creat
    import java.lang.reflect.Method;
    import java.util.Arrays;
    import java.util.Collection;
    import java.util.List;
    
       
    /**      
     * 属性拷贝的 工具类
     * @author zhangtengda        
     * @version 1.0      
     * @created 2015年6月10日 上午11:06:22     
     */       
    public class PropertyCopy {
    	/**
    	 * 利用反射实现对象之间属性复制
    	 * @param from
    	 * @param to
    	 */
    	public static void copyProperties(Object from, Object to) throws Exception {
    		copyPropertiesExclude(from, to, null);
    	}
    	
    	/**
    	 * 复制对象属性
    	 * @param from
    	 * @param to
    	 * @param excludsArray 排除属性列表
    	 * @throws Exception
    	 */
    	@SuppressWarnings("unchecked")
    	public static void copyPropertiesExclude(Object from, Object to, String[] excludsArray) throws Exception {
    		List<String> excludesList = null;
    		if(excludsArray != null && excludsArray.length > 0) {
    			excludesList = Arrays.asList(excludsArray);	//构造列表对象
    		}
    		Method[] fromMethods = from.getClass().getDeclaredMethods();
    		Method[] toMethods = to.getClass().getDeclaredMethods();
    		Method fromMethod = null, toMethod = null;
    		String fromMethodName = null, toMethodName = null;
    		for (int i = 0; i < fromMethods.length; i++) {
    			fromMethod = fromMethods[i];
    			fromMethodName = fromMethod.getName();
    			if (!fromMethodName.contains("get"))
    				continue;
    			//排除列表检测
    			if(excludesList != null && excludesList.contains(fromMethodName.substring(3).toLowerCase())) {
    				continue;
    			}
    			toMethodName = "set" + fromMethodName.substring(3);
    			toMethod = findMethodByName(toMethods, toMethodName);
    			if (toMethod == null)
    				continue;
    			Object value = fromMethod.invoke(from, new Object[0]);
    			if(value == null)
    				continue;
    			//集合类判空处理
    			if(value instanceof Collection) {
    				Collection newValue = (Collection)value;
    				if(newValue.size() <= 0)
    					continue;
    			}
    			toMethod.invoke(to, new Object[] {value});
    		}
    	}
    	
    	/**
    	 * 对象属性值复制,仅复制指定名称的属性值
    	 * @param from
    	 * @param to
    	 * @param includsArray
    	 * @throws Exception
    	 */
    	@SuppressWarnings("unchecked")
    	public static void copyPropertiesInclude(Object from, Object to, String[] includsArray) throws Exception {
    		List<String> includesList = null;
    		if(includsArray != null && includsArray.length > 0) {
    			includesList = Arrays.asList(includsArray);	//构造列表对象
    		} else {
    			return;
    		}
    		Method[] fromMethods = from.getClass().getDeclaredMethods();
    		Method[] toMethods = to.getClass().getDeclaredMethods();
    		Method fromMethod = null, toMethod = null;
    		String fromMethodName = null, toMethodName = null;
    		for (int i = 0; i < fromMethods.length; i++) {
    			fromMethod = fromMethods[i];
    			fromMethodName = fromMethod.getName();
    			if (!fromMethodName.contains("get"))
    				continue;
    			//排除列表检测
    			String str = fromMethodName.substring(3);
    			if(!includesList.contains(str.substring(0,1).toLowerCase() + str.substring(1))) {
    				continue;
    			}
    			toMethodName = "set" + fromMethodName.substring(3);
    			toMethod = findMethodByName(toMethods, toMethodName);
    			if (toMethod == null)
    				continue;
    			Object value = fromMethod.invoke(from, new Object[0]);
    			if(value == null)
    				continue;
    			//集合类判空处理
    			if(value instanceof Collection) {
    				Collection newValue = (Collection)value;
    				if(newValue.size() <= 0)
    					continue;
    			}
    			toMethod.invoke(to, new Object[] {value});
    		}
    	}
    	
    	
    
    	/**
    	 * 从方法数组中获取指定名称的方法
    	 * 
    	 * @param methods
    	 * @param name
    	 * @return
    	 */
    	public static Method findMethodByName(Method[] methods, String name) {
    		for (int j = 0; j < methods.length; j++) {
    			if (methods[j].getName().equals(name))
    				return methods[j];
    		}
    		return null;
    	}
    }

    展开全文
  • java对象属性拷贝

    2020-07-18 18:15:00
    对象属性拷贝 1、这四种对象属性拷贝方式,你都知道吗? 示例代码 该部分测试代码 完整代码地址 2、领域模型转换那些事儿 3、Java Bean Copy 性能大比拼、bean 拷贝工具 ...
    展开全文
  • 文章目录开头聊几句Java属性拷贝工具类使用总结字段和属性使用说明**org.springframework.beans.BeanUtils#copyProperties**org.apache.commons.beanutils.PropertyUtils#_copyProperties_org.apache.commons....

    怕什么真理无穷,进一步有近一步的欢喜

    开头聊几句

    • 1、这周不是很忙,工作上事情不是很多,有空就看看一些技术点
    • 2、网上很多的技术文章和资料是有问题的,要学会辨证的看待,不能随便就拿来用,起码要自己验证一下
    • 3、关注当下,关注此刻,如果你真正阅读本篇文章,请花几分钟时间的注意力阅读,相信你会有收获的

    Java属性拷贝工具类使用总结

    对项目中经常使用的属性拷贝工具类进行总结:

    • org.apache.commons.beanutils.BeanUtils
    • org.apache.commons.beanutils.PropertyUtils
    • org.springframework.beans.BeanUtils

    字段和属性

    首先明确下在Java中字段和属性的区别。


    属性是不是类里最上边的那些全局变量吗?比如:

    public class UserTest{
        private String userName;
        private String password;
    
    
        public String getUserName() {
            return userName;
        }
    
        public void setUserName(String userName) {
            this.userName = userName;
        }
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    
        public String getHello() {
            return "hello";
        }
    
        public void setHello(String str) {
        }
    }
    


    上面 private String userName;private String password;。准确的来说它们应该称为:字段,而不是本次要讲的属性。


    下面简述一下:什么是Java中的属性


    Java中的属性(property),通常可以理解为get和set方法,而字段(field),通常叫做“类成员”,或“类成员变量”,有时也叫“域”,理解为“数据成员”,用来承载数据的。

    直白点就是Java中的属性是指:设置和读取字段的方法,也就是平常见到的set和get方法。只要是set和get开头的方法在Java里都认为它是属性(请注意这句话,等下后边会写代码做验证)


    属性名称:就是set和get方法名 去掉"set"和"get"后的内容

    比如:

    public void setUserName(String userName) {
    	this.userName = userName;
    }
    

    它的属性名称是:userName(也就是方法名称”setUserName”去掉“set”)


    当然 setUserName和 getUserName 方法是指同一个属性 UserName,


    这里再次提醒:字段和属性不是同一个东西。


    代码验证属性
    上面代码中还有一个 getHellosetHello , JDK 中有个API Introspector



    在这里插入图片描述

    在这里插入图片描述


    获取的是java.beans.BeanInfo 类。这个类可以通过

    java.beans.BeanInfo#getPropertyDescriptors : 获取java bean 所有的属性。

    public static void main(String[] args) throws IntrospectionException {
        BeanInfo beanInfo = Introspector.getBeanInfo(UserTest.class);
        // 得到类中的所有的属性描述器
        PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();
        System.out.println("属性的个数:" + pds.length);
        for (PropertyDescriptor pd : pds) {
            System.out.println("属性:" + pd.getName());
        }
    }
    

    结果:

    属性的个数:4
    属性:class
    属性:hello
    属性:password
    属性:userName
    


    上面多了一个 class ,原因很简单,因为Object类是所有类的父类,Object类里有个方法叫 getClass();
    所以这也验证了咱们刚才说的: “只要是set或者get开头的方法都叫属性”

    使用说明

    default (即默认,什么也不写): 在同一包内可见,不使用任何修饰符。使用对象:类、接口、变量、方法。
    public : 对所有类可见。使用对象:类、接口、变量、方法
    private : 在同一类内可见。使用对象:变量、方法。 注意:不能修饰类(外部类)
    protected : 对同一包内的类和所有子类可见。使用对象:变量、方法。 注意:不能修饰类(外部类)

    org.springframework.beans.BeanUtils#copyProperties

    1.基本类型和包装类型会自动转换, 方法名称相同,返回值类型和参数类型不同,不进行复制,也不报错_

    2.支持指定忽略某些属性不复制

    3、支持类的修饰符 default 、 public

    org.apache.commons.beanutils.PropertyUtils#copyProperties

    1.基本类型和包装类型会自动转换

    2.方法名称相同,返回值类型和参数类型不同,复制失败,会报错,如下:

    _argument type mismatch - had objects of type “java.lang.Double” but expected signature “java.lang.String”

    3.只支持类的修饰符 public,如果是default 则直接不会进行转换(注意内部类复制也要加public)

    org.apache.commons.beanutils.BeanUtils#_copyProperties

    1.基本类型和包装类型会自动转换

    2.方法名称相同,返回值类型和_ _参数类型不同,不复制,不报错

    3.只支持类的修饰符 public,如果是default 则直接不会进行转换(注意内部类复制也要加public)


    tips: Spring和apache的_copyProperties_属性的方法源和目的参数的位置正好相反,所以导包和调用的时候都要注意一下。

    // Apache
    public static void 
      copyProperties(final Object dest, final Object orig)
        
    // Spring
    public static void
      copyProperties(Object source, Object target)
    

    性能参考:
    Bean复制的几种框架性能比较(Apache BeanUtils、PropertyUtils,Spring BeanUtils,Cglib BeanCopier)


    在这里插入图片描述

    摘要总结:Spring是在次数增多的情况下,性能较好,在数据较少的时候,性能比PropertyUtils的性能差一些。PropertyUtils的性能相对稳定,表现是呈现线性增长的趋势。而Apache的BeanUtil的性能最差,无论是单次Copy还是大数量的多次Copy性能都不是很好。

    使用的压测工具备忘:Java使用JMH进行简单的基准测试Benchmark : http://irfen.me/java-jmh-simple-microbenchmark/

    根据上面的具体的分析还是使用 :org.springframework.beans.BeanUtils#copyProperties
    原因

    1.这个方法在复制的时候不会因为属性的不同而报错,影响代码执行

    2.性能方面也相对较好


    其他Apache的两个,
    1、org.apache.commons.beanutils.PropertyUtils#copyProperties 复制会直接报错

    2、org.apache.commons.beanutils.BeanUtils#copyProperties 性能相对较差

    原理探索

    核心本质都是使用反射实现。具体的实现代码稍有不同。

    Spring#BeanUtils

    private static void copyProperties(Object source, Object target, @Nullable Class<?> editable,
                                       @Nullable String... ignoreProperties) throws BeansException {
    
        Assert.notNull(source, "Source must not be null");
        Assert.notNull(target, "Target must not be null");
    
        Class<?> actualEditable = target.getClass();
        if (editable != null) {
            if (!editable.isInstance(target)) {
                throw new IllegalArgumentException("Target class [" + target.getClass().getName() +
                                                   "] not assignable to Editable class [" + editable.getName() + "]");
            }
            actualEditable = editable;
        }
        PropertyDescriptor[] targetPds = getPropertyDescriptors(actualEditable);
        List<String> ignoreList = (ignoreProperties != null ? Arrays.asList(ignoreProperties) : null);
    
        for (PropertyDescriptor targetPd : targetPds) {
            Method writeMethod = targetPd.getWriteMethod();
            if (writeMethod != null && (ignoreList == null || !ignoreList.contains(targetPd.getName()))) {
                PropertyDescriptor sourcePd = getPropertyDescriptor(source.getClass(), targetPd.getName());
                if (sourcePd != null) {
                    Method readMethod = sourcePd.getReadMethod();
                    if (readMethod != null &&
                        ClassUtils.isAssignable(writeMethod.getParameterTypes()[0], readMethod.getReturnType())) {
                        try {
                            if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers())) {
                                readMethod.setAccessible(true);
                            }
                            Object value = readMethod.invoke(source);
                            if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers())) {
                                writeMethod.setAccessible(true);
                            }
                            writeMethod.invoke(target, value);
                        }
                        catch (Throwable ex) {
                            throw new FatalBeanException(
                                "Could not copy property '" + targetPd.getName() + "' from source to target", ex);
                        }
                    }
                }
            }
        }
    }
    

    1、获取 目标对象 所有的属性 targetPds

    PropertyDescriptor_[] _targetPds = getPropertyDescriptors(actualEditable);

    2、循环 targetPds ,并在源对象取出对应的属性

    PropertyDescriptor sourcePd = getPropertyDescriptor(source.getClass(), targetPd.getName_())_;


    3、r如果不是修饰不是public,**暴力反射 ,**然后使用对属性进行设值

    setAccessible_(true);// 暴力反射
    writeMethod.invoke
    (target, value)_;


    ### apache.commons#BeanUtils
    • org.apache.commons.beanutils.BeanUtilsBean#copyProperties

    简单截取核心代码:

    // org.apache.commons.beanutils.BeanUtilsBean#copyProperties
    
    final PropertyDescriptor[] origDescriptors =
        getPropertyUtils().getPropertyDescriptors(orig);
    for (PropertyDescriptor origDescriptor : origDescriptors) {
        final String name = origDescriptor.getName();
        if ("class".equals(name)) {
            continue; // No point in trying to set an object's class
        }
        if (getPropertyUtils().isReadable(orig, name) &&
            getPropertyUtils().isWriteable(dest, name)) {
            try {
                final Object value =
                    getPropertyUtils().getSimpleProperty(orig, name);
                copyProperty(dest, name, value);
            } catch (final NoSuchMethodException e) {
                // Should not happen
            }
        }
    }
    // org.apache.commons.beanutils.BeanUtilsBean#copyProperty
    getPropertyUtils().setSimpleProperty(target, propName, value);
    
    // org.apache.commons.beanutils.PropertyUtilsBean#setSimpleProperty
     invokeMethod(writeMethod, bean, values);
    
    

    1、 获取的是源对象的所有的属性

    final PropertyDescriptor[] origDescriptors = getPropertyDescriptors(orig);

    2、如果属性是class,不复制

    if (“class”.equals_(name)) { continue; // No point in trying to set an object’s class}_

    3、循环源对象的属性,做一些检验

    copyProperty(dest, name, value);
    1、会检验目标对象是否有源对象的属性,没有跳过
    2、获取属性的名称类型

    4、然后给目标对象设置,最终还是使用反射

    method.invoke_(bean, values)_;

    apache.commons#PropertyUtils

    • org.apache.commons.beanutils.PropertyUtilsBean#copyProperties

    简单截取核心代码:

    // org.apache.commons.beanutils.PropertyUtilsBean#copyProperties
    final PropertyDescriptor[] origDescriptors =
        getPropertyDescriptors(orig);
    for (PropertyDescriptor origDescriptor : origDescriptors) {
        final String name = origDescriptor.getName();
        if (isReadable(orig, name) && isWriteable(dest, name)) {
            try {
                final Object value = getSimpleProperty(orig, name);
                if (dest instanceof DynaBean) {
                    ((DynaBean) dest).set(name, value);
                } else {
                    setSimpleProperty(dest, name, value);
                }
            } catch (final NoSuchMethodException e) {
                if (log.isDebugEnabled()) {
                    log.debug("Error writing to '" + name + "' on class '" + dest.getClass() + "'", e);
                }
            }
        }
    }
    // org.apache.commons.beanutils.PropertyUtilsBean#invokeMethod
    method.invoke(bean, values);
    
    

    1、 获取的是源对象的所有的属性

    final PropertyDescriptor[] origDescriptors = getPropertyDescriptors(orig);

    2、循环源对象的属性,然后给目标对象设置,最终还是使用反射

    总结

    结合使用说明以及相关的性能和原理分析,建议使用 org.springframework.beans.BeanUtils#copyPropertie

    参考资料

    https://www.cnblogs.com/kaka/archive/2013/03/06/2945514.html


    Java编程技术乐园:分享干货技术,每天进步一点点,小的积累,带来大的改变!

    扫描关注,后台回复【秘籍】,获取珍藏干货! 99.9%的伙伴都很喜欢

    关注不迷路| center| 747x519

    展开全文
  • java对象属性拷贝,不拷贝空值

    千次阅读 2017-01-18 10:03:22
    java对象拷贝,不拷贝空值,对于数据库更新插入操作比较好用!
  • JavaBean 对象之间属性拷贝方法: 方法如下: 切记:赋值操作仅支持两个对象属性相同的情况 BeanUtils.copyProperties(A, B); 把对象A 的值 赋值给B 代码示例如下: 两个不同的包,两种不同的使用方式 package ...
  • java Bean拷贝忽略空属性

    千次阅读 2020-01-02 11:02:00
    java bean的拷贝一般采用两种办法 1.Spring里面的方法, org.springframework.beans.BeanUtils.copyProperties 2.Apache里面的方法,org.apache.commons.beanutils.BeanUtils.copyProperties 但是有需要注意的地方,...
  • 下面是通过java反射完成两个不同对象之间的字段值拷贝的示例: 首先,通过反射获取所有的字段(包含父类),然后进行字段的赋值 /** * 复制字段的值 * @param source 源对象 * @param target 目标对象 * @...
  • Java拷贝和浅拷贝

    千次阅读 2021-03-23 11:25:43
    Java拷贝和浅拷贝拷贝拷贝介绍浅拷贝特点深拷贝拷贝介绍深拷贝特点 浅拷贝拷贝介绍 浅拷贝是按位拷贝对象,它会创建一个新对象,这个对象有着原始对象属性值的一份精确拷贝。如果属性是基本类型,拷贝的...
  • Java提高篇 —— Java拷贝和深拷贝

    千次阅读 2018-08-14 15:31:24
    一、前言    我们知道在Java中存在这个...然而我们知道拷贝分为深拷贝和浅拷贝之分,但是浅拷贝存在对象属性拷贝不彻底问题。下面我们就具体来看一下深浅拷贝问题。   二、定义   首先来看看浅拷贝和深...
  • BeanUtil属性拷贝工具类,支持基本的javabean属性拷贝,通过java反射和泛型编程实现了list属性拷贝
  • java拷贝对象属性的几种方式对比

    千次阅读 2018-12-10 11:47:16
    常用的对象属性拷贝方式有很多,就随便说几个: spring 的 BeanUtils.copyproperties() 原理:反射 apache的 BeanUtils.copyproperties() String的 BeanUtils.copyproperties() PropertyUtils....
  • BeanUtils.copyProperties(对象1,要赋值的对象);
  • JAVA对象拷贝分为两种方式,一种是引用拷贝,一种是对象拷贝 引用拷贝:和对象拷贝的不同之处在于,引用拷贝只会生成一个新的对象引用地址,但两个地址其最终指向的还是同一个对象; 对象拷贝:这种方式会重新生成...
  • Java拷贝 和 浅拷贝 clone

    万次阅读 2019-11-27 16:15:22
    关于Java的深拷贝和浅拷贝,简单来说就是创建一个和已知对象一模一样的对象。可能日常编码过程中用的不多,但是这是一个面试经常会问的问题,而且了解深拷贝和浅拷贝的原理,对于Java中的所谓值传递或者引用传递将会...
  • Java中深拷贝和浅拷贝的研究这篇博文主要来研究下深拷贝和浅拷贝
  • java父子拷贝

    2019-06-05 09:56:23
    这就可能涉及到类的拷贝。 例如:某客户需在标准功能中添加额外功能,如排序,那么我们就需要在返回结果集中,添加属性showorder=true,实现前端配置排序。由于返回的是对象,继承原有对象,在新的对象中添加属性,...
  • java对象拷贝

    万次阅读 多人点赞 2017-03-22 15:49:59
    java赋值是复制对象引用,如果我们想要得到一个对象的副本,使用赋值操作是无法达到目的的:@Test public void testassign(){ Person p1=new Person(); p1.setAge(31); p1.setName("Peter"); Person p2=p1; ...
  • 5张图搞懂Java深浅拷贝

    千次阅读 2020-12-18 09:59:44
    在开发、刷题、面试中,我们可能会遇到将一个对象的属性赋值到另一个对象的情况,这种情况就叫做拷贝拷贝Java内存结构息息相关,搞懂Java深浅拷贝是很必要的! 在对象的拷贝中,很多初学者可能搞不清到底是拷贝...
  • java拷贝和浅拷贝

    2017-12-19 20:44:00
    创建一个新对象,会很精确的复制原来对象属性类型或者属性引用地址。 如:List list1 = list,List list2 = new ArrayList(); list2.addAll(list1)或者list2 = list1.clone(); 都是通过浅拷贝得到的。但是这样我们...
  • java拷贝和深拷贝的区别

    千次阅读 2018-09-28 15:10:05
    拷贝是指:只复制一个...java中使用到的clone方法是浅拷贝,下面是简单演示: 首先定义一个简单类A,申明一个属性aa = 1; public class A {  int aa = 1; } 定义一个可克隆类C,在C类中申明了类A、一个int属性...
  • 最近需要用到比较两个对象属性的变化,其中一个是oldObj,另外一个是newObj,oldObj是newObj的前一个状态,所以需要在newObj的某个状态时,复制一个一样的对象,由于JAVA不支持深层拷贝,因此专门写了一个方法
  • java拷贝与深拷贝拷贝工具推荐

    千次阅读 2020-06-04 22:13:52
    目录浅拷贝介绍深拷贝介绍拷贝的工具类推荐 浅拷贝介绍 拷贝出当前对象的一个副本,这个新对象和当前对象处于不同的堆内存中,两个对象的基本数据类型的值完全一样,但是引用数据类型还是指向同一个对象的。 深拷贝...
  • org.springframework.beans.BeanUtils.copyProperties(Object, Object)是spring 框架的对象工具类:BeanUtils下的一个拷贝对象属性的方法。 官方注释 把给定的源对象属性拷贝到目标对象中。 注意:源对象类与...
  • java拷贝拷贝

    2013-12-11 10:10:57
    Java中常用的拷贝操作有三个,operator=、拷贝构造函数和clone()方法。 由于Java不支持运算符重载,我们无法在自定义类型中定义operator=,所以使用operator=获取的对象都是浅拷贝,若要实现深拷贝那只能借助于拷贝...
  • 仔细一看,它还是一个native方法,大家都知道native方法是非Java语言实现的代码,供Java程序调用的,因为Java程序是运行在JVM虚拟机上面的,要想访问到比较底层的与操作系统相关的就没办法了,只能由靠近操作系统的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 165,289
精华内容 66,115
关键字:

java属性拷贝

java 订阅