Easy way to convert from one type to another in java (when fields are similar)?

I don't think native java can do this.

There is a few libraries that would help you with this kind of problem.

I would recommend MapStruct : https://mapstruct.org/ I also used Orika and ModelMapper.

You may use reflection for that purpose.

Look at java.lang.reflect, get the A.class and loop for every Field, to copy the values.

https://docs.oracle.com/javase/8/docs/api/java/lang/reflect/package-summary.html

// warning: not tested nor compiled -take it as hint

A a = new A(); ...set values
B b = new B();
for (Field f : A.class.getFields()) {
    f.set(b,f.get(a);
}

You can use ModelMapper a Java Library. http://modelmapper.org/getting-started/

Short answer

There is no native way in plain Java to convert an object of type A to an object of type B without having to copy the fields one by one.

Longer answer

Why is that?

There is no such thing as similar fields in Java. The Java language by design does not support duck typing. Thus said you cannot treat a two fields fields as similar / same by their names.

How can I get it done?

There are different approaches:

• Manual mapping

This is a boring but runtime performant approach.

• Inheritance and polymorphism

Not really a mapping approach, but rather treating the objects as similar by their common interfaceand/orparent class`.

• Serialization and deserialization to/from String

If the two types have fields with same names and types they can be mapped from one to another by serialization/deserialization (e.g. GSON). This is not the best solution, but may do the good job in some rare cases.

• Using reflection and reflection-based libraries:

Reflection is another way of achieving the same goal, but with huge trade-offs. This approach is not so different from the one above, but it allows to map fields with different names. Even though the approach is widely used (e.g. in Dozer) it is not very performant. The reflective operations may take significant time.

• Using code generators

There is another approach. As opposed to using reflection at runtime, the code generators (like MapStruct) do the similar thing at compile time. Thus there is no runtime overhead as compared to manual mapping. Actually, the generated code looks quiet the same as the manually written one.

How to choose one for my project?

There is a bunch of different tools for mapping POJO types between each other. Before choosing one of them for using in your project I'd suggest considering the following criteria:

• Is the particular case worth adding external dependency?
• Is it easy to read?
• Is it easy to modify the classes without breaking the code?
• Is it performant at runtime?
• etc...

Subjective opinion:

I personally like using MapStruct. It generates the methods for mapping at compile time, so there is no runtime reflective stuff causing overhead. You can map the objects at almost zero cost.