关于Set<Short>删除整数的问题

本文通过一个Java示例展示了Set数据结构的工作原理,特别是HashSet的行为。代码演示了如何添加和尝试移除元素,最终解释了为何预期移除操作未生效的原因。
  1. import java.util.*;   
  2.   
  3. public class Test {   
  4.   public static void main(String args[]) {   
  5.     Set<Short> s = new HashSet<Short>();   
  6.     for (Short i = 0; i < 100; i++) {   
  7.       s.add(i);   
  8.       if(i>0){
  9.        s.remove(i - 1);   
  10.       }
  11.     }   
  12.     System.out.println(s.size());   
  13.   }   
  14. }  


运行结果为100

分析:
1 Set的remove调用的是删除一个对象remove(Object)
2 Short 和 Integer 进行比较时,是肯定不等的,虽然他们的数值相等。
因为在equals时,先判断对象类型instanceof,他们类型不同,自然不等。


boolean remove(Object o)
如果 set 中存在指定的元素,则将其移除(可选操作)。更确切地讲,如果此 set 中包含满足 (o==null ? e==null : o.equals(e)) 的元素 e,则移除它。如果此 set 包含指定的元素(或者此 set 由于调用而发生更改),则返回 true(一旦调用返回,则此 set 不再包含指定的元素)。

指定者:
接口 Collection <E> 中的 remove
参数:
o - 从 set 中移除的对象(如果存在)
返回:
如果此 set 包含指定的对象,则返回 true
抛出:
ClassCastException - 如果指定元素的类型与此 set 不兼容(可选)
NullPointerException - 如果指定的元素为 null,并且此 set 不允许 null 元素(可选)
UnsupportedOperationException - 如果此 set 不支持 remove 操作


