【练习】将一组数据分类为：一对一、一对多、多对一、多对多四类

最新推荐文章于 2022-03-08 12:05:44 发布
最新推荐文章于 2022-03-08 12:05:44 发布
阅读量2k 收藏
点赞数
分类专栏： Java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/c4jem/article/details/73647851
版权

要求

假设有一批数据，数据中存在重复的数据，数据间主要存在以下四种关系：

  • 一对一：（唯一的 key 和唯一的 value 对应）
    keyA – valueA
  • 一对多：（唯一的 key 和 多个 value 对应，同时这些 value 只与该 key 对应）
    keyA – valueA
    keyA – valueB
  • 多对一：（多个 key 与唯一的 value 对应）
    keyA – valueA
    keyB – valueA
  • 多对多：（多个 key，每个 key 与 相同的多个 value 对应，同时，每个 value 与相同的多个 key 对应）
    keyA – valueA
    keyA – valueB
    keyB – valueA
    keyB – valueB

其它情况不予考虑

代码

逻辑代码：

import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.Multimap;
public class Classfy {
    private static final Logger LOGGER = LoggerFactory.getLogger(Classfy.class);
    public static void classfyAssociate(List<Map<String, String>> list) {
        Multimap<String, String> keyMap = HashMultimap.create();
        Multimap<String, String> valueMap = HashMultimap.create();
        String key = null;
        String value = null;
        // 第一步：对数据去重分类
        for (Map<String, String> map : list) {
            for (Entry<String, String> entry : map.entrySet()) {
                key = entry.getKey();
                value = entry.getValue();
                keyMap.put(key, value);
                valueMap.put(value, key);
            }
        }
        // 第二步：取出一对一的数据
        Map<String, String> oneToOneMap = collectOneToOne(keyMap, valueMap);
        // 第三步：剩下的数据中取出多对多的数据
        Map<Set<String>, Set<String>> manyToManyMap = collectManyToMany(keyMap, valueMap);
        // 第三步：剩下的数据中取出一对多的数据
        Map<String, Set<String>> oneToManyMap = collectOneToMany(keyMap, valueMap);
        // 第四步：剩下的数据中取出多对一的数据
        Map<Set<String>, String> manyToOneMap = collectManyToOne(keyMap, valueMap);
        printOneToOneMap(oneToOneMap);
        printManyToMany(manyToManyMap);
        printOneToMany(oneToManyMap);
        printManyToOne(manyToOneMap);
        // 剩下的就是不符合上面四种数据关系的数据
        LOGGER.info("print keyMap ...");
        printMultimap(keyMap);
        LOGGER.info("print valueMap ...");
        printMultimap(valueMap);
    }
    private static Map<String, String> collectOneToOne(Multimap<String, String> keyMap,
            Multimap<String, String> valueMap) {
        Map<String, String> oneToOneMap = new HashMap<>();
        Set<String> keySet = new HashSet<>(keyMap.keySet());
        for (String key : keySet) {
            Set<String> values = (Set<String>) keyMap.get(key);
            if (values.size() == 1) {
                // key 对应唯一的 value
                for (String value : values) {
                    Collection<String> keys = valueMap.get(value);
                    if (keys.size() == 1) {
                        // 同时 value 对应唯一的 key ,则符合一对一的关系
                        oneToOneMap.put(key, value);
                        keyMap.remove(key, value);
                        valueMap.remove(value, key);
                    }
                }
            }
        }
        return oneToOneMap;
    }
    private static Map<Set<String>, Set<String>> collectManyToMany(Multimap<String, String> keyMap,
            Multimap<String, String> valueMap) {
        Map<Set<String>, Set<String>> manyToManyMap = new HashMap<>();
        Set<String> removeKey = new HashSet<>();
        Set<String> keySet = new HashSet<>(keyMap.keySet());
        for (String key : keySet) {
            try {
                if (removeKey.contains(key)) {
                    continue;
                }
                Set<String> allKeys = new HashSet<>();
                Set<String> allValues = new HashSet<>();
                int keySize = 0;
                int valueSize = 0;
                Set<String> values = (Set<String>) keyMap.get(key);
                if (values.size() > 1) {
                    // 多对多, 则key 对应的 value 必须多于 1
                    for (String value : values) {
                        Set<String> tmpKeys = (Set<String>) valueMap.get(value);
                        if (keySize == 0) {
                            keySize = tmpKeys.size();
                        } else if (keySize != tmpKeys.size()) {
                            // 多对多,每个 value 对应的 key 集合元素的个数是一样的
                            throw new Exception();
                        }
                        if (keySize <= 1) {
                            throw new Exception();
                        }
                        allKeys.addAll(tmpKeys);
                    }
                    for (String tmpKey : allKeys) {
                        Set<String> tmpValues = (Set<String>) keyMap.get(tmpKey);
                        if (valueSize == 0) {
                            valueSize = tmpValues.size();
                        } else if (valueSize != tmpValues.size()) {
                            // 多对多,每个 key 对应的 value 集合元素的个数是一样的
                            throw new Exception();
                        }
                        if (valueSize <= 1) {
                            throw new Exception();
                        }
                        allValues.addAll(tmpValues);
                    }
                    if (values.equals(allValues)) {
                        // 每个 key 的 value 集合个数一致,
                        // 而且 value 集合的交集与其中的某 key value 集合元素一致
                        // 则可说明每个 key 的 value 集合是一样的
                        manyToManyMap.put(allKeys, allValues);
                        removeKey.addAll(allKeys);
                        // 删除keyMap和valueMap中多对多的值
                        for (String tmpkey : allKeys) {
                            for (String tmpvalue : allValues) {
                                keyMap.remove(tmpkey, tmpvalue);
                                valueMap.remove(tmpvalue, tmpkey);
                            }
                        }
                    }
                }
            } catch (Exception e) {
            }
        }
        return manyToManyMap;
    }
    private static Map<String, Set<String>> collectOneToMany(Multimap<String, String> keyMap,
            Multimap<String, String> valueMap) {
        Map<String, Set<String>> oneToManyMap = new HashMap<>();
        Set<String> removeKey = new HashSet<>();
        Set<String> keySet = new HashSet<>(keyMap.keySet());
        for (String key : keySet) {
            try {
                if (removeKey.contains(key)) {
                    continue;
                }
                Set<String> values = new HashSet<>(keyMap.get(key));
                if (values.size() > 1) {
                    // 一对多, 则 key 对应的 value 必须多于 1 
                    for (String value : values) {
                        Set<String> keys = (Set<String>) valueMap.get(value);
                        if (keys.size() == 1) {
                            // 而且每个 value 对应的 key 必须唯一
                            continue;
                        } else {
                            throw new Exception();
                        }
                    }
                    oneToManyMap.put(key, values);
                    removeKey.add(key);
                    for (String value : values) {
                        keyMap.remove(key, value);
                        valueMap.remove(value, key);
                    }
                }
            } catch (Exception e) {
            }
        }
        return oneToManyMap;
    }
    private static Map<Set<String>, String> collectManyToOne(Multimap<String, String> keyMap,
            Multimap<String, String> valueMap) {
        Map<Set<String>, String> manyToOneMap = new HashMap<>();
        Set<String> removeKey = new HashSet<>();
        Set<String> keySet = new HashSet<>(keyMap.keySet());
        for (String key : keySet) {
            try {
                if (removeKey.contains(key)) {
                    continue;
                }
                Set<String> values = new HashSet<>(keyMap.get(key));
                if (values.size() == 1) {
                    // 多对一, key 对应的 value 必须唯一
                    for (String value : values) {
                        Set<String> keys = new HashSet<>(valueMap.get(value));
                        if (keys.size() > 1) {
                            // 多对一, value 对应的 key 必须多于1
                            for (String tmpKey : keys) {
                                Set<String> tmpValues = new HashSet<>(keyMap.get(tmpKey));
                                if (tmpValues.size() == 1) {
                                    // 多对一, 每个 key 对应的 value 必须唯一
                                    continue;
                                } else {
                                    throw new Exception();
                                }
                            }
                            manyToOneMap.put(keys, value);
                            removeKey.addAll(keys);
                            for (String tmpKey : keys) {
                                keyMap.remove(tmpKey, value);
                                valueMap.remove(value, tmpKey);
                            }
                        }
                    }
                }
            } catch (Exception e) {
            }
        }
        return manyToOneMap;
    }
    private static void printMultimap(Multimap<String, String> multimap) {
        LOGGER.info("---------------------------------------");
        for (String str : multimap.keySet()) {
            Set<String> keys = (Set<String>) multimap.get(str);
            LOGGER.info(str + " : " + StringUtils.join(keys.toArray(), ","));
        }
    }
    private static void printManyToOne(Map<Set<String>, String> manyToOneMap) {
        LOGGER.info("---------------------------------------");
        LOGGER.info("print manyToOneMap ...");
        for (Entry<Set<String>, String> entry : manyToOneMap.entrySet()) {
            Set<String> keys = entry.getKey();
            String value = entry.getValue();
            for (String tmpKey : keys) {
                LOGGER.info("key:[{}], value:[{}]", tmpKey, value);
            }
        }
    }
    private static void printOneToMany(Map<String, Set<String>> oneToManyMap) {
        LOGGER.info("---------------------------------------");
        LOGGER.info("print oneToManyMap ...");
        for (Entry<String, Set<String>> entry : oneToManyMap.entrySet()) {
            String key = entry.getKey();
            Set<String> values = entry.getValue();
            for (String tmpValue : values) {
                LOGGER.info("key:[{}], value:[{}]", key, tmpValue);
            }
        }
    }
    private static void printManyToMany(Map<Set<String>, Set<String>> manyToManyMap) {
        LOGGER.info("---------------------------------------");
        LOGGER.info("print manyToManyMap ...");
        for (Entry<Set<String>, Set<String>> entry : manyToManyMap.entrySet()) {
            Set<String> keys = entry.getKey();
            Set<String> values = entry.getValue();
            for (String tmpKey : keys) {
                for (String tmpValue : values) {
                    LOGGER.info("key:[{}], value:[{}]", tmpKey, tmpValue);
                }
            }
        }
    }
    private static void printOneToOneMap(Map<String, String> oneToOneMap) {
        LOGGER.info("---------------------------------------");
        LOGGER.info("print oneToOneMap ...");
        for (Entry<String, String> entry : oneToOneMap.entrySet()) {
            LOGGER.info("key:[{}], value:[{}]", entry.getKey(), entry.getValue());
        }
    }
}

