1.8大基础类型+String是传值 2.浅克隆和深拷贝对象 Orika(且线程安全,需有无参构造) 3.SerializationUtils(实现Serializable)

已于 2024-06-22 19:01:56 修改
阅读量1.1k 收藏
点赞数
分类专栏： # javase 文章标签： java 开发语言 后端
于 2016-01-05 14:10:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/themagickeyjianan/article/details/50462208
版权

知识点1(java有9种传递函数参数时是传值):

8大基础数据类型加String:

1,字节 byte  

2,短整型 short 

3,整型int 

4,长整形 long 

5,字符型 char 

6,浮点型 float 

7,双精度型 double 

8,布尔型 boolean

9,String

这8大基础类型+String是传值。

知识点2.BeanUtils.copyProperties(entity, userDto)

1.从entity拷贝数据到userDto中。

2.是浅拷贝。

3.使用的是反射调用set和get方法设置值，要有相同属性名字。

知识点3(深度克隆对象的三个方法):

方法1. // 重写clone方法

import java.util.ArrayList;

/**
 * 1.必须实现Cloneable接口.
 * 2.写clone方法的话，在clone中代码上每一处都要实现深复制.
 * @author jianan
 */
class Work implements Cloneable{
	private String strText;
	private ArrayList<String> array = new ArrayList<String>();
	
	@SuppressWarnings("unchecked")
	@Override
	protected Work clone(){
		Work work;
		try {
			work = (Work)super.clone();
			 work.strText = this.strText;
			 work.array = (ArrayList<String>) (this.array.clone()); //深克隆
			return work;
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return null;
	}
	
	public void addImage(String imgName){
		array.add(imgName);
	}
	
	public void setText(String strText){
		this.strText = strText;
	}
	
	public void display(String str){
		System.out.println(str);
		System.out.println("Text:" + strText);
		for(int i = 0; i < array.size(); i++){
			System.out.println("Image:" + array.get(i));
		}
		
		System.out.println();
	}
}

//测试函数
public class Main {

	public static void main(String[] args) {
		Work work = new Work();
		work.setText("111");
		work.addImage("1.png");
		work.addImage("2.png");
		work.addImage("3.png");
		work.display("111");
		
		Work work2 = work.clone();   
		work2.setText("2");
		work2.addImage("4.png");
		work2.addImage("5.png");
		work2.addImage("6.png");
		work2.display("222");
		
		work.display("111");
	}
}

方法2.  // io读写序列化反序列化

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;
/**
 * 1.实现Serializable接口即可.toString方法不用重写因为该接口里面本身就为空.
 * @author jianan
 */
//深克隆 工具
class DepthCloneUtil{
	public static Object depthClone(Object srcObj){
		Object cloneObj = null;
		try {
			ByteArrayOutputStream out = new ByteArrayOutputStream();
			ObjectOutputStream oo = new ObjectOutputStream(out);
			oo.writeObject(srcObj);
			ByteArrayInputStream in = new ByteArrayInputStream(out.toByteArray());
			ObjectInputStream oi = new ObjectInputStream(in);
			cloneObj = oi.readObject();
		} catch (IOException e) {
			e.printStackTrace();
		}catch (ClassNotFoundException e) {
			e.printStackTrace();
		}		
		return cloneObj; 
	}
}

//
class Work implements Serializable{
	private static final long serialVersionUID = -3219618174845671783L;  //会自动补充的
	private String strText;
	private ArrayList<String> array = new ArrayList<String>();
	
	public void addImage(String imgName){
		array.add(imgName);
	}
	
	public void setText(String strText){
		this.strText = strText;
	}
	
	public void display(String str){
		System.out.println(str);
		System.out.println("Text:" + strText);
		for(int i = 0; i < array.size(); i++){
			System.out.println("Image:" + array.get(i));
		}
		
		System.out.println();
	}
}

//测试函数
public class Main {

	public static void main(String[] args) {
		Work work = new Work();
		work.setText("111");
		work.addImage("1.png");
		work.addImage("2.png");
		work.addImage("3.png");
		work.display("111");
		
		Work work2 = (Work)DepthCloneUtil.depthClone(work); //如果采用对象序列化的话，
		work2.setText("2");
		work2.addImage("4.png");
		work2.addImage("5.png");
		work2.addImage("6.png");
		work2.display("222");
		
		work.display("111");
	}
}

直接写一个clone方法。

2种方式都实现了深度克隆,输出结果都是：

/*
111
Text:111
Image:1.png
Image:2.png
Image:3.png

222
Text:2
Image:1.png
Image:2.png
Image:3.png
Image:4.png
Image:5.png
Image:6.png

111
Text:111
Image:1.png
Image:2.png
Image:3.png
*/

方法3：使用orika（推荐！！！）

实体必须有无参构造！！！

pom.xml

