Java 泛型方法，泛型类型未知

我有很多bean我想转换成Dto

在每节课上，我都做类似的事情

private List<AddressDto> convertsToDto(List<Address> addresses) {

    List<AddressDto> addressesDto = new ArrayList<>();
    addresses.stream().map((address) -> convertToDto(address)).forEachOrdered((addressDto) -> {
        addressesDto.add(addressDto);
    });
    return addressesDto;

}

private List convertsToDto（列表地址）{
List addressedto=new ArrayList（）；
addresses.stream（）.map（（地址）->convertto（地址））.forEachOrdered（（地址到）->{
addressedto.add（addressedto）；
});
返回地址DTO；
}

每个班级都会有一名学生。。。。但对于convertsToDto，我将在t中放入一个抽象类，其中每个类都将对其进行扩展，并放入一个泛型类型为的泛型convertsToDto方法

public abstract class BaseService {
    public List<T> convertsToDto(List<R> beans) {

        List<T> listDto = new ArrayList<>();
        beans.stream().map((bean) -> convertToDto(bean)).forEachOrdered((dto) -> {
            listDto.add(dto);
        });
        return listDto;
    }
}

公共抽象类BaseService{
公共列表转换器stodto（列表bean）{
List listDto=new ArrayList（）；
beans.stream（）.map（（bean）->convertto（bean））.forEachOrdered（（dto）->{
列表dto.add（dto）；
});
返回listDto；
}
}

---

我总是得到

T

，而

R

是未知的。。。您的BaseService类没有定义这些泛型类型

Try 
public abstract class BaseService<T, R> {
...
}

public class AddressService extends BaseService<AddressDto, Address> {
...
}

试试看
公共抽象类基服务{
...
}
公共类AddressService扩展了BaseService{
...
}

您的BaseService类没有定义这些泛型类型

Try 
public abstract class BaseService<T, R> {
...
}

public class AddressService extends BaseService<AddressDto, Address> {
...
}

试试看
公共抽象类基服务{
...
}
公共类AddressService扩展了BaseService{
...
}

您可以使用类似于

Dto的通用接口来实现此功能

您将能够使您的通用转换方法如下所示：

public <T extends Dto<R>> List<T> convertsToDto(List<R> beans) {
}

public List convertsToDto（列表bean）{
}

您的
Dto
对象将实现将它们映射到基本对象的接口。
您可以使用类似
Dto
的通用接口来实现此功能

您将能够使您的通用转换方法如下所示：

public <T extends Dto<R>> List<T> convertsToDto(List<R> beans) {
}

public List convertsToDto（列表bean）{
}

您的
Dto
对象将实现将它们映射到基本对象的接口。
首先向通用方法添加
T
和
R
类型参数。但是，这不会起作用，因为
converttoto（bean）
将保持未定义状态

您在这里有几个选项：


您可以定义bean接口来生成其DTO，或者
您可以将bean传递给DTO函数对象

以下是第一种方法：

interface Bean<T> {
    T convertToDto();
}
public abstract class BaseService {
    public <T,R extends Bean<T>> List<T> convertsToDto(List<R> beans) {
        return beans.stream().map((b) -> b.convertToDto()).collect(Collectors.toList());
    }
    ... // Additional methods
}

public abstract class BaseService {
    public <T,R> List<R> convertsToDto(List<T> beans, Function<T,R> convert) {
        return beans.stream().map((b) -> convert.apply(b)).collect(Collectors.toList());
    }
}

接口Bean{
T convertto（）；
}
公共抽象类基服务{
公共列表转换器stodto（列表bean）{
返回beans.stream（）.map（（b）->b.convertto（））.collect（Collectors.toList（））；
}
…//其他方法
}

以下是第二种方法：

interface Bean<T> {
    T convertToDto();
}
public abstract class BaseService {
    public <T,R extends Bean<T>> List<T> convertsToDto(List<R> beans) {
        return beans.stream().map((b) -> b.convertToDto()).collect(Collectors.toList());
    }
    ... // Additional methods
}

