如何修复java中的堆栈溢出错误？

我有一个静态数组电影[]电影的类电影。我实现了Comparable，并重载了compareTo方法。如果一部电影的喜好与另一部电影的喜好相同，那么我会按照字母顺序进行比较。我必须创建一个快速排序实现来对一系列电影进行排序。但在第行

中返回此值。与（m）相比我得到一个堆栈溢出错误。我该怎么解决这个问题

 public int compareTo(Movie m) {
            if (this.likes == m.likes) {
                //DefaultComparator cmp = new DefaultComparator();
                return this.compareTo(m);
            } else if (this.likes > m.likes) {
                return 1;
            } else {
                return -1;
            }

        }

        public static Movie[] sort(Movie[] m) {
            if (m == null || m.length == 0) {
                return null;
            } else {
                movies = m;
                quicksort(0, movies.length - 1); // sort the entire array
                return movies;
            }
        }

        public static void quicksort(int left, int right) {
            int i = left;
            int j = right;
            Movie pivot = movies[left + (right - left) / 2];
            while (i <= j) {
                while (movies[i].compareTo(pivot) == -1) {
                    i++;
                }
                while (movies[j].compareTo(pivot) == 1) {
                    j--;
                }
                if (i <= j) {
                    exch(i, j);
                    i++;
                    j--;
                }

            }
            if (left < j) {
                quicksort(left, j);
            }
            if (i < right) {
                quicksort(i, right);
            }
        }

        public static void exch(int i, int j) {
            Movie temp = movies[i];
            movies[i] = movies[j];
            movies[j] = temp;
        }

公共整数比较（电影m）{
if（this.likes==m.likes）{
//DefaultComparator cmp=新的DefaultComparator（）；
返回此。比较到（m）；
}else if（this.likes>m.likes）{
返回1；
}否则{
返回-1；
}
}
公共静态电影[]排序（电影[]m）{
如果（m==null | | m.length==0）{
返回null；
}否则{
电影=m；
快速排序（0，movies.length-1）；//对整个数组进行排序
返回电影；
}
}
公共静态void快速排序（int-left，int-right）{
int i=左；
int j=右；
电影轴=电影[左+（右-左）/2]；
而
如果
this.likes==m.likes
返回true，您将启动一个无限递归循环，毕竟，“this”和“m”在下一次迭代中是相同的，它们的m值也是相同的。这就是您的问题。

if (this.likes == m.likes) {
    return this.compareTo(m);
}

compareTo
递归调用自身，这将导致无限递归，它只能以
StackOverflowerError
结束

如果喜欢的数量相等，您应该决定如何比较这两个
Movie
对象。可以通过
Movie
的另一个属性进行比较，也可以返回
0

if (this.likes == m.likes) {
    return this.compareTo(m);
}