测试代码：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.junit.Before;
import org.junit.Test;
public class ClassfyTest {
    @Before
    public void setUp() throws Exception {
    }
    @Test
    public void testClassfyToTwoKind() {
        List<Map<String, String>> list = new ArrayList<>();
        Map<String, String> map1 = new HashMap<>();
        map1.put("keyA", "valueA");
        Map<String, String> map2 = new HashMap<>();
        map2.put("keyA", "valueB");
        Map<String, String> map3 = new HashMap<>();
        map3.put("keyB", "valueA");
        Map<String, String> map4 = new HashMap<>();
        map4.put("keyB", "valueB");
        Map<String, String> map5 = new HashMap<>();
        map5.put("keyC", "valueC");
        Map<String, String> map6 = new HashMap<>();
        map6.put("keyD", "valueD");
        Map<String, String> map7 = new HashMap<>();
        map7.put("keyD", "valueE");
        Map<String, String> map8 = new HashMap<>();
        map8.put("keyE", "valueF");
        Map<String, String> map9 = new HashMap<>();
        map9.put("keyF", "valueF");
        Map<String, String> map10 = new HashMap<>();
        map10.put("keyG", "valueG");

        Map<String, String> map11 = new HashMap<>();
        map11.put("keyH", "valueH");
        Map<String, String> map12 = new HashMap<>();
        map12.put("keyH", "valueI");
        Map<String, String> map13 = new HashMap<>();
        map13.put("keyI", "valueH");
        Map<String, String> map14 = new HashMap<>();
        map14.put("keyI", "valueI");
        Map<String, String> map15 = new HashMap<>();
        map15.put("keyJ", "valueJ");
        Map<String, String> map16 = new HashMap<>();
        map16.put("keyK", "valueK");
        Map<String, String> map17 = new HashMap<>();
        map17.put("keyK", "valueL");
        Map<String, String> map18 = new HashMap<>();
        map18.put("keyL", "valueM");
        Map<String, String> map19 = new HashMap<>();
        map19.put("keyM", "valueM");
        Map<String, String> map20 = new HashMap<>();
        map20.put("keyO", "valueO");

        list.add(map1);
        list.add(map2);
        list.add(map3);
        list.add(map4);
        list.add(map5);
        list.add(map6);
        list.add(map7);
        list.add(map8);
        list.add(map9);
        list.add(map10);

        list.add(map11);
        list.add(map12);
        list.add(map13);
        list.add(map14);
        list.add(map15);
        list.add(map16);
        list.add(map17);
        list.add(map18);
        list.add(map19);
        list.add(map20);

        Classfy.classfyAssociate(list);
    }
}

