数组创建堆栈溢出 [英] Array Creation Stack overflow
问题描述
我得到一个错误的位置，将继续给我一个堆栈溢出。我基本上想要做的就是创建具有矩形对象的数组列表。但是，如果任何对象的相互重叠的话，我会再次调用该方法，直到它创建不重叠对象的数组创建数组。谁能告诉我什么是错？
公共类TokenArrayCreator {
公众最终诠释TOKEN_WIDTH = 35;私人GameToken TOKEN1;
私人的ArrayList＆LT; GameToken＆GT; tokenarr;
公共TokenArrayCreator（）
{}
公众的ArrayList＆LT; GameToken＆GT; ArrayCreator（）
{
ArrayList的＆LT; GameToken＆GT; tokenArray =新的ArrayList＆LT; GameToken＆GT;（）;
随机随机=新的随机（）;
的for（int i = 0; I＆LT; = 10;我++）
{
GameToken标记=新GameToken（random.nextInt（300），random.nextInt（300），35,35）;
tokenArray.add（标记）;
}
的for（int i = 0; I＆LT; = 10;我++）//使两个列表i和j＆功放;＆安培;如果我！= j的
{
对于（INT J = 0; J＆LT; = 10; J ++）
{
如果（我！= j）条
{
如果（tokenArray.get（I）.overlaps（tokenArray.get（J）））
{
TokenArrayCreator T1 =新TokenArrayCreator（）;
t1.ArrayCreator（）;
} }
别人休息;
} }
返回tokenArray;
}
以上是我的数组的创造者类。下面是我的重叠法是另一个类。
公共布尔重叠（VisibleShape等）
{GameToken其他1 =（GameToken）等;
如果（this.bbox.intersects（other1.bbox））
{
返回true;
}
否则返回false;
}
下面是堆栈跟踪
异常线程mainjava.lang.StackOverflowError
在java.util.Hashtable.hash（来源不明）
在java.util.Hashtable.get（来源不明）
在javax.swing.UIDefaults.getFromHashtable（来源不明）
在javax.swing.UIDefaults.get（来源不明）
在javax.swing.MultiUIDefaults.get（来源不明）
在javax.swing.UIDefaults.getFont（来源不明）
在javax.swing.UIManager.getFont（来源不明）
在javax.swing.LookAndFeel.installColorsAndFont（来源不明）
在javax.swing.plaf.basic.BasicPanelUI.installDefaults（来源不明）
在javax.swing.plaf.basic.BasicPanelUI.installUI（来源不明）
在javax.swing.JComponent.setUI（来源不明）
在javax.swing.JPanel.setUI（来源不明）
在javax.swing.JPanel.updateUI（来源不明）
在javax.swing.JPanel中＆LT;＆初始化GT;（未知来源）
在javax.swing.JPanel中＆LT;＆初始化GT;（未知来源）
在javax.swing.JPanel中＆LT;＆初始化GT;（未知来源）
在CircPattern＆LT;＆初始化GT;（CircPattern.java:25）
在图案和LT。INIT＆GT;（Pattern.java:40）
在GameToken＆LT;＆初始化GT;（GameToken.java:18）
在TokenArrayCreator.ArrayCreator（TokenArrayCreator.java:26）
在TokenArrayCreator.ArrayCreator（TokenArrayCreator.java:40）
在TokenArrayCreator.ArrayCreator（TokenArrayCreator.java:40）
在TokenArrayCreator.ArrayCreator（TokenArrayCreator.java:40）
在TokenArrayCreator.ArrayCreator（TokenArrayCreator.java:40）
在TokenArrayCreator.ArrayCreator（TokenArrayCreator.java:40）
基本上，你在做什么，每次找到两个相交的对象，你正在创建一个全新的的实例 TokenArrayCreator ，然后调用它的 ArrayCreator 方法。
这将创建一个全新的 的ArrayList 并再次尝试填满它，当它发现相交的对象，它创建一个全新 TokenArrayCreator 的实例，并调用它的 ArrayCreator ....一遍又一遍...
除了这一事实没有这些实例有彼此的任何关系（它们都不知道的其他已创建），这是非常罕见的，任何一个将能够创建非重叠对象的全阵列，因此，你的问题。
相反，考虑删除从 ArrayList中的违规对象之一，并继续尝试，直到达到它想要的大小，创建对象，例如...
公共类TokenArrayCreator { 公众最终诠释TOKEN_WIDTH = 35; 私人的ArrayList＆LT;矩形＆GT; tokenarr; 公共TokenArrayCreator（）{
} 公共无效ArrayCreator（）{ tokenarr =新的ArrayList＆LT;矩形＆GT;（）;
随机随机=新的随机（）; INT requiredObjectCount = 11; 而（tokenarr.size（）＆LT; requiredObjectCount）{ 的for（int i = 0; I＆LT; requiredObjectCount - tokenarr.size（）;我++）{
长方形令牌=新的Rectangle（random.nextInt（300），random.nextInt（300），35，35）;
tokenarr.add（标记）;
} 的for（int i = 0; I＆LT; tokenarr.size（）;我++）//使两个列表i和j＆功放;＆安培;如果我！= j的
{
对于（INT J = 0; J＆LT; tokenarr.size（）; J ++）{
如果（我！= j）条{
如果（tokenarr.get（I）.intersects（tokenarr.get（J）））{
tokenarr.remove（J）;
}
}
}
} } } 公众的ArrayList＆LT;矩形＆GT;的GetList（）{
返回tokenarr;
}}
现在，从我persepective，这可能不是最快的解决方案，在您需要循环多次获得的ArrayList 正确填写在这不是时间一致（每次运行它的时候，它会采取不同的时间来运行），并有一个非常小的机会，它永远不会返回（取决于可用大小与您共创对象的数量），但它将解决您的问题immeditate
I'm getting an error where it would keep giving me a stack overflow. What I basically wanna do is create an Array List of objects that have rectangles. However, if any of the object overlap one another then, I would call the method again and create an array till it creates an array of objects that do not overlap. Can anyone tell me whats wrong?
public class TokenArrayCreator {
public final int TOKEN_WIDTH= 35;
private GameToken token1;
private ArrayList<GameToken> tokenarr;
public TokenArrayCreator()
{}
public ArrayList<GameToken> ArrayCreator()
{
ArrayList<GameToken> tokenArray = new ArrayList<GameToken>();
Random random = new Random();
for(int i =0; i<=10 ;i++)
{
GameToken token= new GameToken(random.nextInt(300),random.nextInt(300),35,35);
tokenArray.add(token);
}
for(int i =0 ; i<=10 ; i++) // make two list i and j && if i != j
{
for(int j= 0; j<=10 ; j++)
{
if(i!=j)
{
if(tokenArray.get(i).overlaps(tokenArray.get(j)))
{
TokenArrayCreator t1= new TokenArrayCreator();
t1.ArrayCreator();
}
}
else break;
}
}
return tokenArray;
}
Above is my array creator class. Below is my overlap method that is in another class.
public boolean overlaps(VisibleShape other)
{
GameToken other1 = (GameToken) other;
if(this.bbox.intersects(other1.bbox))
{
return true;
}
else return false;
}
Here is the stack trace
Exception in thread "main" java.lang.StackOverflowError
at java.util.Hashtable.hash(Unknown Source)
at java.util.Hashtable.get(Unknown Source)
at javax.swing.UIDefaults.getFromHashtable(Unknown Source)
at javax.swing.UIDefaults.get(Unknown Source)
at javax.swing.MultiUIDefaults.get(Unknown Source)
at javax.swing.UIDefaults.getFont(Unknown Source)
at javax.swing.UIManager.getFont(Unknown Source)
at javax.swing.LookAndFeel.installColorsAndFont(Unknown Source)
at javax.swing.plaf.basic.BasicPanelUI.installDefaults(Unknown Source)
at javax.swing.plaf.basic.BasicPanelUI.installUI(Unknown Source)
at javax.swing.JComponent.setUI(Unknown Source)
at javax.swing.JPanel.setUI(Unknown Source)
at javax.swing.JPanel.updateUI(Unknown Source)
at javax.swing.JPanel.<init>(Unknown Source)
at javax.swing.JPanel.<init>(Unknown Source)
at javax.swing.JPanel.<init>(Unknown Source)
at CircPattern.<init>(CircPattern.java:25)
at Pattern.<init>(Pattern.java:40)
at GameToken.<init>(GameToken.java:18)
at TokenArrayCreator.ArrayCreator(TokenArrayCreator.java:26)
at TokenArrayCreator.ArrayCreator(TokenArrayCreator.java:40)
at TokenArrayCreator.ArrayCreator(TokenArrayCreator.java:40)
at TokenArrayCreator.ArrayCreator(TokenArrayCreator.java:40)
at TokenArrayCreator.ArrayCreator(TokenArrayCreator.java:40)
at TokenArrayCreator.ArrayCreator(TokenArrayCreator.java:40)
Basically, what you are doing, each time you find two intersecting objects, you are creating a brand new instance of TokenArrayCreator and then call it's ArrayCreator method.
This creates a brand new ArrayList and attempts to fill it again, when it finds intersecting objects, it creates a brand new instance of TokenArrayCreator and calls it's ArrayCreator....over and over again...
Apart from the fact that none of these instance have any relationship to each other (none of them knows what the other have created), it's very rare that any one would be able to create a full array of non-overlapping objects, hence your problem.
Instead, consider removing one of the offending objects from the ArrayList and continue trying to create objects until it reaches it's desired size, for example...
public class TokenArrayCreator {
public final int TOKEN_WIDTH = 35;
private ArrayList<Rectangle> tokenarr;
public TokenArrayCreator() {
}
public void ArrayCreator() {
tokenarr = new ArrayList<Rectangle>();
Random random = new Random();
int requiredObjectCount = 11;
while (tokenarr.size() < requiredObjectCount) {
for (int i = 0; i < requiredObjectCount - tokenarr.size(); i++) {
Rectangle token = new Rectangle(random.nextInt(300), random.nextInt(300), 35, 35);
tokenarr.add(token);
}
for (int i = 0; i < tokenarr.size(); i++) // make two list i and j && if i != j
{
for (int j = 0; j < tokenarr.size(); j++) {
if (i != j) {
if (tokenarr.get(i).intersects(tokenarr.get(j))) {
tokenarr.remove(j);
}
}
}
}
}
}
public ArrayList<Rectangle> getList() {
return tokenarr;
}
}
Now, from my persepective, this probably isn't the "fastest" solution, in that you will need to loop multiple times to get the ArrayList to fill properly and the it's not time consistent (each time you run it, it will take a different time to run) and there is a very small chance that it will never return (depending on the available size and the number of objects you create), but it will solve your immeditate problem
这篇关于数组创建堆栈溢出的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
