Java 如何在变量中存储可比较的元素？

我写了一个程序，我必须写出快速排序的代码。我使用的是一个可比较的[]数组。为了交换数组的两个元素，我必须在一个变量中存储一个元素。通常，对于字符串数组，我可以将元素存储在字符串变量中，但不允许将值存储在具有可比较数组的字符串变量中。如何将此可比较数组中的一个元素存储在此数组之外，以便交换这两个元素？这就是我的程序看起来的样子，我被卡住的部分没有代码

import java.io.*;

public class QuickSort{
public static void main (String args[]) {       
    Comparable[] q = Read();
    int l = 0; 
    int x = q.length-1;
    QSortr(q, l, x);
    PrintFxn(q);
}

public static Comparable[] Read() {
String hold[] = new String[1000];
int numin=0;
try{
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        String s; 
        s=br.readLine();
        while (s!=null&& !s.equals("")) {
            hold[numin]= s;
            numin++;
            s=br.readLine();
        }
        br.close();

    } catch (Exception e) {System.out.println("Ack!:" + e); }
    Comparable q[] = new String[numin];
    for(int a=0; a<numin; a++) {
        q[a] = hold[a];
    }
    return q; }

public static int QSort( Comparable q[], int l, int x) {
    int r = l +1;
    int m= l;
    int k = l;

while(r<q.length-1){
    if( q[r].compareTo(q[k])<=0){
        m++; r++;  }
    else{ 
        while(q[r].compareTo(q[k])>0&&r<q.length-1){
            r++; }
        m++; 
         //This is where i'm stuck...
        q[r] = q[m];
        q[m] = a[0]; }
    }
    return m;}
public static Comparable [] QSortr(Comparable q [], int l, int x) {
    while(l<x) {
        int a = QSort(q, l, x);
        QSortr(q, l, a-1);
        QSortr(q, a+1, x); }
    return q; }

public static void PrintFxn(Comparable[] q) {
    for(int a=0; a<q.length; a++) {
    System.out.println(q[a]); }
}
}

import java.io.*；
公共类快速排序{
公共静态void main（字符串args[]）{
可比[]q=Read（）；
int l=0；
int x=q.length-1；
QSortr（q，l，x）；
PrintFxn（q）；
}
公共静态可比[]读取（）{
字符串保持[]=新字符串[1000]；
int numin=0；
试一试{
BufferedReader br=新的BufferedReader（新的InputStreamReader（System.in））；
字符串s；
s=br.readLine（）；
而（s！=null&&！s.equals（“”）{
保持[numin]=s；
numin++；
s=br.readLine（）；
}
br.close（）；
}catch（异常e）{System.out.println（“Ack！：”+e）；}
可比q[]=新字符串[numin]；
对于（int a=0；a来说，这种“就地”快速排序的实现有许多错误之处，其中一个是条件：
而（rx
）。另一个问题是在QSort中根本不使用
x
（右边界）。
检查以下的实现——即使是在Ruby中——很容易理解：主要思想是使用两个指针运行——一个从右到左，另一个从左到右，当它们相互交叉时停止，但在运行时检查是否有元素小于pivot右侧的pivot，以及大于pivot左侧的pivot of pivot-并在它们之间切换。
也许我太密集了，但不能仅仅使用，呃，使用一个可比的？这正是我想知道的，这是可能的/允许的/合乎逻辑的吗？谢谢你对第一部分的帮助。但是，我的老师希望我们使用这种分区方法，因为它需要更少的代码。右边界基本上是存在的，只是作为一个例子n端点。我们确实学习了这两种类型，但他认为这更好。“就地”版本并不是“更少的代码”-它使用更少的内存空间，因为所有操作都是在数组本身上执行的，而无需复制它。