解决错误The type List is not generic; it cannot be parameterized with arguments <Map>

最新推荐文章于 2023-11-17 14:52:03 发布
最新推荐文章于 2023-11-17 14:52:03 发布
阅读量1.3w 收藏 3
点赞数 7
CC 4.0 BY-SA版权
分类专栏： Java基础 文章标签： arraylist java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zbdxcyg/article/details/71440729
本文介绍了一个关于Java编程中List类型使用的常见错误：由于包导入不正确导致的问题。具体表现为将util包下的List误导入为awt包下的List，以及如何通过更正导入语句来解决该问题。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

今天写一个list 报了个错

List<Map> pList = new ArrayList<Map>();

最后发现是包导错了

import java.awt.List;

换成 util包就好了

import java.util.List;

问题解决。。。

最后，给大家推荐一个学习Java的好网站JAVA自学网站–how2j.cn

The type List is not generic； it cannot be parameterized with arguments ＜Map＜String,Object＞＞
weixin_45479784的博客
07-22 278
The type List is not generic; it cannot be parameterized with arguments <Map<String,Object>> 应该导入 :import java.util.*; 同时检查一下有没有import其他的List.比如 java.awt.List,有的话,去掉。
Java---报错The type List is not generic； it cannot be parameterized with arguments ＜Role＞==List打包错误
技术分享，共同进步
10-06 3769
提示The type List is not generic; it cannot be parameterized with arguments 错误。如下： 解决方法： 这个包是错误的，换到 import java.util.List; 如下：
The type List is not generic; it cannot be parameterized with arguments Integer.
烟敛寒林的博客
12-20 1809
今天写一个list 报了个莫名其妙的警告 List&lt;Integer&gt; list1 = new ArrayList&lt;Integer&gt;(); 然后发现是包导错了 一开始用的是 import java.awt.List; 换成 util包就好了 import java.util.List;  ...
The type List is not generic; it cannot be parameterized with arguments
winnifred的博客
11-05 787
报错： The type List is not generic; it cannot be parameterized with arguments 原因：包自动导成import java.awt.List; 换成import java.util.List;即可
解决错误The type List is not generic, it cannot be parameterized with arguments。
qq_37058980的博客
05-31 3528
今天写一个list 报了个错 List<Map> pList = new ArrayList<Map>(); 最后发现是包导错了 import java.awt.List; 换成 util包就好了 import java.util.List;
/** * 根据非空属性值动态查询实体 * @param entity 包含查询条件的实体对象（非空属性作为查询条件） * @return 查询结果信息（成功时包含数据列表） */ public <T>Information getSELECTEntity(T entity) { if (entity == null) { return Information.NewFail("查询参数不能为空"); } Class<T> entityClass = (Class<T>) entity.getClass(); try { // 1. 获取非泛型的Repository JpaRepository repository = repositoryService.getJpaRepository(entityClass); // 2. 构建非泛型的Example查询 ExampleMatcher matcher = ExampleMatcher.matching() .withIgnoreNullValues() .withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING); // 这里直接使用原始类型Example Example<T> example = Example.of(entity, matcher);//he type Example is not generic; it cannot be parameterized with arguments <T>the method of(T) is undefined for the type Example // 3. 执行查询 List<?> result = repository.findAll(example); return Information.NewSuccess(result); } catch (ClassCastException e) { return Information.NewFail("Repository类型不匹配: " + e.getMessage()); } catch (DataAccessException e) { return Information.NewFail("数据库访问错误: " + e.getMessage()); } catch (Exception e) { return Information.NewFail("系统错误: " + e.getMessage()); } }
06-11
>> repositoryMap = new HashMap<>(); @SuppressWarnings("unchecked") public <T, ID> JpaRepository<T, ID> getJpaRepository(Class<T> entityClass) { // 实际实现可能从Spring上下文中获取Repository ...
package com.kucun.Service; import java.io.Serializable; import java.lang.reflect.*; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.stream.Collectors; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.dao.DataAccessException; import org.springframework.data.domain.Example; import org.springframework.data.domain.ExampleMatcher; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.stereotype.Service; import com.kucun.data.entity.Bancai; import com.kucun.data.entity.Dingdan_chanpin; import com.kucun.data.entity.Dingdan_chanpin_zujian; import com.kucun.data.entity.EntityBasis; import com.kucun.data.entity.Information; import com.kucun.data.entity.Kucun; import com.kucun.dataDo.BancaiRepository; import com.kucun.dataDo.CaizhiRepository; import com.kucun.dataDo.ChanpinRepository; import com.kucun.dataDo.ChanpinZujianRepository; import com.kucun.dataDo.DingdanChanpinRepository; import com.kucun.dataDo.DingdanChanpinZujianRepository; import com.kucun.dataDo.DingdanRepository; import com.kucun.dataDo.KucunRepository; import com.kucun.dataDo.MupiRepository; import com.kucun.dataDo.UserRepository; import com.kucun.dataDo.ZujianRepository; @Service public class AppService { // 注入所有需要的Repository @Autowired private CaizhiRepository caizhiRepository; @Autowired private BancaiRepository bancaiRepository; @Autowired private ChanpinRepository chanpinRepository; @Autowired private DingdanRepository dingdanRepository; @Autowired private MupiRepository mupiRepository; @Autowired private ZujianRepository zujianRepository; @Autowired private KucunRepository kucunRepository; @Autowired private UserRepository userRepository; @Autowired private ChanpinZujianRepository chanpinZujianRepository; @Autowired private DingdanChanpinZujianRepository dingdanChanpinZujianRepository; @Autowired private DingdanChanpinRepository dingdanChanpinRepository; @Autowired private DynamicRepositoryService repositoryService; @Autowired private EntityDependencyService dependencyService; public Information getAllDataWithChildIdse() { Map<String, Object> response = new HashMap<>(); for (String key : repositoryService.getRepositoryNameMap().keySet()) { response.put(key+"s", (repositoryService.getJpaRepository(key).findAll())); } return Information.NewSuccess(response); } public Information getAllDataWithChildIdse(String e) { JpaRepository<?, ?> jp = repositoryService.getJpaRepository(e); System.out.println(jp); return Information.NewSuccess(jp.findAll()); } public Information getAddEntity(Object e) { Class<?> entityClass = e.getClass(); try { // 处理关联字段 handleAssociations(e); @SuppressWarnings("unchecked") JpaRepository<Object, Serializable> jp = (JpaRepository<Object, Serializable>) repositoryService.getJpaRepository(entityClass); Object savedEntity = jp.save(e); if(savedEntity!=null) { if(savedEntity instanceof Bancai) { initializeKucunForBancai((Bancai)savedEntity); } } return Information.NewSuccess(savedEntity); } catch (Exception ex) { return Information.Newfail(500, "创建失败: " + ex.getMessage(), null); } } // 单独封装库存初始化方法 private void initializeKucunForBancai(Bancai bancai) throws Exception { Kucun kucun = new Kucun(null, bancai, 0); // 初始库存为0 try { bancai.setKucun(kucunRepository.save(kucun)); } catch (Exception e) { // TODO: handle exception throw new Exception("initializeKucunForBancai"+e); } } // 处理关联对象（转换为托管实体） private void handleAssociations(Object entity) throws Exception { Class<?> clazz = entity.getClass(); for (Field field : clazz.getDeclaredFields()) { field.setAccessible(true); Object value = field.get(entity); if (value == null) continue; // 处理单个关联实体 if (isEntityBasisField(field)) { EntityBasis associatedEntity = (EntityBasis) value; JpaRepository<Object, Serializable> repo = (JpaRepository<Object, Serializable>) repositoryService.getJpaRepository(associatedEntity.getClass()); // 获取托管状态的关联实体 Object managedEntity = repo.findById(associatedEntity.getId()) .orElseThrow(() -> new RuntimeException("关联实体不存在")); field.set(entity, managedEntity); } // 处理集合关联 else if (isCollectionField(field)) { Collection<?> collection = (Collection<?>) value; List<Object> managedEntities = new ArrayList<>(); for (Object item : collection) { if (item instanceof EntityBasis) { EntityBasis eb = (EntityBasis) item; JpaRepository<Object, Serializable> repo = (JpaRepository<Object, Serializable>) repositoryService.getJpaRepository(eb.getClass()); Object managedEntity = repo.findById(eb.getId()) .orElseThrow(() -> new RuntimeException("关联实体不存在")); managedEntities.add(managedEntity); } } // 更新集合为托管实体 if (!managedEntities.isEmpty()) { field.set(entity, managedEntities); } } } } /** * 更新 * @param e 实体待id * @return */ /** * 更新实体 * @param e 包含ID的实体 * @return 操作结果 */ public Information getupdateEntity(Object e) { if(e == null) { return Information.Newfail(403, "参数为空", null); } Class<?> entityClass = e.getClass(); try { Field idField = entityClass.getDeclaredField("id"); idField.setAccessible(true); Object idValue = idField.get(e); // 修正：应检查id是否为空，而不是不为空 if(idValue == null) { return Information.Newfail(403, "Id为空", null); } // 获取Repository @SuppressWarnings("unchecked") JpaRepository<Object, Serializable> jp = (JpaRepository<Object, Serializable>) repositoryService.getJpaRepository(entityClass); // 从数据库加载现有实体（托管状态） Object existingEntity = jp.findById((Serializable) idValue) .orElseThrow(() -> new RuntimeException("实体不存在")); // 复制属性（排除关联字段） copyNonNullProperties(e, existingEntity); // 保存托管状态的实体 Object updatedEntity = jp.save(existingEntity); return Information.NewSuccess(updatedEntity); } catch (Exception ex) { return Information.Newfail(500, "更新失败: " + ex.getMessage(), null); } } /** * 删除 * @param entity * @return */ /** * 删除实体 * @param entity 要删除的实体 * @return 操作结果 */ public Information getdeleteEntity(EntityBasis entity) { if (entity == null) { return Information.NewFail("删除对象不能为空"); } Class<?> entityClass = entity.getClass(); String entityName = entityClass.getSimpleName().toLowerCase(); try { // 1. 获取对应的Repository JpaRepository<Object, Serializable> jp = (JpaRepository<Object, Serializable>) repositoryService.getJpaRepository(entityName); // 2. 检查实体是否存在 if (!jp.existsById(entity.getId())) { return Information.NewFail("未找到ID为" + entity.getId() + "的" + entityName); } // 3. 检查依赖关系 if (dependencyService.hasDependencies(entityClass, entity.getId())) { return Information.NewFail("该记录已被其他数据引用，无法删除"); } // 4. 执行删除 jp.deleteById(entity.getId()); // 5. 验证删除结果 if (jp.existsById(entity.getId())) { return Information.NewFail("删除操作失败，记录仍然存在"); } return Information.NewSuccess("删除成功"); } catch (Exception e) { return Information.NewFail("删除过程中发生错误: " + e.getMessage()); } } // 复制非空属性（忽略关联字段） private void copyNonNullProperties(Object source, Object target) throws IllegalAccessException { Class<?> clazz = source.getClass(); for (Field field : clazz.getDeclaredFields()) { field.setAccessible(true); Object value = field.get(source); // 跳过关联字段和特殊字段 if (value != null && !isEntityBasisField(field) && !isCollectionField(field) && !field.getName().equals("id")) { Field targetField; try { targetField = target.getClass().getDeclaredField(field.getName()); targetField.setAccessible(true); targetField.set(target, value); } catch (NoSuchFieldException e) { // 忽略不存在的字段 } } } } // 检查是否为关联实体字段 private boolean isEntityBasisField(Field field) { return EntityBasis.class.isAssignableFrom(field.getType()); } // 检查是否为集合字段 private boolean isCollectionField(Field field) { return Collection.class.isAssignableFrom(field.getType()) || Map.class.isAssignableFrom(field.getType()); } /** * 根据非空属性值动态查询实体 * @param entity 包含查询条件的实体对象（非空属性作为查询条件） * @return 查询结果信息（成功时包含数据列表） */ public <T>Information getSELECTEntity(T entity) { if (entity == null) { return Information.NewFail("查询参数不能为空"); } Class<T> entityClass = (Class<T>) entity.getClass(); try { // 1. 获取非泛型的Repository JpaRepository repository = repositoryService.getJpaRepository(entityClass); // 2. 构建非泛型的Example查询 ExampleMatcher matcher = ExampleMatcher.matching() .withIgnoreNullValues() .withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING); // 这里直接使用原始类型Example Example<T> example = Example.of(entity);//he type Example is not generic; it cannot be parameterized with arguments <T>the method of(T) is undefined for the type Example // 3. 执行查询 List<?> result = repository.findAll(example); return Information.NewSuccess(result); } catch (ClassCastException e) { return Information.NewFail("Repository类型不匹配: " + e.getMessage()); } catch (DataAccessException e) { return Information.NewFail("数据库访问错误: " + e.getMessage()); } catch (Exception e) { return Information.NewFail("系统错误: " + e.getMessage()); } } private List<Map<String, Object>> convertEntityBasis(List<EntityBasis> entities) { return entities.stream().map(entity -> { Map<String, Object> map = new HashMap<>(); Field[] fields = entity.getClass().getDeclaredFields(); try { // 添加实体自身的基本字段 map.put("id", entity.getId()); // 处理所有字段 for (Field field : fields) { field.setAccessible(true); // 允许访问私有字段 Object fieldValue = field.get(entity); if (fieldValue != null) { String fieldName = field.getName(); // 处理集合类型关联 if (isCollection(field)) { if (!((Collection<?>) fieldValue).isEmpty()) { List<Map<String, Object>> collectionItems = ((Collection<?>) fieldValue) .stream() .filter(item -> item instanceof EntityBasis) .map(item -> { Map<String, Object> itemMap = new HashMap<>(); itemMap.put("id", ((EntityBasis) item).getId()); return itemMap; }) .collect(Collectors.toList()); map.put(fieldName, collectionItems); } } // 处理单个实体关联 else if (implementsInterface(field, EntityBasis.class)) { Map<String, Object> associatedMap = new HashMap<>(); associatedMap.put("id", ((EntityBasis) fieldValue).getId()); map.put(fieldName, associatedMap); } // 处理其他基本类型字段 else if (!isSpecialField(fieldName)) { map.put(fieldName, fieldValue); } } } } catch (IllegalAccessException e) { e.printStackTrace(); } return map; }).collect(Collectors.toList()); } // 判断是否为特殊字段（需要排除的字段） private boolean isSpecialField(String fieldName) { return fieldName.equals("handler") || fieldName.equals("hibernateLazyInitializer"); } /** *-判断属性是否为集合类型 * @param field * @return */ boolean isCollection(Field field) { Class<?> type = field.getType(); // 检查是否为Java内置集合类型 if (Collection.class.isAssignableFrom(type) || Map.class.isAssignableFrom(type) || type.isArray()) { return true; } // 检查是否实现集合相关接口（如Iterable） for (Class<?> interfaceType : type.getInterfaces()) { if (Iterable.class.isAssignableFrom(interfaceType)) { return true; } } return false; } /** * -判断属性是否实现特定接口 * @param field * @param targetInterface * @return */ boolean implementsInterface(Field field, Class<?> targetInterface) { Class<?> type = field.getType(); // 检查类本身是否实现接口 if (targetInterface.isAssignableFrom(type)) { return true; } // 检查实现的接口是否继承目标接口 for (Class<?> interfaceType : type.getInterfaces()) { if (targetInterface.isAssignableFrom(interfaceType)) { return true; } } return false; } private Object convertDingdanChanpins(List<Dingdan_chanpin> findAll) { // TODO Auto-generated method stub return null; } private Object convertDingdanChanpinZujians(List<Dingdan_chanpin_zujian> findAll) { // TODO Auto-generated method stub return null; } } 简化该类，不用创建新类，加入方法注释
最新发布
06-18
Map<String, Object> response = new HashMap<>(); repositoryService.getRepositoryNameMap().forEach((key, repo) -> response.put(key + "s", repo.findAll()) ); return Information.NewSuccess(response)...
package com.kucun.Service; import java.io.Serializable; import java.lang.reflect.*; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Set; import java.util.stream.Collectors; import javax.persistence.metamodel.Attribute; import javax.persistence.metamodel.EntityType; import javax.persistence.metamodel.Metamodel; import javax.persistence.metamodel.PluralAttribute; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.dao.DataAccessException; import org.springframework.data.domain.Example; import org.springframework.data.domain.ExampleMatcher; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.stereotype.Service; import com.kucun.data.entity.Bancai; import com.kucun.data.entity.Caizhi; import com.kucun.data.entity.Chanpin; import com.kucun.data.entity.Chanpin_zujian; import com.kucun.data.entity.Dingdan; import com.kucun.data.entity.Dingdan_chanpin; import com.kucun.data.entity.Dingdan_chanpin_zujian; import com.kucun.data.entity.EntityBasis; import com.kucun.data.entity.Information; import com.kucun.data.entity.Kucun; import com.kucun.data.entity.Mupi; import com.kucun.data.entity.User; import com.kucun.data.entity.Zujian; import com.kucun.dataDo.BancaiRepository; import com.kucun.dataDo.CaizhiRepository; import com.kucun.dataDo.ChanpinRepository; import com.kucun.dataDo.ChanpinZujianRepository; import com.kucun.dataDo.DingdanChanpinRepository; import com.kucun.dataDo.DingdanChanpinZujianRepository; import com.kucun.dataDo.DingdanRepository; import com.kucun.dataDo.KucunRepository; import com.kucun.dataDo.MupiRepository; import com.kucun.dataDo.UserRepository; import com.kucun.dataDo.ZujianRepository; @Service public class AppService { // 注入所有需要的Repository @Autowired private CaizhiRepository caizhiRepository; @Autowired private BancaiRepository bancaiRepository; @Autowired private ChanpinRepository chanpinRepository; @Autowired private DingdanRepository dingdanRepository; @Autowired private MupiRepository mupiRepository; @Autowired private ZujianRepository zujianRepository; @Autowired private KucunRepository kucunRepository; @Autowired private UserRepository userRepository; @Autowired private ChanpinZujianRepository chanpinZujianRepository; @Autowired private DingdanChanpinZujianRepository dingdanChanpinZujianRepository; @Autowired private DingdanChanpinRepository dingdanChanpinRepository; @Autowired private DynamicRepositoryService repositoryService; // private Map<String, JpaRepository<?, ?>> shiti; // // // @Override // public void setApplicationContext(ApplicationContext context) { // this.shiti = getJpaRepositories(context); // } // // public Map<String, JpaRepository<?, ?>> getJpaRepositories(ApplicationContext context) { // return context.getBeansWithAnnotation(Repository.class) // .entrySet() // .stream() // .filter(entry -> entry.getValue() instanceof JpaRepository) // .collect(Collectors.toMap( // entry -> { // JpaRepository<?, ?> repo = (JpaRepository<?, ?>) entry.getValue(); // return getEntityClass(repo).getName(); // }, // entry -> (JpaRepository<?, ?>) entry.getValue() // )); // } // // public static Class<?> getEntityClass(JpaRepository<?, ?> repo) { // try { // // 处理Spring代理类 // Object target = repo; // while (target instanceof Advised) { // target = ((Advised) target).getTargetSource().getTarget(); // } // // // 通过Spring的ResolvableType解析泛型 // ResolvableType resolvableType = ResolvableType.forClass( // target.getClass()).as(JpaRepository.class); // // if (resolvableType.getGenerics().length > 0) { // Class<?> entityClass = resolvableType.getGeneric(0).resolve(); // if (entityClass != null) { // return entityClass; // } // } // // throw new IllegalStateException("无法解析实体类型"); // } catch (Exception e) { // throw new RuntimeException("获取实体类失败: " + e.getMessage(), e); // } // } // // public Information getAllDataWithChildIdse() { // Map<String, Object> response = new HashMap<>(); // // response.put("caizhis", (caizhiRepository.findAll())); // response.put("bancais", (bancaiRepository.findAll())); // response.put("chanpins", (chanpinRepository.findAll())); // response.put("dingdans", (dingdanRepository.findAll())); // response.put("mupis", (mupiRepository.findAll())); // response.put("zujians", (zujianRepository.findAll())); // response.put("kucuns", (kucunRepository.findAll())); // response.put("users", (userRepository.findAll())); // response.put("chanpin_zujians", (chanpinZujianRepository.findAll())); // response.put("chanpin_zujians", (dingdanChanpinZujianRepository.findAll())); // response.put("chanpin_zujians", (dingdanChanpinRepository.findAll())); // // return Information.NewSuccess(response); // } public Information getAllDataWithChildIdse() { Map<String, Object> response = new HashMap<>(); for (String key : repositoryService.getRepositoryNameMap().keySet()) { response.put(key+"s", (repositoryService.getJpaRepository(key).findAll())); } return Information.NewSuccess(response); } public Information getAllDataWithChildIdse(String e) { JpaRepository<?, ?> jp = repositoryService.getJpaRepository(e); System.out.println(jp); return Information.NewSuccess(jp.findAll()); } public Information getAddEntity(Object e) { Class<?> entityClass = e.getClass(); try { // 处理关联字段 handleAssociations(e); @SuppressWarnings("unchecked") JpaRepository<Object, Serializable> jp = (JpaRepository<Object, Serializable>) repositoryService.getJpaRepository(entityClass); Object savedEntity = jp.save(e); if(savedEntity!=null) { if(savedEntity instanceof Bancai) { initializeKucunForBancai((Bancai)savedEntity); } } return Information.NewSuccess(savedEntity); } catch (Exception ex) { return Information.Newfail(500, "创建失败: " + ex.getMessage(), null); } } // 单独封装库存初始化方法 private void initializeKucunForBancai(Bancai bancai) throws Exception { Kucun kucun = new Kucun(null, bancai, 0); // 初始库存为0 try { bancai.setKucun(kucunRepository.save(kucun)); } catch (Exception e) { // TODO: handle exception throw new Exception("initializeKucunForBancai"+e); } } // 处理关联对象（转换为托管实体） private void handleAssociations(Object entity) throws Exception { Class<?> clazz = entity.getClass(); for (Field field : clazz.getDeclaredFields()) { field.setAccessible(true); Object value = field.get(entity); if (value == null) continue; // 处理单个关联实体 if (isEntityBasisField(field)) { EntityBasis associatedEntity = (EntityBasis) value; JpaRepository<Object, Serializable> repo = (JpaRepository<Object, Serializable>) repositoryService.getJpaRepository(associatedEntity.getClass()); // 获取托管状态的关联实体 Object managedEntity = repo.findById(associatedEntity.getId()) .orElseThrow(() -> new RuntimeException("关联实体不存在")); field.set(entity, managedEntity); } // 处理集合关联 else if (isCollectionField(field)) { Collection<?> collection = (Collection<?>) value; List<Object> managedEntities = new ArrayList<>(); for (Object item : collection) { if (item instanceof EntityBasis) { EntityBasis eb = (EntityBasis) item; JpaRepository<Object, Serializable> repo = (JpaRepository<Object, Serializable>) repositoryService.getJpaRepository(eb.getClass()); Object managedEntity = repo.findById(eb.getId()) .orElseThrow(() -> new RuntimeException("关联实体不存在")); managedEntities.add(managedEntity); } } // 更新集合为托管实体 if (!managedEntities.isEmpty()) { field.set(entity, managedEntities); } } } } /** * 更新 * @param e 实体待id * @return */ /** * 更新实体 * @param e 包含ID的实体 * @return 操作结果 */ public Information getupdateEntity(Object e) { if(e == null) { return Information.Newfail(403, "参数为空", null); } Class<?> entityClass = e.getClass(); try { Field idField = entityClass.getDeclaredField("id"); idField.setAccessible(true); Object idValue = idField.get(e); // 修正：应检查id是否为空，而不是不为空 if(idValue == null) { return Information.Newfail(403, "Id为空", null); } // 获取Repository @SuppressWarnings("unchecked") JpaRepository<Object, Serializable> jp = (JpaRepository<Object, Serializable>) repositoryService.getJpaRepository(entityClass); // 从数据库加载现有实体（托管状态） Object existingEntity = jp.findById((Serializable) idValue) .orElseThrow(() -> new RuntimeException("实体不存在")); // 复制属性（排除关联字段） copyNonNullProperties(e, existingEntity); // 保存托管状态的实体 Object updatedEntity = jp.save(existingEntity); return Information.NewSuccess(updatedEntity); } catch (Exception ex) { return Information.Newfail(500, "更新失败: " + ex.getMessage(), null); } } /** * 删除 * @param entity * @return */ public Information getdeleteEntity(EntityBasis entity) { Map<String, Object> response = new HashMap<>(); JpaRepository<Object, Integer> jp= (JpaRepository<Object, Integer>) repositoryService.getJpaRepository(entity.getClass().getSimpleName().toLowerCase()); if(!jp.existsById(entity.getId())) { return Information.NewFail("没有该数据"); } Object d=jp.findById(entity.getId()).orElse(null); for (Class<?> nt : repositoryService.getRepositoryMap().keySet()) { for (Field ent : nt.getDeclaredFields()) { if(ent.getClass().equals(entity.getClass())) { Object o=null; try { o = nt.newInstance(); ent.set(o, d); } catch (InstantiationException | IllegalAccessException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println(o); if(getSELECTEntity(o).getData()!=null) { return Information.NewFail("已在其他地方使用了，无法删除"); } } } } try { jp.deleteById(((EntityBasis)entity).getId()); } catch (Exception e) { // TODO: handle exception System.out.println(e.getLocalizedMessage()); } if(jp.existsById(entity.getId())) { System.out.println("删除失败"); return Information.NewFail("删除失败"); } return Information.NewSuccess(response); } // 复制非空属性（忽略关联字段） private void copyNonNullProperties(Object source, Object target) throws IllegalAccessException { Class<?> clazz = source.getClass(); for (Field field : clazz.getDeclaredFields()) { field.setAccessible(true); Object value = field.get(source); // 跳过关联字段和特殊字段 if (value != null && !isEntityBasisField(field) && !isCollectionField(field) && !field.getName().equals("id")) { Field targetField; try { targetField = target.getClass().getDeclaredField(field.getName()); targetField.setAccessible(true); targetField.set(target, value); } catch (NoSuchFieldException e) { // 忽略不存在的字段 } } } } // 检查是否为关联实体字段 private boolean isEntityBasisField(Field field) { return EntityBasis.class.isAssignableFrom(field.getType()); } // 检查是否为集合字段 private boolean isCollectionField(Field field) { return Collection.class.isAssignableFrom(field.getType()) || Map.class.isAssignableFrom(field.getType()); } /** * 根据非空属性值动态查询实体 * @param entity 包含查询条件的实体对象（非空属性作为查询条件） * @return 查询结果信息（成功时包含数据列表） */ public <T>Information getSELECTEntity(T entity) { if (entity == null) { return Information.NewFail("查询参数不能为空"); } Class<T> entityClass = (Class<T>) entity.getClass(); try { // 1. 获取非泛型的Repository JpaRepository repository = repositoryService.getJpaRepository(entityClass); // 2. 构建非泛型的Example查询 ExampleMatcher matcher = ExampleMatcher.matching() .withIgnoreNullValues() .withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING); // 这里直接使用原始类型Example Example<T> example = Example.of(entity);//he type Example is not generic; it cannot be parameterized with arguments <T>the method of(T) is undefined for the type Example // 3. 执行查询 List<?> result = repository.findAll(example); return Information.NewSuccess(result); } catch (ClassCastException e) { return Information.NewFail("Repository类型不匹配: " + e.getMessage()); } catch (DataAccessException e) { return Information.NewFail("数据库访问错误: " + e.getMessage()); } catch (Exception e) { return Information.NewFail("系统错误: " + e.getMessage()); } } private List<Map<String, Object>> convertEntityBasis(List<EntityBasis> entities) { return entities.stream().map(entity -> { Map<String, Object> map = new HashMap<>(); Field[] fields = entity.getClass().getDeclaredFields(); try { // 添加实体自身的基本字段 map.put("id", entity.getId()); // 处理所有字段 for (Field field : fields) { field.setAccessible(true); // 允许访问私有字段 Object fieldValue = field.get(entity); if (fieldValue != null) { String fieldName = field.getName(); // 处理集合类型关联 if (isCollection(field)) { if (!((Collection<?>) fieldValue).isEmpty()) { List<Map<String, Object>> collectionItems = ((Collection<?>) fieldValue) .stream() .filter(item -> item instanceof EntityBasis) .map(item -> { Map<String, Object> itemMap = new HashMap<>(); itemMap.put("id", ((EntityBasis) item).getId()); return itemMap; }) .collect(Collectors.toList()); map.put(fieldName, collectionItems); } } // 处理单个实体关联 else if (implementsInterface(field, EntityBasis.class)) { Map<String, Object> associatedMap = new HashMap<>(); associatedMap.put("id", ((EntityBasis) fieldValue).getId()); map.put(fieldName, associatedMap); } // 处理其他基本类型字段 else if (!isSpecialField(fieldName)) { map.put(fieldName, fieldValue); } } } } catch (IllegalAccessException e) { e.printStackTrace(); } return map; }).collect(Collectors.toList()); } // 判断是否为特殊字段（需要排除的字段） private boolean isSpecialField(String fieldName) { return fieldName.equals("handler") || fieldName.equals("hibernateLazyInitializer"); } /** *-判断属性是否为集合类型 * @param field * @return */ boolean isCollection(Field field) { Class<?> type = field.getType(); // 检查是否为Java内置集合类型 if (Collection.class.isAssignableFrom(type) || Map.class.isAssignableFrom(type) || type.isArray()) { return true; } // 检查是否实现集合相关接口（如Iterable） for (Class<?> interfaceType : type.getInterfaces()) { if (Iterable.class.isAssignableFrom(interfaceType)) { return true; } } return false; } /** * -判断属性是否实现特定接口 * @param field * @param targetInterface * @return */ boolean implementsInterface(Field field, Class<?> targetInterface) { Class<?> type = field.getType(); // 检查类本身是否实现接口 if (targetInterface.isAssignableFrom(type)) { return true; } // 检查实现的接口是否继承目标接口 for (Class<?> interfaceType : type.getInterfaces()) { if (targetInterface.isAssignableFrom(interfaceType)) { return true; } } return false; } private Object convertDingdanChanpins(List<Dingdan_chanpin> findAll) { // TODO Auto-generated method stub return null; } private Object convertDingdanChanpinZujians(List<Dingdan_chanpin_zujian> findAll) { // TODO Auto-generated method stub return null; } } 删除功能完善
06-18
>>> associationCache = new HashMap<>(); /** * 检查实体是否被其他实体引用 * @param entityClass 实体类 * @param entityId 实体ID * @return 存在引用返回true */ public boolean hasDependencies(Class...
package com.example.kucun2.entity.data; import android.content.Context; import android.os.Handler; import android.os.Looper; import android.util.Log; import com.example.kucun2.entity.*; import com.example.kucun2.function.MyAppFnction; import com.example.kucun2.function.SafeLogger; import com.google.gson.Gson; import com.google.gson.reflect.TypeToken; import java.io.IOException; import java.lang.reflect.Field; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import java.util.*; import okhttp3.Call; import okhttp3.Callback; import okhttp3.OkHttpClient; import okhttp3.Request; import okhttp3.Response; public class Data { // 数据集合声明（保持原有属性名不变） public static SynchronizedList<Bancai> bancais = new SynchronizedList<>(Bancai.class); public static SynchronizedList<Caizhi> caizhis = new SynchronizedList<>(Caizhi.class); public static SynchronizedList<Mupi> mupis = new SynchronizedList<>(Mupi.class); public static SynchronizedList<Chanpin> chanpins = new SynchronizedList<>(Chanpin.class); public static SynchronizedList<Chanpin_Zujian> chanpin_zujians = new SynchronizedList<>(Chanpin_Zujian.class); public static SynchronizedList<Dingdan> dingdans = new SynchronizedList<>(Dingdan.class); public static SynchronizedList<Dingdan_Chanpin> dingdan_chanpins = new SynchronizedList<>(Dingdan_Chanpin.class); public static SynchronizedList<Dingdan_chanpin_zujian> Dingdan_chanpin_zujians = new SynchronizedList<>(Dingdan_chanpin_zujian.class); public static SynchronizedList<Kucun> kucuns = new SynchronizedList<>(Kucun.class); public static SynchronizedList<Zujian> zujians = new SynchronizedList<>(Zujian.class); public static SynchronizedList<User> users = new SynchronizedList<>(User.class); public static SynchronizedList<Jinhuo> jinhuos = new SynchronizedList<>(Jinhuo.class); public static final Map<Class,SynchronizedList<SynchronizableEntity>> dataCollectionMap=new HashMap<>(); private static final Gson gson = new Gson(); private static OkHttpClient client ; private static final String TAG = "DataLoader"; static { // 静态初始化块：在类加载时执行，保证所有静态字段已初始化 try { Field[] fields = Data.class.getDeclaredFields(); for (Field field : fields) { if (SynchronizedList.class.isAssignableFrom(field.getType())) { // 获取泛型类型参数 ParameterizedType parameterizedType = (ParameterizedType) field.getGenericType(); Class<?> entityType = (Class<?>) parameterizedType.getActualTypeArguments()[0]; // 创建 SynchronizedList 并设置实体类型 SynchronizedList<?> list = new SynchronizedList<>((Class<SynchronizableEntity>) entityType); field.set(null, list); // 将列表添加到 dataCollectionMap if (list != null) { dataCollectionMap.put(entityType, (SynchronizedList<SynchronizableEntity>) list); } } } } catch (IllegalAccessException e) { throw new RuntimeException("初始化dataCollectionMap失败", e); } } public static void loadAllData(Context context, LoadDataCallback callback) { if (Looper.myLooper() != Looper.getMainLooper()) { throw new IllegalStateException("Data.loadAllData must be called on main thread"); } // 确保使用安全的客户端 if (client == null) { client= MyAppFnction.getClient(); } //禁用同步 SynchronizableEntity.setSyncEnabled(false); String url = MyAppFnction.getStringResource("string", "url") + MyAppFnction.getStringResource("string", "url_all"); Log.d("url", "loadAllData: " + url); Request request = new Request.Builder() .url(url) .build(); client.newCall(request).enqueue(new Callback() { @Override public void onFailure(Call call, IOException e) { Log.e(TAG, "Failed to load data", e); SynchronizableEntity.setSyncEnabled(true); if (callback != null)safeCallback(callback, false); } @Override public void onResponse(Call call, Response response) throws IOException { if (!response.isSuccessful()) { Log.e(TAG, "Unexpected response code: " + response.code()); if (callback != null) safeCallback(callback, false); return; } String responseData = response.body().string(); SynchronizableEntity.setSyncEnabled(true); ensurePreservedObjects(); parseAndAssignData(responseData, context, callback); } }); } // 解析并赋值数据 private static void parseAndAssignData(String jsonData, Context context, LoadDataCallback callback) { // 创建包含所有数据类型的TypeToken ensurePreservedObjects(); Type informationType = new TypeToken<Information<AllDataResponse>>(){}.getType(); Information<AllDataResponse> information = gson.fromJson(jsonData, informationType); Log.e(TAG, "Invalid response data"+jsonData); if (information == null || information.getData() == null || information.getStatus() != 200) { Log.e(TAG, "Invalid response data"); if (callback != null) callback.onFailure(); return; } AllDataResponse allData = information.getData(); SafeLogger.d("data","数据："+gson.toJson(allData)); safeInitializeList(allData.bancais); safeInitializeList(allData.caizhis); safeInitializeList(allData.mupis); safeInitializeList(allData.chanpins); safeInitializeList(allData.chanpin_zujians); safeInitializeList(allData.dingdans); safeInitializeList(allData.dingdan_chanpins); safeInitializeList(allData.Dingdan_chanpin_zujians); safeInitializeList(allData.kucuns); safeInitializeList(allData.zujians); safeInitializeList(allData.users); safeInitializeList(allData.jinhuos); SafeLogger.d("data","数据：非空"+gson.toJson(allData)); // 赋值到对应的列表（使用安全方法保持已有引用） updateList(bancais, allData.bancais); updateList(caizhis, allData.caizhis); updateList(mupis, allData.mupis); updateList(chanpins, allData.chanpins); updateList(chanpin_zujians, allData.chanpin_zujians); updateList(dingdans, allData.dingdans); updateList(dingdan_chanpins, allData.dingdan_chanpins); updateList(Dingdan_chanpin_zujians, allData.Dingdan_chanpin_zujians); updateList(kucuns, allData.kucuns); updateList(zujians, allData.zujians); updateList(users, allData.users); updateList(jinhuos, allData.jinhuos); SafeLogger.d("data","数据：data.bancais"+gson.toJson(Data.bancais)); // 在设置引用关系前关闭同步 SynchronizableEntity.setSyncEnabled(false); Log.d("DataParse", "开始解析JSON数据"); resolveReferences(); Log.d("DataParse", "解析完成，实体关系建立"); // 为所有实体设置正确状态（已存在服务器） setAllEntitiesState(SynchronizableEntity.SyncState.MODIFIED); ensurePreservedObjects(); // 启用同步 SynchronizableEntity.setSyncEnabled(true); if (callback != null) callback.onSuccess(); } public static void safeCallback(LoadDataCallback callback, boolean success) { new Handler(Looper.getMainLooper()).post(() -> { if (success) { callback.onSuccess(); } else { callback.onFailure(); } }); } // 更新列表内容但保持对象引用不变 private static <T extends SynchronizableEntity> void updateList(List<T> existingList, List<T> newList) { if (newList == null) return; // 创建临时列表保留预置对象 List<T> preservedObjects = new ArrayList<>(); for (T item : existingList) { if (item != null && item.isPreservedObject()) { preservedObjects.add(item); } } // 清除原有列表并添加保留对象 existingList.clear(); existingList.addAll(preservedObjects); // 添加新数据，跳过预置对象的ID for (T newItem : newList) { if (newItem.getId() != null && newItem.getId() != -1) { existingList.add(newItem); } } } // 添加确保预置对象存在的方法 private static void ensurePreservedObjects() { if (!containsPreservedObject(bancais)) bancais.add(createInstance(Bancai.class)); if (!containsPreservedObject(caizhis)) caizhis.add(createInstance(Caizhi.class)); if (!containsPreservedObject(mupis)) mupis.add(createInstance(Mupi.class)); if (!containsPreservedObject(chanpins)) chanpins.add(createInstance(Chanpin.class)); if (!containsPreservedObject(chanpin_zujians)) chanpin_zujians.add(createInstance(Chanpin_Zujian.class)); if (!containsPreservedObject(dingdans)) dingdans.add(createInstance(Dingdan.class)); if (!containsPreservedObject(kucuns)) kucuns.add(createInstance(Kucun.class)); if (!containsPreservedObject(zujians)) zujians.add(createInstance(Zujian.class)); if (!containsPreservedObject(Dingdan_chanpin_zujians)) Dingdan_chanpin_zujians.add(createInstance(Dingdan_chanpin_zujian.class)); if (!containsPreservedObject(dingdan_chanpins)) dingdan_chanpins.add(createInstance(Dingdan_Chanpin.class)); if (!containsPreservedObject(jinhuos)) jinhuos.add(createInstance(Jinhuo.class)); if (!containsPreservedObject(users)) users.add(createInstance(User.class)); // 为其他需要预置对象的列表添加... try { setDefaultAssociation(bancais); } catch (IllegalAccessException e) { throw new RuntimeException(e); } catch (ClassNotFoundException e) { throw new RuntimeException(e); } } // 检查列表是否包含预置对象 private static <T extends SynchronizableEntity> boolean containsPreservedObject(List<T> list) { for (T item : list) { if (item != null && item.isPreservedObject()) { Log.d(TAG, "containsPreservedObject: "+item.getId()); item= (T) createInstance(item.getClass()); return true; } } return !list.isEmpty(); } private static <T extends SynchronizableEntity> void setDefaultAssociation(SynchronizedList<T> e ) throws IllegalAccessException, ClassNotFoundException { for (T t:e) { Class clazz=t.getClass(); Field[] fields = clazz.getDeclaredFields(); for (Field f:fields){ f.setAccessible(true); Class s=f.getType(); if(SynchronizableEntity.class.isAssignableFrom(s)){ if (t.getId()<0 ||f.get(t)==null|| ((SynchronizableEntity)f.get(t)).getId()==null) { f.set(t, dataCollectionMap.get(s).get(-1)); }else { f.set(t, dataCollectionMap.get(s).get( ((SynchronizableEntity)f.get(t)).getId())); } } if (List.class.isAssignableFrom(s)){ Type genericSuperclass = s.getGenericSuperclass(); if (genericSuperclass instanceof ParameterizedType) { ParameterizedType pt = (ParameterizedType) genericSuperclass; Type[] types = pt.getActualTypeArguments(); System.out.println("集合类型: " + types[0].getTypeName()); // User Class c=Class.forName(types[0].getTypeName()); if(SynchronizableEntity.class.isAssignableFrom(c)) { List<SynchronizableEntity> l = (List<SynchronizableEntity>) f.get(t); if (l == null) { l = new ArrayList(); } if (l.isEmpty() || t.getId() < 0) { l.add(dataCollectionMap.get(c).get(-1)); } if (!l.isEmpty()) { for (int i = 0; i < l.size(); i++) { l.set(i,dataCollectionMap.get(c).get( l.get(i).getId())); } } } } } } } } /** * 根据传入的Class对象创建对应类型的实例 * @param clazz 目标类型对应的Class对象 * @param <T> 目标类型泛型参数 * @return 指定类型的实例 */ public static <T> T createInstance(Class<T> clazz) { try { // 通过反射调用无参构造函数创建实例 T g=clazz.getDeclaredConstructor().newInstance(); // Log.d("g",""+g); Field[] fields = clazz.getDeclaredFields(); for (Field f: fields ) { f.setAccessible(true); if(f.getType().equals(String.class)){ f.set(g,"无"); } if(f.getType().equals(Integer.class)){ f.set(g,-1); }if(f.getType().equals(Double.class)){ f.set(g,-1.0); } if (f.getType().equals(Date.class)){ f.set(g,new Date()); } } Log.d("g",""+gson.toJson(g)); clazz.getMethod("setId",Integer.class).invoke(g,-1); clazz.getMethod("setState", SynchronizableEntity. SyncState.class) .invoke(g,SynchronizableEntity.SyncState.PRESERVED); return g; } catch (Exception e) { Log.d(TAG, "createInstance: "+e.getLocalizedMessage()); throw new RuntimeException("创建实例失败: " + clazz.getName(), e); } } // // 创建预置板材对象 // private static<T> T createPreservedBancai(Class<T> t) { // Bancai preserved = new Bancai(); // preserved.setId(-1); // preserved.setState(SynchronizableEntity.SyncState.PRESERVED); // return preserved; // } // 解析对象间的引用关系（使用ID关联） private static void resolveReferences() { // 创建ID到对象的映射 Map<Integer, Bancai> bancaiMap = createIdMap(bancais); Map<Integer, Caizhi> caizhiMap = createIdMap(caizhis); Map<Integer, Mupi> mupiMap = createIdMap(mupis); Map<Integer, Chanpin> chanpinMap = createIdMap(chanpins); Map<Integer, Zujian> zujianMap = createIdMap(zujians); Map<Integer, Dingdan> dingdanMap = createIdMap(dingdans); Map<Integer, Kucun> kucunMap = createIdMap(kucuns); Log.d("RefResolution", "开始解析实体关系..."); // 解析Bancai引用 for (Bancai bancai : bancais) { if (bancai.getCaizhi() != null) { bancai.setCaizhi(caizhiMap.get(bancai.getCaizhi().getId())); } if (bancai.getMupi1() != null) { bancai.setMupi1(mupiMap.get(bancai.getMupi1().getId())); } if (bancai.getMupi2() != null) { bancai.setMupi2(mupiMap.get(bancai.getMupi2().getId())); } } // 解析Kucun引用 for (Kucun kucun : kucuns) { if(kucun==null)break; if (kucun.getBancai() != null) { kucun.setBancai(bancaiMap.get(kucun.getBancai().getId())); } } // 解析订单相关的嵌套对象 for (Dingdan_Chanpin dc : dingdan_chanpins) { if(dc==null)break; if (dc.getDingdan() != null) { dc.setDingdan(dingdanMap.get(dc.getDingdan().getId())); } if (dc.getChanpin() != null) { dc.setChanpin(chanpinMap.get(dc.getChanpin().getId())); } } // 解析产品相关的嵌套对象 for (Chanpin_Zujian cz : chanpin_zujians) { if(cz==null)break; if (cz.getChanpin() != null) { cz.setChanpin(chanpinMap.get(cz.getChanpin().getId())); } if (cz.getZujian() != null) { cz.setZujian(zujianMap.get(cz.getZujian().getId())); } if (cz.getBancai() != null) { cz.setBancai(bancaiMap.get(cz.getBancai().getId())); } } // 解析库存关联 for (Kucun k : kucuns) { if(k==null)break; if (k.getBancai() != null) { k.setBancai(bancaiMap.get(k.getBancai().getId())); } } // 添加缺失的实体关系解析 for (Dingdan_chanpin_zujian dm : Dingdan_chanpin_zujians) { if (dm.getZujian() != null) { // 确保组件和板材关联 dm.setZujian(chanpin_zujians.stream() .filter(cz -> cz.getId().equals(dm.getZujian().getId())) .findFirst().orElse(null)); if (dm.getBancai() != null) { dm.setBancai(bancais.stream() .filter(b -> b.getId().equals(dm.getBancai().getId())) .findFirst().orElse(null)); } } } } // 创建ID到对象的映射 private static <T extends EntityClassGrassrootsid> Map<Integer, T> createIdMap(List<T> list) { return createSafeIdMap(list); } // 回调接口 public interface LoadDataCallback { void onSuccess(); void onFailure(); } // 确保列表不为null private static <T> void safeInitializeList(List<T> list) { if (list == null) { list = new ArrayList<>(); } } // 安全创建ID映射 private static <T extends EntityClassGrassrootsid> Map<Integer, T> createSafeIdMap(List<T> list) { Map<Integer, T> map = new HashMap<>(); if (list != null) { for (T item : safeIterable(list)) { if (item != null && item.getId() != null) { map.put(item.getId(), item); } } } return map; } // 安全迭代方法（处理空集合） private static <T> Iterable<T> safeIterable(List<T> list) { return list != null ? list : Collections.emptyList(); } // 内部类用于解析JSON响应 public static class AllDataResponse { public List<Bancai> bancais; public List<Caizhi> caizhis; public List<Mupi> mupis; public List<Chanpin> chanpins; public List<Chanpin_Zujian> chanpin_zujians; public List<Dingdan> dingdans; public List<Dingdan_Chanpin> dingdan_chanpins; public List<Dingdan_chanpin_zujian> Dingdan_chanpin_zujians; public List<Kucun> kucuns; public List<Zujian> zujians; public List<User> users; public List<Jinhuo> jinhuos; } // 新增方法：设置所有实体状态 private static void setAllEntitiesState(SynchronizableEntity.SyncState state) { setListState(bancais, state); setListState(caizhis, state); setListState(mupis, state); setListState(Dingdan_chanpin_zujians, state); setListState(dingdans, state); setListState(chanpins, state); setListState(chanpin_zujians, state); setListState(zujians, state); setListState(jinhuos, state); setListState(kucuns, state); setListState(users, state); setListState(caizhis, state); // ... 其他列表 } private static <T extends SynchronizableEntity> void setListState(List<T> list, SynchronizableEntity.SyncState state) { for (T entity : list) { entity.setState(state); } } } E FATAL EXCEPTION: main Process: com.example.kucun2, PID: 21888 java.lang.ExceptionInInitializerError at com.example.kucun2.MainActivity.loadAppData(MainActivity.java:100) at com.example.kucun2.MainActivity.onCreate(MainActivity.java:31) at android.app.Activity.performCreate(Activity.java:9441) at android.app.Activity.performCreate(Activity.java:9387) at android.app.Instrumentation.callActivityOnCreate(Instrumentation.java:1526) at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:4644) at android.app.ActivityThread.handleLaunchActivity(ActivityThread.java:4876) at android.app.servertransaction.LaunchActivityItem.execute(LaunchActivityItem.java:112) at android.app.servertransaction.TransactionExecutor.executeNonLifecycleItem(TransactionExecutor.java:220) at android.app.servertransaction.TransactionExecutor.executeTransactionItems(TransactionExecutor.java:148) at android.app.servertransaction.TransactionExecutor.execute(TransactionExecutor.java:120) at android.app.ActivityThread$H.handleMessage(ActivityThread.java:3102) at android.os.Handler.dispatchMessage(Handler.java:109) at android.os.Looper.loopOnce(Looper.java:250) at android.os.Looper.loop(Looper.java:340) at android.app.ActivityThread.main(ActivityThread.java:9913) at java.lang.reflect.Method.invoke(Native Method) at com.android.internal.os.RuntimeInit$MethodAndArgsCaller.run(RuntimeInit.java:621) at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:957) Caused by: java.lang.IllegalArgumentException: Entity type cannot be null at com.example.kucun2.entity.data.SynchronizedList.<init>(SynchronizedList.java:35) at com.example.kucun2.entity.data.Data.<clinit>(Data.java:26) ... 19 more
06-13
错误日志显示在 `Data` 类的静态初始化块中出现异常：`java.lang.IllegalArgumentException: Entity type cannot be null`。这个异常发生在 `SynchronizedList` 的构造函数中，说明在创建 `SynchronizedList` 实例时...
泛型问题-The type Map is not generic; it cannot be parameterized with arguments
weixin_30539835的博客
05-25 1374
　　解决办法有两个步骤，如果第一步不行，再试一下第二步。 第一步： 　　修改Window-〉Preferences->Java ->Compiler->JDK Compliance中的compiler compliance level，把它设为5.0或者以上。 第二步： 　　修改Window-〉Preferences->Java ->I...
eclipse The type Map is not generic； it cannot be parameterized with arguments ＜String, String＞
weixin_46608163的博客
11-17 392
因为我eclipse报了错 idea没报错 然后想应该是环境的问题 上网找了下说是jar包冲突 你引入的别的jar包里有这些基础包导致冲突报错,但是我又找不到冲突的包因为导入的包太多了,然后我们可以将jdk的优先级调高,具体操作是。单击jdk并且 按TOP按钮并将其移至第一个位置 然后 applay and close。首先确保你引入的是java.util,不要引错了别的类。从右侧面板中选择Java Build Path。选择Order and Export。
The type HashMap is not generic
rootkiss的博客
05-05 880
问题：提示HashMap并非泛型 错误原因：我把类名设置为了HashMap，，，人家HashMap本来就是个类啊！ 解决方法：修改类名
The type List is not generic; it cannot be parameterized with arguments <Integer>
热门推荐
提升心智
05-08 6万+
The type List is not generic; it cannot be parameterized with arguments <Integer> 今天写一个list 报了这个莫名其妙的警告 List<Integer> list1 = new ArrayList<Integer>(); 发现是包导错了 import java.awt.List; 换成 util包就好了 import java.util.List; 做了很久的 android 了 突然对这个awt 包感兴
力扣附属--处理报错:The type List is not generic； it cannot be parameterized with arguments
weixin_45941945的博客
03-28 753
导错包了 应该import java.util.*
报错-The type List is not generic; it cannot be parameterized with arguments。
qq_41950447的博客
05-16 1499
在使用泛型类List<>的时候，突然就报错了。泛型类是jdk1.5以上才支持的，我用的就是1.5以上的。无奈上网上查了一查，结果是包引错了。 public List <StuClass> getClassList(StuClass stuClass){ List<StuClass> retList = new ArrayList<StuClass&gt...
解决：The type List is not generic; it cannot be parameterized with arguments
qq_37942904的博客
05-10 2079
发现报错： 原因可能包导错了： 将： import java.awt.List; 替换成 import java.util.List;就OK了。 每天进步一点点
The type List is not generic; it cannot be parameterized with arguments <T>
b296405422的博客
04-01 1104
导入的包import java.awt.List;改为import java.util.List;
jboss编译servlet时报错：The type List is not generic
iteye_14397的博客
09-19 205
    今天在测试过程中遇到一个错误，打开jsp页面上报错：The type List is not generic; it cannot be parameterized with arguments，原因是引入的List对象使用了泛型，jboss编译不通过。我第一印象想到的就是jdk的版本问题了，因为在1.4之前是没有泛型这种类型了，但是检查eclipse的jdk版本都正常，google一下原...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值