Java Generic Methods get Class from Returntype

I would like to create a mapper that reads the individual variables with the specification of two entity classes and passes the various data types (with content) to a converter, which then returns the data under various conditions.
My problem is that I am not yet 100% familiar with Java Generics and therefore need help how to determine the return types in the best possible/standardized way.

As far as I found out, I have to define a generic class or pass the class to the generic method, that should be correct, right? Because I had already tried to define a generic method without passing the class as a parameter and to determine the type from this is not supposed to work in Java.

Could you maybe show me an example, how a generic method determines the return type, if a generic class is available?

public abstract class Converter{
    public static <TInto, TFrom> TInto convertDataTypes(TFrom from){
        TInto into = null;
        /* My Try 
        Class<?> intoClass = (Class<?>) ((java.lang.reflect.ParameterizedType Converter.class.getDeclaredMethods()[0]
                .getGenericReturnType()).getActualTypeArguments()[0];

        into = (TInto) intoClass.getDeclaredConstructor().newInstance();
        */
        // TODO: init into;
        // TODO: get into class
        return into;
    }
}

I also tried with the simple 'Type', because ParameterizedType throws an exception, but then 'getActualTypeArguments' doesn't work, or I still don't get the correct type (Boolean) that I want...

What I also didn't quite understand is why even if I specify the generic types, so when I call the generic method it doesn't recognize what I attach to the method.
Function call simply as Example:

Boolean b = Converter.<Boolean,String>convertDataTypes("true");

Yes, Java's type erasure makes it impossible to infer the generic type at runtime without explicitly passing the class. More formal:
> the generic type information is not retained at runtime due to type erasure, which removes all generic type information, replacing it with their bounds or with Object if the type parameters are unbounded.

So the typical way to handle this problem is indeed to pass the Class object of the desired return type to the method, let's try to create something for String->Integer for example:

abstract class Converter {

    public static <TInto, TFrom> TInto convertDataTypes(TFrom from, Class<TInto> intoClass) {
        TInto into = null;

        if (intoClass == String.class && from instanceof Integer) {
            into = intoClass.cast(Integer.toString((Integer) from));
        } else if (intoClass == Integer.class && from instanceof String) {
            into = intoClass.cast(Integer.parseInt((String) from));
        }
        // maybe you'll have more converters here, depending on the given types

        return into;
    }
}

Usage:

Integer i = Converter.convertDataTypes("41", Integer.class);
String s = Converter.convertDataTypes(41, String.class);