public abstract class BaseService {
    public <T,R> List<R> convertsToDto(List<T> beans, Function<T,R> convert) {
        return beans.stream().map((b) -> convert.apply(b)).collect(Collectors.toList());
    }
}

公共抽象类BaseService{
公共列表convertsToDto（列表bean、函数转换）{
返回beans.stream（）.map（（b）->convert.apply（b））.collect（Collectors.toList（））；
}
}
首先在泛型方法中添加
T
和
R
类型参数。但是，这不会起作用，因为
converttoto（bean）
将保持未定义状态

您在这里有几个选项：


您可以定义bean接口来生成其DTO，或者
您可以将bean传递给DTO函数对象

以下是第一种方法：

interface Bean<T> {
    T convertToDto();
}
public abstract class BaseService {
    public <T,R extends Bean<T>> List<T> convertsToDto(List<R> beans) {
        return beans.stream().map((b) -> b.convertToDto()).collect(Collectors.toList());
    }
    ... // Additional methods
}

public abstract class BaseService {
    public <T,R> List<R> convertsToDto(List<T> beans, Function<T,R> convert) {
        return beans.stream().map((b) -> convert.apply(b)).collect(Collectors.toList());
    }
}

接口Bean{
T convertto（）；
}
公共抽象类基服务{
公共列表转换器stodto（列表bean）{
返回beans.stream（）.map（（b）->b.convertto（））.collect（Collectors.toList（））；
}
…//其他方法
}

以下是第二种方法：

interface Bean<T> {
    T convertToDto();
}
public abstract class BaseService {
    public <T,R extends Bean<T>> List<T> convertsToDto(List<R> beans) {
        return beans.stream().map((b) -> b.convertToDto()).collect(Collectors.toList());
    }
    ... // Additional methods
}

public abstract class BaseService {
    public <T,R> List<R> convertsToDto(List<T> beans, Function<T,R> convert) {
        return beans.stream().map((b) -> convert.apply(b)).collect(Collectors.toList());
    }
}

公共抽象类BaseService{
公共列表convertsToDto（列表bean、函数转换）{
返回beans.stream（）.map（（b）->convert.apply（b））.collect（Collectors.toList（））；
}
}
是否可以将T和R作为类型参数添加到函数中？又名“publicsistconverstodto（列表bean）”泛型在编译时被删除。在运行时，它总是一个对象列表。您应该将类型作为参数传递。为什么需要使用泛型？为什么不直接使用基本抽象类？也许可以将t和R作为类型参数添加到函数中？又名“publicsistconverstodto（列表bean）”泛型在编译时被删除。在运行时，它总是一个对象列表。您应该将类型作为参数传递。为什么需要使用泛型？为什么不直接使用基本抽象类呢？从第一个选项开始，在我的类中，当我尝试调用方法convertsToDto时，我得到：类BaseService中的方法convertsToDto不能应用于给定的类型；必需：找到列表：列表原因：推理变量R具有不兼容的边界相等约束：地址上限：Bean，其中R、T是类型变量：R扩展在方法convertsToDto（列表）中声明的Bean T扩展在方法convertsToDto（列表）中声明的对象@roberttrudel看起来您的
Bean
接口不同-它需要两个参数，而不是一个。第一个解决方案使用一个参数，
T
，它对应于目标DTO类型。换句话说，如果
Address
的目标DTO是
AddressDto
，那么
Address
必须
实现Bean
；因为输入参数应该不同于输出，所以第二种方法似乎更容易实现implement@roberttrudel第二种方法还允许您在无法访问bean类并且无法在其上“固定”新接口时使用此代码。但是，每次调用
convertToDtos
时，它都需要一个lambda或converter函数对象。从第一个选项开始，在我的类中，当我尝试调用方法convertsToDto时，我得到：类BaseService中的方法convertsToDto不能应用于给定的类型；必需：List found:List reason:推理变量R具有不兼容的边界等式约束：Address upper bounds:Bean，其中R、T是类型变量：R扩展在me中声明的Bean