remove的参数是Object,而lz的程序里写的是int值,所以没有删除掉。
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
06-12
#include <iostream> // 标准输入输出流 #include <fstream> // 文件操作 #include <vector> // 用于存储IQ样本 #include <cmath> // 数学函数:cos, sin, PI 等 #include <random> // 用于生成高斯噪声 // 定义 π 常量,用于三角函数计算 const double PI = 3.14159265358979323846; // LINK 4A 参数 const int SAMPLE_RATE = 48000; // 采样率(Hz) const double BIT_RATE = 5000.0; // 数据速率 5 kbps const double BIT_DURATION = 1.0 / BIT_RATE; // 每个比特持续时间(秒) const double CARRIER_FREQ = 300e6; // 载波频率(300 MHz) // 模拟发送的二进制数据(例如指令) const std::vector<bool> BINARY_DATA = { 1, 0, 1, 1, 0, 0, 1, 1, 0, 1 }; // 定义 IQ 样本结构体,用于存储 I 和 Q 分量 struct IQSample { double I; // 同相分量 double Q; // 正交分量 }; // 函数:生成 BPSK 调制的 IQ 数据 std::vector<IQSample> generateBPSKSignal(const std::vector<bool>& data) { std::vector<IQSample> iqSignal; // 存储生成的 IQ 数据 // 每个比特对应的采样点数 = 采样率 × 比特持续时间 int samplesPerBit = static_cast<int>(SAMPLE_RATE * BIT_DURATION); // 遍历每个比特 for (bool bit : data) { // 根据比特值确定相位:1 → 0°, 0 → 180° double phase = bit ? 0.0 : PI; // 对每个比特生成 samplesPerBit 个采样点 for (int i = 0; i < samplesPerBit; ++i) { // 当前时间 t = 样本总数 / 采样率 double t = static_cast<double>(iqSignal.size()) / SAMPLE_RATE; // BPSK 调制:s(t) = cos(2πf_c t + φ) double I = cos(2 * PI * CARRIER_FREQ * t + phase); double Q = sin(2 * PI * CARRIER_FREQ * t + phase); // 将当前时刻的 I 和 Q 存入 IQ 样本 iqSignal.push_back({ I, Q }); } } return iqSignal; } // 函数:添加高斯白噪声(AWGN) std::vector<IQSample> addAWGNNoise(const std::vector<IQSample>& iqSignal, double noise_std = 0.1) { std::vector<IQSample> noisyIQ; std::default_random_engine generator; // 随机数引擎 std::normal_distribution<double> distribution(0.0, noise_std); // 均值为0,标准差为noise_std for (const auto& sample : iqSignal) { double noise_I = distribution(generator); // I 分量噪声 double noise_Q = distribution(generator); // Q 分量噪声 noisyIQ.push_back({ sample.I + noise_I, // 添加噪声后的 I sample.Q + noise_Q // 添加噪声后的 Q }); } return noisyIQ; } // 函数:将 IQ 数据归一化到 [0, 65535] 范围 std::vector<std::pair<unsigned short, unsigned short>> normalizeIQ( const std::vector<IQSample>& iqSignal) { std::vector<std::pair<unsigned short, unsigned short>> normalizedIQ; for (const auto& sample : iqSignal) { // 归一化公式:(value + 1.0) / 2.0 * 65535 unsigned short I_norm = static_cast<unsigned short>( (sample.I + 1.0) / 2.0 * 65535 ); unsigned short Q_norm = static_cast<unsigned short>( (sample.Q + 1.0) / 2.0 * 65535 ); normalizedIQ.emplace_back(I_norm, Q_norm); } return normalizedIQ; } // 函数:将归一化后的 IQ 数据保存为 CSV 文件(逗号分隔值,方便 Excel 打开) void saveNormalizedIQToFile( const std::vector<std::pair<unsigned short, unsigned short>>& iqSignal, const std::string& filename) { // 打开文件输出流 std::ofstream file(filename); // 检查是否打开成功 if (!file) { std::cerr << "无法打开文件:" << filename << std::endl; return; } // 写入 CSV 文件的表头(可选) file << "I,Q" << std::endl; // 遍历归一化后的 IQ 数据并写入文件,使用逗号分隔 for (const auto& sample : iqSignal) { file << sample.first << "," << sample.second << std::endl; } // 关闭文件 file.close(); // 输出提示信息 std::cout << "归一化后的 LINK 4A IQ CSV 数据已保存至文件:" << filename << std::endl; } // 主函数 int main() { // 生成原始 BPSK IQ 数据 std::vector<IQSample> iqSignal = generateBPSKSignal(BINARY_DATA); // 添加高斯白噪声 std::vector<IQSample> noisyIQ = addAWGNNoise(iqSignal, 0.1); // 噪声标准差设为 0.1 // 归一化 IQ 数据到 [0, 65535] auto normalizedIQ = normalizeIQ(noisyIQ); // 保存归一化后的 IQ 数据到文件 saveNormalizedIQToFile(normalizedIQ, "noisy_normalized_link4a_iq_data.csv"); // 程序正常退出 return 0; } #if 0 #include <iostream> #include <unordered_map> #include <vector> #include <string> #include <algorithm> #include <random> // 定义一个结构体 targetInfo,用于存储目标的相关信息 // 包含目标名称、目标距离和目标新距离 struct targetInfo { std::string targetName; // 目标的名称 int targetDistance; // 目标的距离 int targetNewDistance; // 目标的新距离 }; // 使用 typedef 为 targetInfo 结构体定义一个别名 targetInfoStruct using targetInfoStruct = struct targetInfo; // 生成指定范围 [min, max] 的随机整数 int generateRandomNumber(int min, int max) { std::random_device rd; std::mt19937 gen(rd()); std::uniform_int_distribution<> dis(min, max); return dis(gen); } int main() { // 定义一个 unordered_map,键为 std::string 类型,表示平台名称 // 值为 std::vector<targetInfoStruct> 类型,表示该平台对应的目标信息列表 std::unordered_map<std::string, std::vector<targetInfoStruct>> platTargetMap; // 插入一些示例数据 // 创建一个 targetInfoStruct 类型的对象 info1,并初始化其成员变量 targetInfoStruct info1; info1.targetName = "target1"; info1.targetDistance = 0; info1.targetNewDistance = -1; // 创建一个 targetInfoStruct 类型的对象 info2,并初始化其成员变量 targetInfoStruct info2; info2.targetName = "target2"; info2.targetDistance = 0; info2.targetNewDistance = -1; // 创建一个 targetInfoStruct 类型的对象 info3,并初始化其成员变量 targetInfoStruct info3; info3.targetName = "target3"; info3.targetDistance = 0; info3.targetNewDistance = -1; // 创建一个 targetInfoStruct 类型的对象 info4,并初始化其成员变量 targetInfoStruct info4; info4.targetName = "target4"; info4.targetDistance = 0; info4.targetNewDistance = -1; // 创建一个 targetInfoStruct 类型的对象 info5,并初始化其成员变量 targetInfoStruct info5; info5.targetName = "target5"; info5.targetDistance = 0; info5.targetNewDistance = -1; // 将 info1 添加到不同平台对应的目标信息列表中 platTargetMap["platform1"].push_back(info1); platTargetMap["platform2"].push_back(info1); platTargetMap["platform3"].push_back(info1); platTargetMap["platform4"].push_back(info1); // 将 info2 添加到不同平台对应的目标信息列表中 platTargetMap["platform1"].push_back(info2); platTargetMap["platform2"].push_back(info2); platTargetMap["platform3"].push_back(info2); platTargetMap["platform4"].push_back(info2); // 将 info3 添加到部分平台对应的目标信息列表中 platTargetMap["platform2"].push_back(info3); platTargetMap["platform3"].push_back(info3); platTargetMap["platform4"].push_back(info3); platTargetMap["platform3"].push_back(info4); platTargetMap["platform4"].push_back(info4); // 将 info5 添加到特定平台对应的目标信息列表中 platTargetMap["platform5"].push_back(info5); // 遍历 platTargetMap,更新每个目标的距离信息 for (std::unordered_map<std::string, std::vector<targetInfoStruct>>::iterator it = platTargetMap.begin(); it != platTargetMap.end(); ++it) { // 获取当前平台的名称 std::string key = it->first; // 获取当前平台对应的目标信息列表的引用 std::vector<targetInfoStruct>& tmpVec = it->second; // 遍历当前平台对应的目标信息列表 for (int i = 0; i < tmpVec.size(); ++i) { // 构造一个临时字符串,由平台名称和目标名称组成 std::string tmpString = key + tmpVec[i].targetName; // 根据临时字符串的长度更新目标的距离信息 tmpVec[i].targetDistance = tmpString.length() + generateRandomNumber(1, 100); } } // 再次遍历 platTargetMap,输出每个平台及其对应的目标信息 for (std::unordered_map<std::string, std::vector<targetInfoStruct>>::iterator it = platTargetMap.begin(); it != platTargetMap.end(); ++it) { // 获取当前平台的名称 std::string key = it->first; // 输出当前平台的名称 std::cout << key << std::endl; // 获取当前平台对应的目标信息列表的副本 std::vector<targetInfoStruct> tmpVec = it->second; // 遍历当前平台对应的目标信息列表 for (int i = 0; i < tmpVec.size(); ++i) { // 输出目标的名称、距离和新距离信息 std::cout << " targetName " << tmpVec[i].targetName << " targetDistance " << tmpVec[i].targetDistance << " targetNewDistance " << tmpVec[i].targetNewDistance << std::endl; } } // 定义一个无序映射 minDistanceMap,用于存储每个目标名称对应的最小距离 // 键为目标名称,值为该目标的最小距离 std::unordered_map<std::string, int> minDistanceMap; // 遍历 platTargetMap,它是一个无序映射,键为平台名称,值为目标信息结构体的向量 for (const std::pair<const std::string, std::vector<targetInfoStruct>>& pair : platTargetMap) { // 从当前的键值对中取出值,即目标信息结构体的向量,并将其引用赋值给 tmpVec const std::vector<targetInfoStruct>& tmpVec = pair.second; // 遍历当前平台对应的目标信息结构体向量 for (const targetInfoStruct& info : tmpVec) { // 检查 minDistanceMap 中是否已经存在当前目标名称的键 if (minDistanceMap.find(info.targetName) == minDistanceMap.end()) { // 如果不存在,则将当前目标的距离作为该目标的最小距离存入 minDistanceMap minDistanceMap[info.targetName] = info.targetDistance; } else { // 如果已经存在,则比较当前目标的距离和 minDistanceMap 中存储的该目标的最小距离 // 取较小值作为新的最小距离更新到 minDistanceMap 中 minDistanceMap[info.targetName] = std::min(minDistanceMap[info.targetName], info.targetDistance); } } } // 再次遍历 platTargetMap,这次是为了更新每个目标的新距离信息 for (std::pair<const std::string, std::vector<targetInfoStruct>>& pair : platTargetMap) { // 从当前的键值对中取出值,即目标信息结构体的向量,并将其引用赋值给 tmpVec std::vector<targetInfoStruct>& tmpVec = pair.second; // 遍历当前平台对应的目标信息结构体向量 for (targetInfoStruct& info : tmpVec) { // 检查当前目标的距离是否等于该目标在 minDistanceMap 中存储的最小距离 if (info.targetDistance == minDistanceMap[info.targetName]) { // 如果相等,则将该目标的新距离设为 0 info.targetNewDistance = 0; } else { // 如果不相等,则将该目标的新距离设为当前距离减去最小距离 info.targetNewDistance = info.targetDistance - minDistanceMap[info.targetName]; } } } // 再次遍历 platTargetMap,输出每个平台及其对应的目标信息 for (std::unordered_map<std::string, std::vector<targetInfoStruct>>::iterator it = platTargetMap.begin(); it != platTargetMap.end(); ++it) { // 获取当前平台的名称 std::string key = it->first; // 输出当前平台的名称 std::cout << key << std::endl; // 获取当前平台对应的目标信息列表的副本 std::vector<targetInfoStruct> tmpVec = it->second; // 遍历当前平台对应的目标信息列表 for (int i = 0; i < tmpVec.size(); ++i) { // 输出目标的名称、距离和新距离信息 std::cout << " targetName " << tmpVec[i].targetName << " targetDistance " << tmpVec[i].targetDistance << " targetNewDistance " << tmpVec[i].targetNewDistance << std::endl; } } return 0; } #endif #if 0 #include <iostream> #include <unordered_map> #include <vector> #include <string> // 定义一个结构体 targetInfo,用于存储目标的相关信息 // 包含目标名称、目标距离和目标新距离 struct targetInfo { std::string targetName; // 目标的名称 int targetDistance; // 目标的距离 int targetNewDistance; // 目标的新距离 }; // 使用 typedef 为 targetInfo 结构体定义一个别名 targetInfoStruct using targetInfoStruct = struct targetInfo; int main() { // 定义一个 unordered_map,键为 std::string 类型,表示平台名称 // 值为 std::vector<targetInfoStruct> 类型,表示该平台对应的目标信息列表 std::unordered_map<std::string, std::vector<targetInfoStruct>> platTargetMap; // 插入一些示例数据 // 创建一个 targetInfoStruct 类型的对象 info1,并初始化其成员变量 targetInfoStruct info1; info1.targetName = "target1"; info1.targetDistance = 0; info1.targetNewDistance = -1; // 创建一个 targetInfoStruct 类型的对象 info2,并初始化其成员变量 targetInfoStruct info2; info2.targetName = "target2"; info2.targetDistance = 0; info2.targetNewDistance = -1; // 创建一个 targetInfoStruct 类型的对象 info3,并初始化其成员变量 targetInfoStruct info3; info3.targetName = "target3"; info3.targetDistance = 0; info3.targetNewDistance = -1; // 创建一个 targetInfoStruct 类型的对象 info4,并初始化其成员变量 targetInfoStruct info4; info4.targetName = "target4"; info4.targetDistance = 0; info4.targetNewDistance = -1; // 将 info1 添加到不同平台对应的目标信息列表中 platTargetMap["platform1"].push_back(info1); platTargetMap["platform2"].push_back(info1); platTargetMap["platform3"].push_back(info1); platTargetMap["platform4"].push_back(info1); // 将 info2 添加到不同平台对应的目标信息列表中 platTargetMap["platform1"].push_back(info2); platTargetMap["platform2"].push_back(info2); platTargetMap["platform3"].push_back(info2); platTargetMap["platform4"].push_back(info2); // 将 info3 添加到部分平台对应的目标信息列表中 platTargetMap["platform2"].push_back(info3); platTargetMap["platform3"].push_back(info3); platTargetMap["platform4"].push_back(info3); // 将 info4 添加到特定平台对应的目标信息列表中 platTargetMap["platform4"].push_back(info4); // 遍历 platTargetMap,更新每个目标的距离信息 for (std::unordered_map<std::string, std::vector<targetInfoStruct>>::iterator it = platTargetMap.begin(); it != platTargetMap.end(); ++it) { // 获取当前平台的名称 std::string key = it->first; // 获取当前平台对应的目标信息列表的引用 std::vector<targetInfoStruct>& tmpVec = it->second; // 遍历当前平台对应的目标信息列表 for (int i = 0; i < tmpVec.size(); ++i) { // 构造一个临时字符串,由平台名称和目标名称组成 std::string tmpString = key + tmpVec[i].targetName; // 根据临时字符串的长度更新目标的距离信息 tmpVec[i].targetDistance = tmpString.length(); } } // 再次遍历 platTargetMap,输出每个平台及其对应的目标信息 for (std::unordered_map<std::string, std::vector<targetInfoStruct>>::iterator it = platTargetMap.begin(); it != platTargetMap.end(); ++it) { // 获取当前平台的名称 std::string key = it->first; // 输出当前平台的名称 std::cout << key << std::endl; // 获取当前平台对应的目标信息列表的副本 std::vector<targetInfoStruct> tmpVec = it->second; // 遍历当前平台对应的目标信息列表 for (int i = 0; i < tmpVec.size(); ++i) { // 构造一个临时字符串,由平台名称和目标名称组成 std::string tmpString = key + tmpVec[i].targetName; // 根据临时字符串的长度更新目标的距离信息 tmpVec[i].targetDistance = tmpString.length(); // 输出目标的名称、距离和新距离信息 std::cout << " targetName " << tmpVec[i].targetName << " targetDistance " << tmpVec[i].targetDistance << " targetNewDistance" << tmpVec[i].targetNewDistance << std::endl; } } return 0; } #endif #if 0 #include <iostream> #include <unordered_map> #include <vector> #include <string> struct targetInfo { std::string targetName; int targetDistance; int targetNewDistance; }; using targetInfoStruct = struct targetInfo; int main() { std::unordered_map<std::string, std::vector<targetInfoStruct>> platTargetMap; // 插入一些示例数据 targetInfoStruct info1; info1.targetName = "target1"; info1.targetDistance = 0; info1.targetNewDistance = -1; targetInfoStruct info2; info2.targetName = "target2"; info2.targetDistance = 0; info2.targetNewDistance = -1; targetInfoStruct info3; info3.targetName = "target3"; info3.targetDistance = 0; info3.targetNewDistance = -1; targetInfoStruct info4; info4.targetName = "target4"; info4.targetDistance = 0; info4.targetNewDistance = -1; platTargetMap["platform1"].push_back(info1); platTargetMap["platform2"].push_back(info1); platTargetMap["platform3"].push_back(info1); platTargetMap["platform4"].push_back(info1); platTargetMap["platform1"].push_back(info2); platTargetMap["platform2"].push_back(info2); platTargetMap["platform3"].push_back(info2); platTargetMap["platform4"].push_back(info2); platTargetMap["platform2"].push_back(info3); platTargetMap["platform3"].push_back(info3); platTargetMap["platform4"].push_back(info3); platTargetMap["platform4"].push_back(info4); for (std::unordered_map<std::string, std::vector<targetInfoStruct>>::iterator it = platTargetMap.begin(); it != platTargetMap.end(); ++it) { std::string key = it->first; std::vector<targetInfoStruct>& tmpVec = it->second; for (int i = 0; i < tmpVec.size(); ++i) { std::string tmpString = key + tmpVec[i].targetName; tmpVec[i].targetDistance = tmpString.length(); } } for (std::unordered_map<std::string, std::vector<targetInfoStruct>>::iterator it = platTargetMap.begin(); it != platTargetMap.end(); ++it) { std::string key = it->first; std::cout << key << std::endl; std::vector<targetInfoStruct> tmpVec = it->second; for (int i = 0; i < tmpVec.size(); ++i) { std::string tmpString = key + tmpVec[i].targetName; tmpVec[i].targetDistance = tmpString.length(); std::cout << " targetName " << tmpVec[i].targetName << " targetDistance " << tmpVec[i].targetDistance << " targetNewDistance" << tmpVec[i].targetNewDistance << std::endl; } } return 0; } #endif #if 0 #include <iostream> #include <map> #include <set> #include <vector> #include <string> struct targetInfo { std::string targetName; double targetDistance; double targetNewDistance; }; using targetInfoStruct = struct targetInfo; int main() { std::map<std::string, std::vector<targetInfoStruct>> platTargetMap; return 0; } #endif #if 0 #include <iostream> #include <map> #include <set> #include <vector> #include <string> // 计算字符串长度的函数 double calc(const std::string& str) { return static_cast<double>(str.length()); } // 改造后的处理 resultMap 的函数 void processResultMap(std::map<std::string, std::vector<double>>& resultMap) { // 检查 resultMap 是否为空 if (resultMap.empty()) { // 如果为空,直接返回,不进行后续处理 return; } // 获取 vector 的长度 std::map<std::string, std::vector<double>>::iterator firstIt = resultMap.begin(); // 取第一个键值对的值(即第一个 std::vector<double>),获取其长度 std::vector<double>::size_type vecSize = firstIt->second.size(); // 对 vector 中每个位置的元素进行处理 for (std::vector<double>::size_type i = 0; i < vecSize; ++i) { // 找到该位置的最小值 double minVal = resultMap.begin()->second[i]; // 遍历 resultMap 中的每个键值对 for (std::map<std::string, std::vector<double>>::iterator it = resultMap.begin(); it != resultMap.end(); ++it) { // 如果当前键值对对应 vector 中第 i 个元素小于 minVal if (it->second[i] < minVal) { // 更新 minVal 为更小的值 minVal = it->second[i]; } } // 其余值减去最小值,最小值置为 0 for (std::map<std::string, std::vector<double>>::iterator it = resultMap.begin(); it != resultMap.end(); ++it) { // 将当前键值对对应 vector 中第 i 个元素减去 minVal it->second[i] -= minVal; } } } int main() { // 定义 platTargetMap 并添加元素,且 set 中字符串长度不同 std::map<std::string, std::vector<std::string>> platTargetMap; platTargetMap["plat1"] = { "target1", "target23", "1" }; // 12 13 6 platTargetMap["plat2"] = { "t1", "longerTargetHere", "22" }; // 7 21 7 platTargetMap["plat3"] = { "short", "aBitLongerTarget", "333" }; //10 21 8 // 存储结果的 resultMap std::map<std::string, std::vector<double>> resultMap; // 遍历 platTargetMap for (std::map<std::string, std::vector<std::string>>::iterator outerIt = platTargetMap.begin(); outerIt != platTargetMap.end(); ++outerIt) { std::string key = outerIt->first; std::vector<std::string> values = outerIt->second; std::vector<double> lengths; // 遍历 set 中的元素 for (std::vector<std::string>::iterator innerIt = values.begin(); innerIt != values.end(); ++innerIt) { std::string combined = key + *innerIt; double length = calc(combined); lengths.push_back(length); } // 将结果存入 resultMap resultMap[key] = lengths; } // 输出处理前的 resultMap for (std::map<std::string, std::vector<double>>::iterator it = resultMap.begin(); it != resultMap.end(); ++it) { std::cout << "Key: " << it->first << std::endl; for (std::vector<double>::iterator vecIt = it->second.begin(); vecIt != it->second.end(); ++vecIt) { std::cout << " Value: " << *vecIt << std::endl; } } // 处理 resultMap processResultMap(resultMap); // 输出处理后的 resultMap for (std::map<std::string, std::vector<double>>::iterator it = resultMap.begin(); it != resultMap.end(); ++it) { std::cout << "Key: " << it->first << std::endl; for (std::vector<double>::iterator vecIt = it->second.begin(); vecIt != it->second.end(); ++vecIt) { std::cout << " Value: " << *vecIt << std::endl; } } return 0; } #endif #if 0 #include <iostream> #include <map> #include <set> #include <vector> #include <string> /* std::map<std::string, std::set<std::string>> platTargetMap; platTargetMap["plat1"] = { "target1", "target2" }; platTargetMap["plat2"] = { "target1", "target2" }; 我需要将platTargetMap中元素1中的set中的每一个元素分别依次和key相加,例如"plat1"+"target1",此处由函数名为calc的方法实现,返回值为相加后字符串的长度,类型为int,其余元素做同样的操作,并将对应结果存储到std::map<std::string, std::vector<double>> resultMap; 请使用迭代器实现,不要使用auto,并加上注释,请给platTargetMap多加几个元素,并且set中的字符串长度不要一样 */ /* * std::map<std::string, std::set<std::string>> platTargetMap; platTargetMap["plat1"] = { "target1", "target2" }; platTargetMap["plat2"] = { "target1", "target2" }; 我需要将platTargetMap中元素1中的set中的每一个元素分别依次和key相加,例如"plat1"+"target1",此处由函数名为calc的方法实现,返回值为相加后字符串的长度,类型为int,其余元素做同样的操作,并将对应结果存储到std::map<std::string, std::vector<double>> resultMap; 请使用迭代器实现,不要使用auto,并加上注释,请给platTargetMap多加几个元素,并且set中的字符串长度不要一样。 在完成上面的步骤,我需要对resultMap进行处理,将resultMap中的第一个,第二个,第三个元素中的vector中的第一个元素进行比较,并找到vector中的最小值,其余的值减去最小值,最小值置为0,并存储在原来位置,resultMap中的第一个,第二个,第三个元素中的vector中的其他元素进行相同操作,请使用迭代器实现,不要使用auto,并加上注释 */ // 定义 calc 方法,计算字符串的长度 int calc(const std::string& str) { return static_cast<int>(str.length()); } int main() { // 定义 platTargetMap 并添加多个元素,set 中字符串长度不同 std::map<std::string, std::set<std::string>> platTargetMap; platTargetMap["plat1"] = { "target1", "target2", "longertarget" }; platTargetMap["plat2"] = { "t1", "longerTargetHere" }; platTargetMap["plat3"] = { "short", "aBitLongerTarget" }; // 定义 resultMap,用于存储计算结果 std::map<std::string, std::vector<double>> resultMap; // 定义 platTargetMap 的迭代器,用于遍历 platTargetMap std::map<std::string, std::set<std::string>>::iterator platIt; for (platIt = platTargetMap.begin(); platIt != platTargetMap.end(); ++platIt) { // 获取当前的 key const std::string& key = platIt->first; // 获取当前 key 对应的 set const std::set<std::string>& values = platIt->second; // 定义一个向量,用于存储当前 key 与 set 中元素相加后的长度 std::vector<double> lengths; // 定义 set 的迭代器,用于遍历当前 key 对应的 set std::set<std::string>::iterator valueIt; for (valueIt = values.begin(); valueIt != values.end(); ++valueIt) { // 将 key 和 set 中的元素相加 std::string combined = key + *valueIt; // 调用 calc 方法计算相加后字符串的长度 int length = calc(combined); // 将长度添加到 lengths 向量中 lengths.push_back(static_cast<double>(length)); } // 将 lengths 向量存储到 resultMap 中,键为当前的 key resultMap[key] = lengths; } // 输出 resultMap std::map<std::string, std::vector<double>>::iterator resultIt; for (resultIt = resultMap.begin(); resultIt != resultMap.end(); ++resultIt) { const std::string& key = resultIt->first; const std::vector<double>& lengths = resultIt->second; std::cout << "Key: " << key << std::endl; std::vector<double>::const_iterator lengthIt; for (lengthIt = lengths.begin(); lengthIt != lengths.end(); ++lengthIt) { std::cout << " Length: " << *lengthIt << std::endl; } } return 0; } #endif 假设我现在需要1s的采样数据,请帮我改写这段代码,在指令不变的前提下
最新发布
09-06
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值