非加权图在推荐系统中的建模方法

本文详细阐述如何在Java中为推荐系统构建非加权图，以有效管理和识别用户间的复杂关系，如“密切联系人”。文章从数据读取和存储入手，逐步指导如何将人员信息转化为图的节点，并基于共享属性（社区、学校、雇主）定义边，最终形成邻接列表表示的图结构，并整合隐私设置，为后续的推荐逻辑奠定基础。

在构建推荐系统时，有效地表示和管理实体之间的关系至关重要。对于需要基于“密切联系人”概念进行推荐的场景，图数据结构提供了一种直观且强大的建模方式。本文将指导您如何在Java中，从原始文件数据出发，构建一个非加权图来表示人员之间的关系，并集成隐私设置。

1. 数据模型定义

首先，我们需要定义用于存储人员和活动信息的Java类。这些类将作为图的节点和相关属性的载体。

import java.util.Objects;

// Person 类用于存储人员信息
public class Person {
    private String firstname;
    private String lastname;
    private String phone;
    private String email;
    private String community;
    private String school;
    private String employer;
    private String privacy; // "Y" 表示请求隐私，"N" 表示不请求

    // 构造函数
    public Person() {}

    // Getters and Setters
    public String getFirstname() { return firstname; }
    public void setFirstname(String firstname) { this.firstname = firstname; }
    public String getLastname() { return lastname; }
    public void setLastname(String lastname) { this.lastname = lastname; }
    public String getPhone() { return phone; }
    public void setPhone(String phone) { this.phone = phone; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
    public String getCommunity() { return community; }
    public void setCommunity(String community) { this.community = community; }
    public String getSchool() { return school; }
    public void setSchool(String school) { this.school = school; }
    public String getEmployer() { return employer; }
    public void setEmployer(String employer) { this.employer = employer; }
    public String getPrivacy() { return privacy; }
    public void setPrivacy(String privacy) { this.privacy = privacy; }

    // 判断是否请求隐私
    public boolean requestsPrivacy() {
        return "Y".equalsIgnoreCase(privacy);
    }

    // 重写 equals 和 hashCode 方法，确保在集合（如Map的键）中正确识别Person对象
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return Objects.equals(firstname, person.firstname) &&
               Objects.equals(lastname, person.lastname) &&
               Objects.equals(email, person.email); // 假设 firstname, lastname, email 组合唯一标识一个人
    }

    @Override
    public int hashCode() {
        return Objects.hash(firstname, lastname, email);
    }

    @Override
    public String toString() {
        return "Person{" +
               "firstname='" + firstname + '\'' +
               ", lastname='" + lastname + '\'' +
               ", community='" + community + '\'' +
               ", school='" + school + '\'' +
               ", employer='" + employer + '\'' +
               ", privacy='" + privacy + '\'' +
               '}';
    }
}

// Activities 类用于存储活动信息 (在本教程中，活动信息不直接用于构建图，但作为原始数据的一部分保留)
public class Activities {
    private String firstname;
    private String lastname;
    private String activity;

    // 构造函数
    public Activities() {}

    // Getters and Setters
    public String getFirstname() { return firstname; }
    public void setFirstname(String firstname) { this.firstname = firstname; }
    public String getLastname() { return lastname; }
    public void setLastname(String lastname) { this.lastname = lastname; }
    public String getActivity() { return activity; }
    public void setActivity(String activity) { this.activity = activity; }

    @Override
    public String toString() {
        return "Activities{" +
               "firstname='" + firstname + '\'' +
               ", lastname='" + lastname + '\'' +
               ", activity='" + activity + '\'' +
               '}';
    }
}

注意事项：

• Person 类中重写 equals() 和 hashCode() 方法至关重要。当 Person 对象被用作 Map 的键或存储在 Set 中时，这些方法确保了对象的正确比较和唯一性识别。通常，选择一个或多个属性组合作为唯一标识（例如，姓、名和电子邮件）。
• privacy 属性的 requestsPrivacy() 方法提供了一个便捷的方式来检查隐私状态。

2. 数据读取与存储优化

原始数据文件需要被读取并存储到易于操作的集合中。ArrayList 是一个合适的选择，用于临时存储所有 Person 和 Activities 对象。

