Java Stackoverflow对具有相互引用的列表元素的类调用toString（）

我有一个带有团队列表的用户类：

class User {
  List<Team> teams...

  public String toString() {
    return "a user and " + teams.toString();
  }
}

类用户{
列出团队。。。
公共字符串toString（）{
返回“a user and”+teams.toString（）；
}
}

以及包含用户列表的团队类：

class Team {
  List<User> users...

  public String toString() {
    return "a team and " + users.toString();
  }
}

班级团队{
列出用户。。。
公共字符串toString（）{
返回“一个团队和”+users.toString（）；
}
}

我创建的用户和团队如下所示：

User aUser = new User();
List<User> usersList = new ArrayList<User>();
usersList.add(aUser);

Team aTeam = new Team();
List<Team> teamsList = new ArrayList<User>();
teamsList.add(aTeam);

aUser.setTeams(teamsList);
aTeam.setUsers(userList);

User aUser=new User（）；
List usersList=new ArrayList（）；
usersList.add（aUser）；
团队aTeam=新团队（）；
List teamsList=new ArrayList（）；
团队列表添加（aTeam）；
aUser.setTeams（团队列表）；
aTeam.setUsers（用户列表）；

但是当我调用user.toString（）时，由于用户和团队之间的循环，我得到了一个StackOverflower错误

---

关于如何绕过这个循环有什么想法吗？

是的，因为调用

列表的
toString（）
方法将依次调用其元素的
toString（）
方法，将元素的
toString（）返回值逐个追加到一个字符串并返回

对于您的上下文，
users.toString（）
将导致
user
实例的
toString（）
调用
user
类：这反过来调用
teams.toString（）
方法，从而产生
team
类的团队实例的
toString（）
。因此，一个循环正在发生，通过函数调用函数

然而，正如这位官员所说：

返回对象的字符串表示形式。总的来说
toString方法返回一个字符串，该字符串“以文本形式表示”此
对象结果应该是简洁但信息丰富的表示
这对一个人来说很容易阅读。建议所有
子类重写此方法

所以，您不应该为不同类的对象返回相同的表示：这可能是您正在尝试的
 是，因为调用
列表的
toString（）
方法将依次调用其元素的
toString（）
方法，将元素的
toString（）
返回值逐个追加到一个字符串并返回

对于您的上下文，
users.toString（）
将导致
user
实例的
toString（）
调用
user
类：这反过来调用
teams.toString（）
方法，从而产生
team
类的团队实例的
toString（）
。因此，一个循环正在发生，通过函数调用函数

然而，正如这位官员所说：

返回对象的字符串表示形式。总的来说
toString方法返回一个字符串，该字符串“以文本形式表示”此
对象结果应该是简洁但信息丰富的表示
这对一个人来说很容易阅读。建议所有
子类重写此方法

所以，您不应该为不同类的对象返回相同的表示：这可能是您正在尝试的
 是，因为调用
列表的
toString（）
方法将依次调用其元素的
toString（）
方法，将元素的
toString（）
返回值逐个追加到一个字符串并返回

对于您的上下文，
users.toString（）
将导致
user
实例的
toString（）
调用
user
类：这反过来调用
teams.toString（）
方法，从而产生
team
类的团队实例的
toString（）
。因此，一个循环正在发生，通过函数调用函数

然而，正如这位官员所说：

返回对象的字符串表示形式。总的来说
toString方法返回一个字符串，该字符串“以文本形式表示”此
对象结果应该是简洁但信息丰富的表示
这对一个人来说很容易阅读。建议所有
子类重写此方法

所以，您不应该为不同类的对象返回相同的表示：这可能是您正在尝试的
 是，因为调用
列表的
toString（）
方法将依次调用其元素的
toString（）
方法，将元素的
toString（）
返回值逐个追加到一个字符串并返回

对于您的上下文，
users.toString（）
将导致
user
实例的
toString（）
调用
user
类：这反过来调用
teams.toString（）
方法，从而产生
team
类的团队实例的
toString（）
。因此，一个循环正在发生，通过函数调用函数

然而，正如这位官员所说：

返回对象的字符串表示形式。总的来说
toString方法返回一个字符串，该字符串“以文本形式表示”此
对象结果应该是简洁但信息丰富的表示
这对一个人来说很容易阅读。建议所有
子类重写此方法

所以，您不应该为不同类的对象返回相同的表示：这可能是您正在尝试的
 这里的根本问题是糟糕的设计。你是对的，有一个循环。要解决此问题，请不要在
用户
中包含对
团队
的任何引用；相反，只需在每个
团队的列表中列出属于
团队的
用户。为了稍后确定哪些人属于哪些团队，您可以遍历
Team
s列表，或者使用其他一些数据结构

通常，您总是希望保留更多的原子元素（在本例中为
User
，因为
User
s是组成
Team
s的原子）独立于对复合元素的引用。
这里的基本问题是设计不佳。你是对的，有一个循环。为了解决这个问题，d
class User {
  List<Team> teams...

  public String toString() {
    StringBuilder sb = ...
    sb.append("a user and ");

    for (Team team : teams) {
      sb.append("[a team with id ")
      sb.append(team.getId());
      sb.append("and team name ");
      sb.append(team.getName());
      sb.append("] ");
    } 
    return sb.toString();
  }
}