file-type

Java包装类深入解析:代码案例与自动装箱拆箱技巧

ZIP文件

下载需积分: 1 | 2KB | 更新于2025-02-09 | 55 浏览量 | 1 下载量 举报 收藏
download 立即下载
Java是一种广泛使用的面向对象编程语言,它支持一系列的核心概念,其中包括数据类型系统。Java的类型系统既包括基本数据类型,也包括引用数据类型。基本数据类型直接映射到机器级别的数据结构,而引用数据类型则通过类和接口来构建。为了在面向对象的环境中更好地使用基本数据类型,Java提供了包装类的概念。 包装类是一组特殊的类,它们为每种基本数据类型提供了一个对应的引用类型。这些包装类通常被用于需要对象形式的场景,比如作为方法的参数、存储在集合中等。 ### 设计目的(作用)和用途 Java的包装类通常位于java.lang包中,每种基本数据类型都有一个对应的包装类: - byte: Byte - short: Short - int: Integer - long: Long - float: Float - double: Double - char: Character - boolean: Boolean 包装类的主要作用包括: - 将基本类型封装为对象,便于使用Java的对象操作; - 提供了一系列的工具方法,用于基本类型和字符串之间的转换; - 使得基本类型的数据能够存储在集合中,如List、Set和Map; - 允许在需要对象的情况下使用基本数据类型,如泛型编程; - 支持自动装箱和拆箱操作。 ### 自动装箱与拆箱 自动装箱与拆箱是Java中的一个特性,它允许基本数据类型和它们对应的包装类之间自动转换。 - 自动装箱:将基本类型自动转换为对应的包装类。例如,将int类型的值直接赋给Integer对象。 - 自动拆箱:将包装类自动转换为对应的基本数据类型。例如,将Integer对象赋给int类型变量。 自动装箱与拆箱在代码中大大简化了对包装类的使用,但也可能导致一些性能问题,因为每次转换都可能涉及到对象的创建。 ### 常用方法 包装类都有一些常用的静态方法,使得开发者能够方便地进行类型转换、数值运算等操作。例如: - `Integer.parseInt(String s)`:将字符串转换为整型; - `Double.parseDouble(String s)`:将字符串转换为双精度浮点数; - `Boolean.parseBoolean(String s)`:将字符串转换为布尔值; - `Integer.valueOf(String s)`:返回一个表示指定的int值的Integer实例。 除此之外,包装类也提供了一些用于处理数值的方法,比如计算数值的最大值、最小值,以及数值的类型转换等。 ### null和默认值 包装类的一个特性是它们可以持有`null`值,表示没有有效的值。这在Java中非常重要,尤其是在泛型集合中,因为泛型不允许使用基本数据类型。当你从一个集合中获取一个基本类型的数据时,实际上得到的是对应的包装类对象。 例如,当你从一个List<Integer>中获取元素,如果没有元素可获取,你将得到一个`null`,而不是抛出异常。这提供了更好的灵活性和错误处理能力。但是,获取到的`null`值需要谨慎处理,因为如果尝试将其自动拆箱为基本类型,将会抛出`NullPointerException`。 ### 总结 Java的包装类是整个语言中非常重要的组成部分,尤其是在进行面向对象编程时。它们不仅提供了基本数据类型与对象类型之间的桥梁,还增强了程序的健壮性和可读性。通过自动装箱和拆箱特性,包装类使得基本数据类型在某些场景下可以被当作对象来处理,极大地提高了开发效率。同时,包装类的工具方法和对`null`值的支持,也使得开发者能够编写更加安全和灵活的代码。 为了深入理解和掌握Java中的包装类,建议通过实际编写和运行示例代码,观察不同场景下的行为和效果,从而在实际的开发工作中能够更加得心应手地使用这些工具类。

相关推荐

filetype

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.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<>(Bancai.class); public static SynchronizedList<Jinhuo> jinhuoList = new SynchronizedList<>(Bancai.class); public static SynchronizedList<Jinhuo> jinhuos = new SynchronizedList<>(Bancai.class); private static final Gson gson = new Gson(); private static OkHttpClient client ; private static final String TAG = "DataLoader"; 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(jinhuoList, 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)); // 为其他需要预置对象的列表添加... } // 检查列表是否包含预置对象 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(); } /** * 根据传入的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.getType().equals(Double.class)){ f.set(g,-1); } if (f.getType().equals(Date.class)){ f.set(g,new Date()); } Log.d("g",""+f.get(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(jinhuoList, 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: OkHttp Dispatcher Process: com.example.kucun2, PID: 10514 java.lang.RuntimeException: 鍒涘缓瀹炰緥澶辫触: com.example.kucun2.entity.Bancai at com.example.kucun2.entity.data.Data.createInstance(Data.java:260) at com.example.kucun2.entity.data.Data.ensurePreservedObjects(Data.java:191) at com.example.kucun2.entity.data.Data.-$$Nest$smensurePreservedObjects(Unknown Source:0) at com.example.kucun2.entity.data.Data$1.onResponse(Data.java:81) at okhttp3.internal.connection.RealCall$AsyncCall.run(RealCall.kt:519) at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145) at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:644) at java.lang.Thread.run(Thread.java:1042) Caused by: java.lang.IllegalArgumentException: field com.example.kucun2.entity.Bancai.houdu has type java.lang.Double, got java.lang.Integer at java.lang.reflect.Field.set(Native Method) at com.example.kucun2.entity.data.Data.createInstance(Data.java:242) ... 7 more

小山code
  • 粉丝: 1w+
上传资源 快速赚钱