     <dependency>
            <groupId>ma.glasnost.orika</groupId>
            <artifactId>orika-core</artifactId>
            <version>1.4.6</version>
        </dependency>

例子1---代替BeanUtils.copyProperties使用

OrikaUtil.java

package org.example.testOrika;

import ma.glasnost.orika.MapperFacade;
import ma.glasnost.orika.impl.DefaultMapperFactory;

public class OrikaUtil {
    public static MapperFacade MAPPER_FACADE = new DefaultMapperFactory.Builder().build().getMapperFacade();
}

Book.java

package org.example.testOrika;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

@Builder
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Book {
    private String id;
}

User.java

package org.example.testOrika;

import lombok.Data;
import lombok.ToString;

import java.util.List;

@Data
@ToString
public class User {
    private String id;
    private String name;
    private List<Book> books;
}

UserVo.java

package org.example.testOrika;

import lombok.Data;
import lombok.ToString;

import java.util.List;

@Data
@ToString
public class UserVo {
    private String id;
    private String name;
    private List<Book> books;
}

Main.java

package org.example.testOrika;

import com.google.common.collect.Lists;

/*
必须含有无参构造
 */
public class Main {
    public static void main(String[] args) {
        // 原对象
        User a = new User();
        a.setId("123");
        a.setName("1231");
        a.setBooks(Lists.newArrayList(Book.builder().id("1").build()));

        // 使用orika复制工具将A复制到B对象中(深拷贝)
        UserVo map = OrikaUtil.MAPPER_FACADE.map(a, UserVo.class);
        System.out.println(map);
    }
}

/*
UserVo(id=123, name=1231, books=[Book(id=1)])
 */

----------例子2.深度克隆

OrikaUtils.java 

package org.example.testOrika.utils;

import ma.glasnost.orika.MapperFacade;
import ma.glasnost.orika.impl.DefaultMapperFactory;

public class OrikaUtils {
    public static ThreadLocal<MapperFacade> facade = ThreadLocal.withInitial(() -> new DefaultMapperFactory.Builder().build().getMapperFacade());
}

Book.java

package org.example.testOrika.model;

import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor  // 这个无参的必须有
@AllArgsConstructor
public class Book {
    private String id;

    @Override
    public Book clone() {
        Book clone = new Book();
        clone.id = id;
        return clone;
    }
}

User.java

package org.example.testOrika.model;

import com.google.common.collect.Lists;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;

import java.util.List;

@Data
@ToString
@NoArgsConstructor
public class User {
	public String id;
	public String name;
	public List<Book> books = Lists.newArrayList();

	@Override
	public User clone() {
		User clone = new User();
		clone.id = id;
		clone.name = name;

		// 暂时book不拷贝
		books.forEach(book -> {
			clone.books.add(book.clone()); 
		});

		return clone;
	}
}

Main.java

package org.example.testOrika;

import com.google.common.collect.Lists;
import org.example.testOrika.model.Book;
import org.example.testOrika.model.User;
import org.example.testOrika.utils.OrikaUtils;

/*
必须含有无参构造
 */
public class Main {
	public static void main(String[] args) {
		// 原对象
		User user = new User();
		user.setId("123");
		user.setName("1231");
		user.setBooks(Lists.newArrayList(new Book("1"), new Book("2"), new Book("3")));

		// 使用orika复制工具将A复制到B对象中(深拷贝)
		User orikaCloneUser = OrikaUtils.facade.get().map(user, User.class);
		System.out.println(orikaCloneUser);

		// 使用普通的做法深拷贝每一项
		User cloneUser = user.clone();
		System.out.println(cloneUser);

		System.out.println();

	}
}