import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class InfoReader {

    private List persons;
    private List activities;

    public InfoReader() {
        this.persons = new ArrayList<>();
        this.activities = new ArrayList<>();
    }

    public void ReadInfo() {
        // 读取人员数据
        try {
            // 请根据您的实际文件路径修改
            String personFileLocation = "path" + File.separator + "to" + File.separator + "SamplefilePersons2022Oct31text.csv";
            File personListFile = new File(personFileLocation);
            Scanner personScanner = new Scanner(personListFile);

            while (personScanner.hasNextLine()) {
                String nextline = personScanner.nextLine();
                String[] personComponents = nextline.split(",");
                if (personComponents.length >= 8) { // 确保数据完整性
                    Person newPerson = new Person();
                    newPerson.setFirstname(personComponents[0].trim());
                    newPerson.setLastname(personComponents[1].trim());
                    newPerson.setPhone(personComponents[2].trim());
                    newPerson.setEmail(personComponents[3].trim());
                    newPerson.setCommunity(personComponents[4].trim());
                    newPerson.setSchool(personComponents[5].trim());
                    newPerson.setEmployer(personComponents[6].trim());
                    newPerson.setPrivacy(personComponents[7].trim());
                    this.persons.add(newPerson); // 将 Person 对象存储到列表中
                }
            }
            personScanner.close(); // 关闭扫描器
        } catch (FileNotFoundException e) {
            System.err.println("人员文件未找到: " + e.getMessage());
            throw new RuntimeException("无法读取人员数据", e);
        }

        // 读取活动数据
        try {
            // 请根据您的实际文件路径修改
            String activityFileLocation = "path" + File.separator + "to" + File.separator + "SamplefileActivities2022Oct31text.csv";
            File activityListFile = new File(activityFileLocation);
            Scanner activityScanner = new Scanner(activityListFile);

            while (activityScanner.hasNextLine()) {
                String nextLine = activityScanner.nextLine();
                String[] activityComponents = nextLine.split(",");
                if (activityComponents.length >= 3) { // 确保数据完整性
                    Activities newActivity = new Activities();
                    newActivity.setFirstname(activityComponents[0].trim());
                    newActivity.setLastname(activityComponents[1].trim());
                    newActivity.setActivity(activityComponents[2].trim());
                    this.activities.add(newActivity); // 将 Activities 对象存储到列表中
                }
            }
            activityScanner.close(); // 关闭扫描器
        } catch (FileNotFoundException e) {
            System.err.println("活动文件未找到: " + e.getMessage());
            throw new RuntimeException("无法读取活动数据", e);
        }
    }

    public List getPersons() {
        return persons;
    }

    public List getActivities() {
        return activities;
    }
}

关键改进：

• 在 InfoReader 类中定义了 persons 和 activities 两个 ArrayList 成员变量。
• 在循环内部，创建 Person 或 Activities 对象后，立即将其添加到对应的列表中。
• 添加了 trim() 方法去除字符串两端的空白，提高数据处理的健壮性。
• 增加了 if (personComponents.length >= X) 检查，避免因数据行不完整而导致的 ArrayIndexOutOfBoundsException。
• 在 try-catch 块中关闭了 Scanner 资源。

3. 图数据结构基础与表示

图由节点（Vertices/Nodes）和边（Edges）组成。

• 在我们的场景中，每个 Person 对象可以被视为一个节点。
• 如果两个人之间满足“密切联系人”的条件（共享社区、学校或雇主），则他们之间存在一条边。
• 这是一个非加权图，因为边没有关联的权重（例如，联系的强度）。
• 这是一个无向图，因为如果A是B的密切联系人，那么B也是A的密切联系人。

图的常见表示方法有邻接矩阵和邻接列表。对于稀疏图（边相对较少），邻接列表通常更高效，它使用 Map 来存储每个节点及其相邻节点列表。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Graph {
    // 邻接列表：Map 的键是 Person 节点，值是其所有相邻 Person 节点的列表
    private Map> adjList;

    public Graph() {
        this.adjList = new HashMap<>();
    }

    // 添加一个节点到图中（如果它还不存在）
    public void addPerson(Person person) {
        adjList.putIfAbsent(person, new ArrayList<>());
    }

    // 添加一条边：将 person2 添加到 person1 的邻接列表中，反之亦然（无向图）
    public void addRelationship(Person person1, Person person2) {
        // 确保两个人都已作为节点存在
        addPerson(person1);
        addPerson(person2);

        // 添加双向关系
        if (!adjList.get(person1).contains(person2)) {
            adjList.get(person1).add(person2);
        }
        if (!adjList.get(person2).contains(person1)) {
            adjList.get(person2).add(person1);
        }
    }

    // 获取某个人的所有密切联系人
    public List getCloseContacts(Person person) {
        return adjList.getOrDefault(person, new ArrayList<>());
    }

    // 打印图的结构
    public void printGraph() {
        for (Map.Entry> entry : adjList.entrySet()) {
            System.out.print("Person: " + entry.getKey().getFirstname() + " " + entry.getKey().getLastname() + " -> ");
            for (Person neighbor : entry.getValue()) {
                System.out.print(neighbor.getFirstname() + " " + neighbor.getLastname() + ", ");
            }
            System.out.println();
        }
    }
}

4. 构建人员关系图

现在，我们将读取的数据转换为图结构。核心逻辑是遍历所有人员对，检查他们是否符合“密切联系人”的条件，然后添加相应的边。

import java.util.List;
import java.util.Objects; // 用于Objects.equals的空值安全比较

public class GraphBuilder {

