数据库为空值的处理 以及List.add方法

最新推荐文章于 2022-12-21 08:56:27 发布
原创 最新推荐文章于 2022-12-21 08:56:27 发布 · 957 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细解释了在声明List元素时使用List<class> name=new ArrayList<class>()的重要性，并阐述了其背后的原理。通过理解ArrayList的长度可变特性，读者将学会如何正确地使用add等方法进行元素添加。

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

List.add  在声明List元素的时候应当用List<class>  name = new  ArrayList<class>()

只用这样才能正常的使用add等方法。


这主要是因为ArrayList的长度是可变的，因此可以不断地添加。

Java list.add(list)为空问题
阿拉修
12-07 2280
先看代码 class Solution { List<List<String>> res = new ArrayList<>(); List<String> path = new ArrayList<>(); public List<List<String>> partition(String s) { backtracing(0,s); return res;
C#在List集合为NULL时需要添加数据的处理方法
余音Yoin的博客
12-22 4625
众所周知，List集合在为null时是不能使用Add来添加对象的。
Java中List.add(list)为空问题
fantow的博客
09-21 5174
参考博文 List调用add()方法为空解释(qq_34250494 的回答) 在做LeetCode 39. Combination Sum 时使用到了递归，在合适的条件下将本次结果添加到List<List> result 中。 class Solution { public List<List<Integer>> combinationSum(int...
List等于null时，list.add()失败
乱码行空的博客
12-11 4793
List等于null时，list.add()失败 工作中新建一个list，手误有时会会这样写 List<User> mapsList = null; 这样写的话有时会报一个NullPonterException的错误 java.lang.NullPonterException:null at com................... 原因是什么呢？文章结尾会说，先说解决方法，改成如下代码就可以了 List<User> mapsList = new ArrayList&lt
Java小细节：List可以add(null)吗？
tank的博客
04-13 662
在写代码的时候，有时候遇到for循环，写到下面的时候有一点犹豫。 遍历的时候，是否需要对每个元素判空？换句话说，List是否可以允许add null。 List<Data> dataList = ...; for (Data d : dataList) { if (d != null) { // 我需要这个判断吗？ // ... } } 然后我实验了一...
C# 获取数据库某字段空值处理办法
博客
06-20 5592
在查询语句中难免遇到查询字段为空的情况，所以如何处理返回空值就是一个必须处理的问题； sqlserver在数据库中空值时NULL，在查询后就是一个空，不是“”，也不是null所以无法用sr[0]==null来判断； ` 在进行判断的时候我查看网上判断空值的办法大体分为三种： 1.通过System.DBNull类来判断； dt.rows[0]["字段名"] == DBNull.Value; ...
【Python】Scrapy ItemLoader 处理空列表让数据库字段为空值
用代码书写梦想
10-20 2580
问题描述 我需要爬取某些招聘网页上的信息，但不是所有招聘网页中展示的信息都一样，例如有些网页上并没有附上公司网址，而如果没有需要在数据库相应的字段中赋值为空。 方法一：不使用itemLoader 使用extract_first()取得列表第一个元素，默认值为‘’，但这不适用列表中有多个元素，比如不止爬取一个标签 def parse_detail(self, response): a...
Java 8中Collectors.groupingBy方法空指针异常源码分析
m0_71777195的博客
08-03 3835
现在有这样的一个需求： 老板让把所有的员工按年龄进行分组，然后统计各个年龄的人数。这个需求，如果是在数据库中，可以直接使用一个group by语句进行统计即可，那么在 Java 中的话，可以借助于 Java 8 中Collectors类提供的方法来实现，方法返回的是一个集合，如果通过分组的属性 key 值为null，就会抛出空指针异常。...
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 java.util.stream.Collectors; 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 = GsonFactory.createWithIdSerialization(); private static OkHttpClient client; private static final String TAG = "DataLoader"; static { // 静态初始化块：在类加载时执行，保证所有静态字段已初始化 try { Field[] fields = Data.class.getDeclaredFields(); for (Field field : fields) { if (SynchronizedList.class.equals(field.getType())) { SynchronizedList<?> list = (SynchronizedList<?>) field.get(null); if (list != null) { dataCollectionMap.put(list.getEntityType(), (SynchronizedList<SynchronizableEntity>) list); } } } } catch (IllegalAccessException e) { throw new RuntimeException("初始化dataCollectionMap失败", e); } } public static void loadAllData(Context context, LoadDataCallback callback) { ensurePreservedObjects(); 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"); 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); safeCallback(callback, false); } @Override public void onResponse(Call call, Response response) throws IOException { if (!response.isSuccessful()) { Log.e(TAG, "Unexpected response code: " + response.code()); 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) { Type informationType = new TypeToken<Information<AllDataResponse>>() {}.getType(); Information<AllDataResponse> information = null; try { information = gson.fromJson(jsonData, informationType); } catch (Exception e) { Log.e(TAG, "JSON解析失败: " + e.getMessage()); safeCallback(callback, false); return; } if (information == null || information.getData() == null || information.getStatus() != 200) { Log.e(TAG, "无效响应数据"); safeCallback(callback, false); 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); // 过滤掉所有列表中的空值 allData.bancais = filterNulls(allData.bancais); allData.caizhis = filterNulls(allData.caizhis); allData.mupis = filterNulls(allData.mupis); allData.chanpins = filterNulls(allData.chanpins); allData.chanpin_zujians = filterNulls(allData.chanpin_zujians); allData.dingdans = filterNulls(allData.dingdans); allData.dingdan_chanpins = filterNulls(allData.dingdan_chanpins); allData.Dingdan_chanpin_zujians = filterNulls(allData.Dingdan_chanpin_zujians); allData.kucuns = filterNulls(allData.kucuns); allData.zujians = filterNulls(allData.zujians); allData.users = filterNulls(allData.users); allData.jinhuos = filterNulls(allData.jinhuos); // 更新列表（保留预置对象） 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); SynchronizableEntity.setSyncEnabled(false); // 自动关联实体（全面空值防护） automaticAssociation(); // 设置所有实体状态 setAllEntitiesState(SynchronizableEntity.SyncState.MODIFIED); ensurePreservedObjects(); SynchronizableEntity.setSyncEnabled(true); safeCallback(callback, true); } // 安全回调方法 public static void safeCallback(LoadDataCallback callback, boolean success) { new Handler(Looper.getMainLooper()).post(() -> { if (callback != null) { 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 != null && 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)); automaticAssociation(); } // 检查列表是否包含预置对象 private static <T extends SynchronizableEntity> boolean containsPreservedObject(List<T> list) { for (T item : list) { if (item != null && item.isPreservedObject()) { return true; } } return false; } // 自动关联实体（全面空值防护） private static void automaticAssociation() { try { for (Class t : dataCollectionMap.keySet()) { setDefaultAssociation(Objects.requireNonNull(dataCollectionMap.get(t))); } } catch (IllegalAccessException | ClassNotFoundException e) { Log.e(TAG, "自动关联失败", e); } } /** * 自动关联实体（加强空值处理） */ private static <T extends SynchronizableEntity> void setDefaultAssociation(SynchronizedList<T> list) throws IllegalAccessException, ClassNotFoundException { for (T t : list) { if (t == null) continue; // 跳过空对象 Class clazz = t.getClass(); Field[] fields = clazz.getDeclaredFields(); for (Field f : fields) { f.setAccessible(true); Class fieldType = f.getType(); // 处理实体引用字段 if (SynchronizableEntity.class.isAssignableFrom(fieldType)) { SynchronizableEntity currentValue = (SynchronizableEntity) f.get(t); // 处理空值或无效ID if (t.getId() < 0 || currentValue == null || currentValue.getId() == null) { // 设置为对应类型的预置对象 SynchronizedList<SynchronizableEntity> targetList = dataCollectionMap.get(fieldType); if (targetList != null && !targetList.isEmpty()) { f.set(t, targetList.stream() .filter(item -> item.isPreservedObject()) .findFirst() .orElse(null)); } } else { // 查找匹配的实体 SynchronizedList<SynchronizableEntity> targetList = dataCollectionMap.get(fieldType); if (targetList != null) { SynchronizableEntity found = targetList.stream() .filter(item -> currentValue.getId().equals(item.getId())) .findFirst() .orElse(null); // 如果找不到，使用预置对象作为回退 f.set(t, found != null ? found : targetList.stream() .filter(SynchronizableEntity::isPreservedObject) .findFirst() .orElse(null)); } } } // 处理列表字段 else if (List.class.isAssignableFrom(fieldType)) { Type genericType = f.getGenericType(); if (genericType instanceof ParameterizedType) { ParameterizedType pt = (ParameterizedType) genericType; Type[] types = pt.getActualTypeArguments(); if (types.length > 0) { Class itemType = Class.forName(types[0].getTypeName()); if (SynchronizableEntity.class.isAssignableFrom(itemType)) { List<SynchronizableEntity> currentList = (List<SynchronizableEntity>) f.get(t); if (currentList == null) { currentList = new ArrayList<>(); f.set(t, currentList); } // 过滤掉空值 currentList.removeAll(Collections.singleton(null)); // 处理空列表或无效ID if (currentList.isEmpty() || t.getId() < 0) { SynchronizedList<SynchronizableEntity> sourceList = dataCollectionMap.get(itemType); if (sourceList != null && !sourceList.isEmpty()) { currentList.add(sourceList.stream() .filter(SynchronizableEntity::isPreservedObject) .findFirst() .orElse(null)); } } else { // 更新列表中的引用 SynchronizedList<SynchronizableEntity> sourceList = dataCollectionMap.get(itemType); if (sourceList != null) { for (int i = 0; i < currentList.size(); i++) { SynchronizableEntity item = currentList.get(i); if (item == null) continue; SynchronizableEntity found = sourceList.stream() .filter(e -> e.getId().equals(item.getId())) .findFirst() .orElse(null); // 如果找不到，使用预置对象作为回退 currentList.set(i, found != null ? found : sourceList.stream() .filter(SynchronizableEntity::isPreservedObject) .findFirst() .orElse(null)); } } } } } } } // 处理基本类型字段 else { Object value = f.get(t); if (value == null) { // 设置类型安全的默认值 if (String.class.equals(fieldType)) { f.set(t, "无"); } else if (Integer.class.equals(fieldType) || int.class.equals(fieldType)) { f.set(t, -1); } else if (Double.class.equals(fieldType) || double.class.equals(fieldType)) { f.set(t, -1.0); } else if (Boolean.class.equals(fieldType) || boolean.class.equals(fieldType)) { f.set(t, false); } else if (Date.class.equals(fieldType)) { f.set(t, new Date()); } } } } } } /** * 根据传入的Class对象创建对应类型的实例（加强空值防护） */ public static <T> T createInstance(Class<T> clazz) { try { T instance = clazz.getDeclaredConstructor().newInstance(); // 设置默认值 Field[] fields = clazz.getDeclaredFields(); for (Field field : fields) { field.setAccessible(true); Class<?> type = field.getType(); if (type == String.class) { field.set(instance, "无"); } else if (type == Integer.class || type == int.class) { field.set(instance, -1); } else if (type == Double.class || type == double.class) { field.set(instance, -1.0); } else if (type == Boolean.class || type == boolean.class) { field.set(instance, false); } else if (type == Date.class) { field.set(instance, new Date()); } else if (SynchronizableEntity.class.isAssignableFrom(type)) { // 设置为对应类型的预置对象 SynchronizedList<SynchronizableEntity> targetList = dataCollectionMap.get(type); if (targetList != null && !targetList.isEmpty()) { field.set(instance, targetList.stream() .filter(SynchronizableEntity::isPreservedObject) .findFirst() .orElse(null)); } } else if (List.class.isAssignableFrom(type)) { // 初始化为空列表 field.set(instance, new ArrayList<>()); } } // 设置特殊字段 clazz.getMethod("setId", Integer.class).invoke(instance, -1); clazz.getMethod("setState", SynchronizableEntity.SyncState.class) .invoke(instance, SynchronizableEntity.SyncState.PRESERVED); return instance; } catch (Exception e) { Log.e("Data", "创建实例失败: " + clazz.getName(), e); return createSafeFallback(clazz); } } // 安全回退创建 private static <T> T createSafeFallback(Class<T> clazz) { try { return clazz.getDeclaredConstructor().newInstance(); } catch (Exception ex) { throw new RuntimeException("创建回退实例失败", ex); } } // 辅助方法：确保列表不为null private static <T> void safeInitializeList(List<T> list) { if (list == null) { list = new ArrayList<>(); } } // 辅助方法：过滤列表中的空值 private static <T> List<T> filterNulls(List<T> list) { if (list == null) return new ArrayList<>(); return list.stream() .filter(Objects::nonNull) .collect(Collectors.toList()); } // 回调接口 public interface LoadDataCallback { void onSuccess(); void onFailure(); } // 内部类用于解析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); } private static <T extends SynchronizableEntity> void setListState(List<T> list, SynchronizableEntity.SyncState state) { for (T entity : list) { if (entity != null) { entity.setState(state); } } } }结构简化加入详细注释
06-14
3.为每个关键步骤添加注释。注意：由于原代码较长，我们不会改变其核心逻辑，但会尝试使结构更清晰。以下是简化后的代码，并加入详细注释：以下是简化后的 `Data` 类结构，加入了详细注释，重点优化了代码结构和...
java list的tostring方法与json.toJSONString方法的字符串的区别
最新发布
07-11
我们正在比较Java中List的toString()方法和FastJson的JSON.toJSONString()方法生成字符串的区别。 首先，我们需要明确两个方法的作用和输出格式。 1. List的toString()方法： - 这是Java中Object类的方法，被...
当一个空的List作为参数时候需注意
进阶的小橙子
01-07 1192
当一个方法中，有一个参数为List时，一定要注意，如果此时List为空时，不可直接add元素，否则会报错(UnsupportedOperationException)，因为emptyList不允许add元素，一定要判空之后再操作 if(CollectionUtils.isEmpty(opRecordsList)){ opRecordsList= Lists.newArrayLis...
ArrayList的add()方法使用
zhuhai__yizhi的专栏
11-25 1万+
How to avoid null insertion in ArrayList? 如何避免在ArrayList零插入？ Tags: java source 标签: java source 问题 (Question) How to avoid null insertion in ArrayList w
Java中List用add方法出错
ABCDEFGYHQ的博客
05-07 1335
Java中List用add方法出错
对象中的list赋值报空（循环赋值add方法报空指针）
m0_50932526的博客
12-20 693
对象中的list赋值报空
02.Java 集合 - ArrayList
一把空心菜
04-10 546
基本概念在分析 ArrayList 前，需要明白几个词的概念：线性表、数组。线性表是最基本、最简单、也是最常用的一种数据结构。线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的。线性表有两种存储方式： 一种是顺序存储结构 另一种是链式存储结构 数组，是一种典型的顺序存储结构。具有以下特点： 是物理存储连续、逻辑存储连续的顺序表。 利于查询。这种存
List.addAll方法的入参不能为null
poleanNa的博客
05-19 1万+
缘由： 某天，发现一段日志中出现了诡异的NPE。经过定位，认为是ArrayList不能加入null所致。 验证： new一个ArrayList，然后调用其addAll方法，并将入参设为null。 public static void main(String[] args) { List<String> list = new Arra...
Java List.add()方法
热门推荐
Jeremy__Liu的博客
03-01 1万+
Java List.add()方法 Java 集合类中的 List.add() 方法用于向集合列表中添加对象。 语法1 add(A) 用于在列表的尾部插入指定元素。如果 List 集合对象由于调用 add 方法而发生更改，则返回 true；否则返回 false。 参数说明： A：要添加到列表中的元素。 语法2 void add(int index,E element) 用于在列表的指定位置插入指定元素，并将当前处于该位置的元素及其后续元素的索引加 1。 参数说明： index：用于指定在其中插入指定
有关List集合中的add方法（循环遍历中的list.add()方法踩坑）
qq_42305089的博客
01-05 5850
分别在fro循环内外new一个对象，然后在循环中将对象加入集合中，两种方法产生的结果不同。 在for循环内new一个对象，并添加进list中，与添加数值的结果没有差别。 在for循环外new一个对象，并添加进list中，无论循环多少次，最终整个list中的结果都会是最后一次赋值为对象的结果。 原因：在创建List时，指定了引用对象House作用泛型，list.add（）在添加对象时，添加的是它的引用，而在循环体外new一个对象，在循环体内赋值，则对象House引用不变，数值改变，因引用不变，最...
Java List根据属性赋值
weixin_35750483的博客
12-21 1457
Java 中的 List 是一种接口，它继承于 Collection 接口。List 接口中的元素是有序的，可以重复的。Java 中有许多 List 的实现类，如 ArrayList、LinkedList 等。 在 Java 中，要给 List 中的元素赋值，可以使用 List 的 add 方法来添加元素，也可以使用 set 方法来修改 List 中指定位置的元素的值。 例如： List<S...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值