 可以看出：Orika最简单，也是深度克隆

/*
1亿次
75360
4451
 */
调用1亿次的话，可以看出Orika性能略低，不到原生的1/10

用arthas查看生成的类：

// sc模糊搜索类
[arthas@35972]$ sc *User*
com.taobao.arthas.core.util.UserStatUtil
com.taobao.arthas.core.util.UserStatUtil$1
ma.glasnost.orika.generated.Orika_User_User_Mapper2058567866428400$0
org.example.test.testOrika.User
Affect(row-cnt:4) cost in 33 ms.

// jad查看类的代码
[arthas@35972]$ jad ma.glasnost.orika.generated.Orika_User_User_Mapper2058567866428400$0

ClassLoader:                                                                                                                                                                                                  
+-jdk.internal.loader.ClassLoaders$AppClassLoader@2437c6dc                                                                                                                                                    
  +-jdk.internal.loader.ClassLoaders$PlatformClassLoader@7e93dc47                                                                                                                                             

Location:                                                                                                                                                                                                     
/C:/Users/elex/.m2/repository/ma/glasnost/orika/orika-core/1.4.6/orika-core-1.4.6.jar                                                                                                                         

/*
 * Decompiled with CFR.
 * 
 * Could not load the following classes:
 *  org.example.test.testOrika.User
 */
package ma.glasnost.orika.generated;

import java.util.ArrayList;
import java.util.List;
import ma.glasnost.orika.MappingContext;
import ma.glasnost.orika.impl.GeneratedMapperBase;
import org.example.test.testOrika.User;

public class Orika_User_User_Mapper2058567866428400$0
extends GeneratedMapperBase {
    @Override
    public void mapBtoA(Object object, Object object2, MappingContext mappingContext) {
        super.mapBtoA(object, object2, mappingContext);
        User user = (User)object;
        User user2 = (User)object2;
        if (user.getBooks() != null) {
            List list = new ArrayList(user.getBooks().size());
            list.addAll(this.mapperFacade.mapAsList(user.getBooks(), this.usedTypes[0], this.usedTypes[0], mappingContext));
            user2.setBooks(list);
        } else if (user2.getBooks() != null) {
            user2.setBooks(null);
        }
        user2.setId(user.getId());
        user2.setName(user.getName());
        if (this.customMapper != null) {
            this.customMapper.mapBtoA(user, user2, mappingContext);
        }
    }

    @Override
    public void mapAtoB(Object object, Object object2, MappingContext mappingContext) {
        super.mapAtoB(object, object2, mappingContext);
        User user = (User)object;
        User user2 = (User)object2;
        if (user.getBooks() != null) {
            List list = new ArrayList(user.getBooks().size());
            list.addAll(this.mapperFacade.mapAsList(user.getBooks(), this.usedTypes[0], this.usedTypes[0], mappingContext));
            user2.setBooks(list);
        } else if (user2.getBooks() != null) {
            user2.setBooks(null);
        }
        user2.setId(user.getId());
        user2.setName(user.getName());
        if (this.customMapper != null) {
            this.customMapper.mapAtoB(user, user2, mappingContext);
        }
    }
}

------------同时orika可以避免并发访问错误，是线程安全的

SO_PlayerTroop.java

package com.example.demo.entity;

import lombok.Data;

import java.util.HashMap;
import java.util.Map;

@Data
public class SO_PlayerTroop {
    private Map<Integer, Hero> heroMap = new HashMap<>();

    public void testWrite() {
        for (int i = 0; i < 10000; i++) {
            if (i % 2 == 0) {
                if(heroMap.containsKey(i)){
                    Hero hero = heroMap.get(i);
                    hero.add();
                }else {
                    Hero hero = new Hero();
                    heroMap.put(i, hero);
                    hero.add();
                }
            }else {
                heroMap.remove(i);
            }
        }
    }

    public void testRead() {
        for (Map.Entry<Integer, Hero> entry : heroMap.entrySet()) {
            for (Integer num : entry.getValue().getNums()) {
                System.out.println(num);
            }
        }
    }

}

Hero.java

package com.example.demo.entity;

import lombok.Data;

import java.util.ArrayList;
import java.util.List;

@Data
public class Hero {
    private List<Integer> nums = new ArrayList<>();

    public Hero() {
        nums.add(1);
        nums.add(2);
    }

    public void add() {
        for (int i = 0; i < nums.size(); i++) {
            nums.set(i, nums.get(i) + 1);
        }
    }
}

Main.java

package com.example.demo;

import com.example.demo.entity.SO_PlayerTroop;
import com.example.demo.utils.OrikaUtils;

//@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
//        SpringApplication.run(DemoApplication.class, args);


        SO_PlayerTroop so_playerTroop = new SO_PlayerTroop();

        new Thread(() -> {
            while (true) {
                so_playerTroop.testWrite();
            }
        }).start();


        new Thread(() -> {
            while (true) {
                // 深拷贝是不会有问题的
                SO_PlayerTroop so_playerTroopCopy = OrikaUtils.deepClone(so_playerTroop, SO_PlayerTroop.class);
                so_playerTroopCopy.testRead();

                // 报并发修改错误
                //  so_playerTroop.testRead();
            }
        }).start();

        System.out.println("start");
    }

}