    public static Graph buildRecommendationGraph(List persons) {
        Graph graph = new Graph();

        // 将所有人员添加到图中作为节点
        for (Person p : persons) {
            graph.addPerson(p);
        }

        // 遍历所有人员对，建立密切联系关系
        for (int i = 0; i < persons.size(); i++) {
            for (int j = i + 1; j < persons.size(); j++) { // 避免重复和自连接
                Person p1 = persons.get(i);
                Person p2 = persons.get(j);

                // 判断是否为密切联系人：共享社区、学校或雇主
                boolean isCloseContact = false;
                if (p1.getCommunity() != null && !p1.getCommunity().isEmpty() &&
                    Objects.equals(p1.getCommunity(), p2.getCommunity())) {
                    isCloseContact = true;
                }
                if (p1.getSchool() != null && !p1.getSchool().isEmpty() &&
                    Objects.equals(p1.getSchool(), p2.getSchool())) {
                    isCloseContact = true;
                }
                if (p1.getEmployer() != null && !p1.getEmployer().isEmpty() &&
                    Objects.equals(p1.getEmployer(), p2.getEmployer())) {
                    isCloseContact = true;
                }

                if (isCloseContact) {
                    graph.addRelationship(p1, p2);
                }
            }
        }
        return graph;
    }

    // 整合隐私设置的推荐生成方法
    public static List getRecommendedContacts(Person targetPerson, Graph graph) {
        List recommendations = new ArrayList<>();

        // 如果目标人员请求隐私，则不进行任何推荐
        if (targetPerson.requestsPrivacy()) {
            System.out.println(targetPerson.getFirstname() + " " + targetPerson.getLastname() + " 已请求隐私，不生成推荐。");
            return recommendations;
        }

        // 获取目标人员的所有密切联系人
        List closeContacts = graph.getCloseContacts(targetPerson);

        // 过滤掉请求隐私的联系人
        for (Person contact : closeContacts) {
            if (!contact.requestsPrivacy()) {
                recommendations.add(contact);
            }
        }
        return recommendations;
    }

    public static void main(String[] args) {
        // 1. 读取数据
        InfoReader reader = new InfoReader();
        reader.ReadInfo(); // 确保您已修改文件路径

        List allPersons = reader.getPersons();
        // List allActivities = reader.getActivities(); // 活动数据在本例中不直接用于图构建

        // 2. 构建图
        Graph recommendationGraph = buildRecommendationGraph(allPersons);
        System.out.println("--- 图结构 ---");
        recommendationGraph.printGraph();

        // 3. 生成推荐
        System.out.println("\n--- 推荐结果 ---");
        if (!allPersons.isEmpty()) {
            // 假设我们想为列表中的第一个人生成推荐
            Person personToRecommendFor = allPersons.get(0);
            List recommendations = getRecommendedContacts(personToRecommendFor, recommendationGraph);

            System.out.println("为 " + personToRecommendFor.getFirstname() + " " + personToRecommendFor.getLastname() + " 推荐的联系人:");
            if (recommendations.isEmpty()) {
                System.out.println("  无推荐或所有密切联系人均已请求隐私。");
            } else {
                for (Person rec : recommendations) {
                    System.out.println("  - " + rec.getFirstname() + " " + rec.getLastname());
                }
            }

            // 示例：为另一个可能请求隐私的人生成推荐
            // 假设我们有一个名为 "John Doe" 的人，并且他请求了隐私
            Person privacyRequester = new Person();
            privacyRequester.setFirstname("John");
            privacyRequester.setLastname("Doe");
            privacyRequester.setPrivacy("Y"); // 设置为请求隐私
            privacyRequester.setCommunity("SomeCommunity"); // 确保equals方法能匹配
            privacyRequester.setSchool("SomeSchool");
            privacyRequester.setEmail("john.doe@example.com");

            // 假设 John Doe 也在 allPersons 列表中，或者我们只是模拟
            // 如果不在列表中，getCloseContacts可能返回空，这里仅为演示隐私过滤
            // 实际应用中，privacyRequester 应该来自 allPersons 列表
            List privacyRecommendations = getRecommendedContacts(privacyRequester, recommendationGraph);
            if (privacyRecommendations.isEmpty() && privacyRequester.requestsPrivacy()) {
                 // 已经打印了信息，这里不再重复
            } else if (!privacyRecommendations.isEmpty()) {
                System.out.println("为 " + privacyRequester.getFirstname() + " " + privacyRequester.getLastname() + " 推荐的联系人:");
                for (Person rec : privacyRecommendations) {
                    System.out.println("  - " + rec.getFirstname() + " " + rec.getLastname());
                }
            }
        } else {
            System.out.println("没有读取到人员数据，无法生成推荐。");
        }
    }
}

代码解析：

• buildRecommendationGraph 方法负责图的实际构建。它首先将所有 Person 对象添加为图的节点，然后通过嵌套循环遍历所有人员对。
• Objects.equals() 用于安全地比较字符串属性，即使其中一个为 null 也不会抛出 NullPointerException。
• getRecommendedContacts 方法演示了如何利用构建好的图来生成推荐。它首先获取目标人员的所有直接密切联系人，然后根据隐私