运行结果：

这里写图片描述

欢迎指出不足
转载请注明出处

湛耀
关注
专栏目录
数据结构第一章概论习题及答案
ywl470812087的博客
04-05 1万+
一、名词解释 1.数据表示 2.数据处理 3.数据 4.数据元素 5.逻辑关系 6.逻辑结构 7.结构 8.运算 9.基本运算 10.存储结构 11.顺序存储结构 12.链式存储结构 13.索引存储结构 14.散列存储结构 15.算法 16.运行终止的程序可执行部分 17.伪语言算法 18.非形式算法 19....
wps二维码根据一列自动生成_拯救秃头！WPS还能这么玩？
weixin_39959349的博客
11-21 1156
hi，我是壹习君，今天的你们，感觉还好吗~说起WPS/Office系列软件，你最头疼的地方是哪里？是软件的某些功能不会用？是公式太复杂？是动画效果不会做？还是长文档排版太难？都！不！是！你最头疼的地方，其实是——当你要用到某个功能的时候，你想不起来；要用到某个公式的时候，你在网上搜不到答案。比如我现在要给一个长文档排版，我知道肯定要用到小节和目录功能，但我真不知道在哪些地方建立小节，也不...
MATLAB实现“一对一”多分类方法
07-12
程序是用于解决多分类问题的“一对一”方法，程序中有个二分类接口是高斯过程分类器，用户可以进行修改，用什么分类器都可以。该程序是用MATLAB把一对一的思想写成了代码。
对数据进行分类
qq_2221775251的博客
12-22 1032
数值分为两大类：整型；浮点型。 字符型：char。 无符号字符型：unsigned char。 短整型：short。 无符号短整型：unsignes short 整型：int。 无符号整型：unsigned int。 长整型：long。 无符号长整型：unsigned long。 单精度型：float。 双精度型：double。 长双精度型：long double。
多组数据分类
weixin_51512095的博客
10-16 417
最近新生赛选拔就要开始了，师傅想选一个心仪的徒弟继承他的衣钵，他想看看新生的实力，但是师傅比较懒，要我帮他给新生排个名次， 首先是按照IQ从大到小排名， 在IQ同样的基础上按照AQ从小到大排名, 若IQ和AQ都相同，则根据id从小到大排名. 【输入形式】 n a1 a2 … an f1 f2 … fn 第一行输入一个正整数n，0<n<201,表示新生人数（id从1-n编号）， 第二行按id顺序输入n个整数ai，0<=ai<100，表示第i位新生的IQ， 第三行按id顺序输入n
支持向量机一对一多分类
04-10
已经把相应的函数放在了压缩包里，包括数据图片运行结果，用的是传统的一对一支持向量机多分类方法，直接可以运行。如果你不能直接运行，请安装stprtool工具箱或相应的函数。
吴恩达机器学习笔记18-多类别分类：一对多(Multiclass Classification_ One-vs-all)
weixin_34291004的博客
02-18 828
　　对于之前的一个，二元分类问题，我们的数据看起来可能是像这样： 　　对于一个多类分类问题，我们的数据集或许看起来像这样： 　　我用3 种不同的符号来代表3 个类别，问题就是给出3 个类型的数据集，我们如何得到一个学习算法来进行分类呢？我们现在已经知道如何进行二元分类，可以使用逻辑回归，对于直线或许你也知道，可以将数据集一分为二为正类和负类。用一对多的分类思想，我们可以将其用在多类分类...
计算机系统结构第一章自考练习题答案.pdf
最新发布
05-14
3. **弗林分类法**：根据指令流和数据流的组合，弗林将计算机系统分为四类：SISD（单指令流单数据流）、SIMD（单指令流多数据流）、MISD（多指令流单数据流）和MIMD（多指令流多数据流）。SIMD适用于数据密集型应用...
一年级数学一图四式训练.doc
10-20
在这个阶段，孩子们通常会接触到简单的数量关系，如物体的增加或减少，而"一图四式"就是将这种关系转化为数学表达式的过程。 一、看图写出四道算式 在"一图四式"的训练中，一幅图通常会包含两个或多个数量间的交互...
微干预带来的即时情绪改善效果 缺乏持久效果 对抑郁症患者是否有效需要更多研究
2017年第10期第17-22页微干预在情绪和痛苦方面产生即时但不持久的益处阿什利湾放大图片创作者：Alfreda，J.Muñoza，b，c，Eduardo L.Bungea，c...临床试验A B S T R A C T未经治疗的抑郁症仍然是最大的公共卫生问题之一...
bp神经网络 多组数据_基于改进BP神经网络的心电信号分类方法
weixin_39779032的博客
12-29 1201
心电图是心脏电活动在人体体表的反映，是检测和诊断心脏疾病的重要依据。早期心脏疾病诊断主要凭借医生丰富的经验，长时间诊断中可能存在误检或错检。随着计算机技术的快速发展，实现心电信号自动分析成为研究的热点[1]。心电信号分类的本质是模式识别。常用的心电信号分类方法有支持向量机(Support Vector Machines，SVM)[2-3]、人工神经网络(Artificial Neural Netw...
数据分类/组处理
qq_41170489的博客
01-09 895
数据分类/组处理 groupby（） 分组函数 分组之后必聚合，只对数字的列聚合 单列进行分组 data.groupby(“attack_range”).mean()[“hp_max”] 使用列表进行多条件分组 data.groupby([“attack_range”,“role_main”]).mean()[“hp_max”] 对不同列求不同的聚合指标 gp = data.groupby([“a...
简单类（多对多练习）
dududu1224的博客
07-15 286
class Student{ private int id; private String name; private Studentcourse[] studentcourse; public Student(){ } public Student(int id,String name){ this.id=id; thi
SQL 一对多转为一对一
偷得浮生半日闲
03-08 788
一对多产生笛卡尔积 需求：A表一条数据对B表多条数据中一条数据（且这个数据经过排序选择最大的一条）
libsvm处理多分类的问题
机器智能
05-31 3588
SVM作为判别模型(discriminative model)中所使用的典型方法，其产生是为2分类问题设计的 svm多分类效果不佳，目前是svm研究的热点之一。libsvm用的是one- versus-one法。 简介： .一对一法（one-versus-one,简称OVO SVMs或者pairwise）。其做法是在任意两类样本之间设计一个SVM，因此k个类别的样本就需要设计k(k-
一对多查询，合并成一条数据
weixin_34314962的博客
09-13 642
一对多查询，合并成一条数据 举例：一个产品对应多个型号，把多个型号查询出来显示在一个字段下面。显示出一条数据。 步骤： 1：创建产品表： 2：创建型号表： 思路： 先写出不含产品型号的查询语句， 然后将一个产品对应的多个成分合并成一个字段， 将合成的字段插入到一个语句中 sql语句： SELECT p.id AS ...
SQL 数据库 学习 011 关系、一对一、一对多、多对多
热门推荐
AoboSir.com
10-14 2万+
我的电脑系统：Windows 10 64位 SQL Server 软件版本： SQL Server 2014 Express 什么是关系定义： 表和表之间的联系。 实现方式： 通过设置不同形式的外键来体现表和表的不同关系。 关系的分类（假设是A表和B表）第一种分类： 一对一 （详述一对一关系及其实现）（一对一，几乎不使用。所以，我们就一句话带过。） 一对一的实现：既可以把表A的主键充当表B的外键
机器学习--多分类任务
weixin_50267049的博客
12-06 1247
一、思想 多分类问题还是以二分类为基础，即将多分类任务拆解为多个二分类任务。 具体来说就是先对问题进行拆分，然后对每个二分类任务训练一个分类学习器；测试时对这些分类器的预测结果进行汇总，然后得出最终分类结果。 二、拆解策略 2.1 一对一(OVO) ①、流程 将N个类别进行两两配对，产生N(N-1)/2 个二分类任务，然后为每一个二分类任务训练一个分类器。测试阶段，分类器将新样本进行预测，得到N(N-1)/2个预测结果，最终结果通过”投票”产生。 2.2 一对其余(OVR) ①、流程 对于由N个类别的样本，
一文详解Java数据类型
阔码人生
06-19 237
数据类型概述 在学习数据类型之前我们先来思考一个问题，数据类型在程序中起什么作用呢？ 实际上软件主要是对数据进行处理，现实生活中的数据有很多，所以编程语言对其进行了分类，然后就产生了数据类型，不同数据类型的数据会给其分配不同大小的空间进行存储。也就是说，数据类型作用就是决定程序运行阶段给变量分配多大的内存空间。 java 中的数据类型包括两大类，一类是基本数据类型，另一类是引用数据类型。其中，基本数据类型又包括以下 4 类 8 种： 第1类：整数型（不带小数的数字）：byte, short, int, l
苏仕华数据库练习题：基础理论与一对一至多对多联系详解
5. 第六至九题通过实例测试不同类型的实体联系，一对一联系（如父亲与孩子）、一对多联系（如学校与学生）和多对多联系（如商店与顾客）的概念。例如，一个教师可以教授多个课程，而一个课程可以有多名学生，这属于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值