OrikaUtils.java // 线程安全的深度克隆

package com.example.demo.utils;

import ma.glasnost.orika.MapperFacade;
import ma.glasnost.orika.impl.DefaultMapperFactory;

public class OrikaUtils {
    private static final MapperFacade MAPPER_FACADE = new DefaultMapperFactory.Builder().build().getMapperFacade();

    public static <S, D> D deepClone(S data, Class<D> clazz) {
        return MAPPER_FACADE.map(data, clazz);
    }
}

坑：

        必须有无参构造。

        字段不能是final，因为先调用无参构造，再进行set时就不成功！

------------------------------------

坑：

      <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.14.0</version>
        </dependency>

代码

package com.example.testsb.testOrika;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.SerializationUtils;

@Slf4j
public class Main {
    public static void main(String[] args) {

        long start = System.currentTimeMillis();
        for (int i = 0; i < 100000; i++) {
            SO_Player so_player = new SO_Player("xx");
            so_player.addBook(i);
            
            SO_Player so_playerCopy = SerializationUtils.clone(so_player);
//            log.info("so_playerCopy={}", so_playerCopy);
        }
        
        log.info("costTime={}", System.currentTimeMillis() - start);
    }
}

实现序列化接口

package com.example.testsb.testOrika;

import lombok.Data;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

@Data
public class SO_Player implements Serializable {
    private List<Book> bookList = new ArrayList<>();

    private String name;

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

    public void addBook(int id) {
        bookList.add(new Book(id));
    }
}

.net core game
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java string 深拷贝_探讨java深拷贝
weixin_31477659的博客
02-16 3349
本文将讨论以下4个问题1. java Cloneable接口实现深拷贝2. java 序列化实现深拷贝3. 号称最快的深拷贝二方库cloning源码分析4. 几种拷贝方式速度的比较深拷贝的概念本文就不说了。在C++中实现深拷贝一般情况下重载赋值操作符 “=” 来实现同一个类的对象间的深拷贝，所以很自然的在java中我们也同样可以定义一个copy函数，在函数内部为对象的每一个属性作赋值操作。这种方式...
OrikaUtil以及BeanUtils的使用
Blank 哥哥
09-22 923
OrikaUtil以及BeanUtils的使用 OrikaUtil是DO/BO以及 VO 的复制工具类,一般进行对象和集合之间的复制 一 ; copyObject /** * 将对象sourceObject的值拷贝到对象targetObject中 */ public static void copyObject(Object sourceObject, Object targetObject) { mapperFacade.map(sourceObject
orika core工具对实体（Bean）进行深度拷贝
weixin_30535167的博客
10-09 379
1. 在pom.xml中添加orika core依赖： <!-- https://mvnrepository.com/artifact/ma.glasnost.orika/orika-core --> <dependency> <groupId>ma.glasnost.orika</group...
对象属性复制之Orika
weixin_34248849的博客
10-02 314
2019独角兽企业重金招聘Python工程师标准>>> ...
Orika--更快的bean复制工具
weixin_42030357的博客
05-29 1016
文章目录pom使用 原博客，点击这里 参考博文，点击这里 pom <dependency> <groupId>ma.glasnost.orika</groupId> <artifactId>orika-core</artifactId> <version>1.4.2</version><!-- or latest version --> </dependency> 使用 这里假设我
渐析java的浅拷贝和深拷贝
hexi_sijin的专栏
05-16 447
转自：http://www.cnblogs.com/chenssy/p/3308489.html 首先来看看浅拷贝和深拷贝的定义：       浅拷贝：使用一个已知实例对新创建实例的成员变量逐个赋值，这个方式被称为浅拷贝。       深拷贝：当一个类的拷贝构造方法，不仅要复制对象的所有非引用成员变量值，还要为引用类型的成员变量创建新的实例，并且初始化为形式参数实例值。这个方式称为深拷
java数组深拷贝_浅谈Java中实现深拷贝的两种方式—clone() & Serialized
weixin_39942108的博客
02-12 218
clone() 方法麻烦一些，需要将所有涉及到的类实现声明式接口 Cloneable，并覆盖Object类中的clone()方法，并设置作用域为public(这是为了其他类可以使用到该clone方法)。序列化的方法简单，需要将所有涉及到的类实现接口Serializablepackage b1ch06.clone;import java.io.Serializable;class Car imple...
orika-core-1.5.4-API文档-中文版.zip
07-13
赠送jar包：orika-core-1.5.4.jar； 赠送原API文档：orika-core-1.5.4-javadoc.jar； 赠送源代码：orika-core-1.5.4-sources.jar； 赠送Maven依赖信息文件：orika-core-1.5.4.pom； 包含翻译后的API文档：orika-core...
orika-core-1.5.4-API文档-中英对照版.zip
07-13
赠送jar包：orika-core-1.5.4.jar； 赠送原API文档：orika-core-1.5.4-javadoc.jar； 赠送源代码：orika-core-1.5.4-sources.jar； 赠送Maven依赖信息文件：orika-core-1.5.4.pom； 包含翻译后的API文档：orika-core...
orika-sample:使用“ ma.glasnost.orika”的样本
05-19
1. **对象映射**：Orika允许开发者定义源对象和目标对象之间的映射关系，然后自动进行对象间的属性拷贝。这在处理不同数据模型间转换或跨层数据传递时非常有用。 2. **自定义映射**：除了自动映射外，Orika还支持...
orika,更简单、更好和更快的java bean映射框架.zip
09-26
新的我们很高兴宣布发布的奥里卡1.5.4！此版本在Maven中央存储库上可用
orika Java实例Demo
08-09
**Orika Java实例Demo** ...无论是在简单的对象拷贝还是复杂的对象结构映射中，Orika都能提供强大的支持，提高代码质量和开发效率。在实际项目中，根据需求选择合适的映射策略和配置，可以使代码更加简洁高效。
对象的深度克隆
string佳佳的博客
07-19 90
对象的深度克隆 let cloneData = JSON.parse(JSON.stringify(source))
深拷贝和浅拷贝工具整理
qq_22795957的博客
06-30 787
前几天写代码的时候，需要拷贝对象，就使用了的拷贝对象，后面又修改了新对象的属性，就导致原对象也被修改了，仔细一研究才发现这个工具只是进行了浅拷贝。索性整理一下现在比较常用的一些深拷贝和浅拷贝工具。......
Java中实现深拷贝的方法—学习笔记
Fish的专栏
03-05 3525
类实现Cloneable接口，然后用调用clone()方法，那么返回的只是一个浅拷贝的对象，基本属性的值是拷贝过来了而引用类型还是指向了被拷贝对象的引用类型。 方法一：类实现一个标记接口Serializable通过IO流来实现对象的深拷贝 public class Menus implements Serializable{ private static final long serialV
实现深拷贝的多种方式
weixin_48371382的博客
05-05 123
来源 | http://www.fly63.com/article/detial/9650 简单来说，深拷贝主要是将另一个对象的属性值拷贝过来之后，另一个对象的属性值并不受到影响，因为此时它自己在堆中开辟了自己的内存区域，不受外界干扰。 浅拷贝主要拷贝的是对象的引用值，当改变对象的值，另一个对象的值也会发生变化。 1.简单深拷贝(一层浅拷贝) ①for循环拷贝 // 只复制第一层的浅拷贝 function simpleCopy(obj1) { var obj2 = Array.isArray(obj1
spring boot 对象拷贝工具(Orika)
qq_42702229的博客
10-23 1694
1.spring 自带拷贝工具 LoginUser user = new LoginUser(); // 将data中字段相同的属性拷贝到user中 BeanUtils.copyProperties(data , user); 2. 基于Orika的字节码拷贝工具 1) pom <!-- 基于字节码的深拷贝工具类 --> <dependency> <groupId>ma.glasnost.orika&
Springboot对象拷贝方案(Orika/MapStructPlus)
青春不散场的专栏
08-20 327
对象拷贝分为深拷贝和浅拷贝，如果使用Apache-BeanUtil和Hutool和Spring的BeanUtil等都是浅拷贝。效率:因为Orika的设计思路是预先通过javaassist把JavaBean之间的映射关系一次性生成目标拷贝方法代码。这样就可以避免在Bean 映射环节一次次的读取映射规则。从而实现效率上的提高。
10.javaSE基础_JDBC编译程序(Driver+Statement+Connection+mysql数据库连接)
最新发布
m0_61086522的博客
07-02 1231
JDBC是的缩写。它是Sun的Javasoft公司制定的Java数据库连接技术，是一套标准接口java.sql包中提供了JDBC API,通过它连接到各种数据库系统，编写访问数据库的程序。JDBC API不能直接访问数据库，它依赖于数据库厂商提供的JDBC Driver（JDBC驱动程序）
Orika与BeanUtil.copyProperties
10-13
Orika和BeanUtil.copyProperties都是Java中用于对象属性拷贝的工具类，它们的作用都是将一个Java对象的属性值拷贝到另一个Java对象中。但是它们之间还是有一些区别的。 Orika相对于BeanUtil.copyProperties来说，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值