从val返回farthestK:Can'；不能导入除java.util.Array以外的任何内容

需要返回k个元素a[i]，使得ABS（a[i]-val）是k个最大的求值。我的代码只适用于大于val的整数。如果整数小于val，它将失败。我可以在不导入java.util.array以外的任何内容的情况下执行此操作吗？任何帮助都将不胜感激

import java.util.Arrays;

public final class Selector {

private Selector() {
 } 
public static int[] farthestK(int[] a, int val, int k) {// This line should not change                  
  int[] b = new int[a.length];
  for (int i = 0; i < b.length; i++) {
     b[i] = Math.abs(a[i] - val);
  }
  Arrays.sort(b);
  int[] c = new int[k];
  int w = 0;
  for (int i = b.length-1; i > b.length-k-1; i--) {       
     c[w] = b[i] + val;
     w++;     
  }
  return c;    
}

导入java.util.array；
公共最终类选择器{
私有选择器（）{
} 
公共静态int[]farthestK（int[]a，int-val，int-k）{//此行不应更改
int[]b=新的int[a.长度]；
for（int i=0；ib.length-k-1；i--）{
c[w]=b[i]+val；
w++；
}
返回c；
}

测试用例：

import org.junit.Assert;
import static org.junit.Assert.*;
import org.junit.Before;
import org.junit.Test;


public class SelectorTest {


 /** Fixture initialization (common initialization
  *  for all tests). **/
 @Before public void setUp() {
 }
  @Test public void farthestKTest() {
       int[] a = {-2, 4, -6, 7, 8, 13, 15};
       int[] expected = {15, -6, 13, -2};
       int[] actual = Selector.farthestK(a, 4, 4);
       Assert.assertArrayEquals(expected, actual);
     }
 }

 There was 1 failure:
 1) farthestKTest(SelectorTest)
 arrays first differed at element [1]; expected:<-6> but was:<13>
 FAILURES!!!
 Tests run: 1,  Failures: 1

import org.junit.Assert；
导入静态org.junit.Assert.*；
导入org.junit.Before；
导入org.junit.Test；
公共类选择器测试{
/**夹具初始化（公共初始化）
*对于所有测试）**/
@在公共作废设置（）之前{
}
@测试公共空间farthestKTest（）{
int[]a={-2,4,6,7,8,13,15}；
int[]应为{15，-6,13，-2}；
int[]实际值=选择器.farthestK（a，4，4）；
Assert.assertArrayEquals（预期、实际）；
}
}
有1次失败：
1） 最远测试（选择或测试）
数组首先在元素[1]处不同；应为：但为：
失败！！！
测试运行：1，失败：1

通过将距离存储为绝对值，您将破坏最后一个for循环，该循环将根据abs值重新计算原始值

使用使用abs值进行比较的比较器，但将数组值与搜索值的差值存储在数组b中，怎么样

这里是这样的：

public static int[] farthestK(int[] a, int val, int k) {// This line should not change
    Integer[] b = new Integer[a.length];
    for (int i = 0; i < b.length; i++) {
      b[i] = a[i] - val;
    }
    Arrays.sort(b, new Comparator<Integer>() {

      @Override
      public int compare(Integer arg0, Integer arg1) {
        return Integer.valueOf(Math.abs(arg0)).compareTo(Math.abs(arg1));
      }
    });
    int[] c = new int[k];
    int w = 0;
    for (int i = b.length - 1; i > b.length - k - 1; i--) {
      c[w] = b[i] + val;
      w++;
    }
    return c;
  }

public static int[]farthestK（int[]a，int-val，int-k）{//此行不应更改
整数[]b=新整数[a.length]；
for（int i=0；ib.length-k-1；i--）{
c[w]=b[i]+val；
w++；
}
返回c；
}

通过将距离存储为绝对值，您将破坏最后一个for循环，该循环将根据abs值重新计算原始值

使用使用abs值进行比较的比较器，但将数组值与搜索值的差值存储在数组b中，怎么样

这里是这样的：

public static int[] farthestK(int[] a, int val, int k) {// This line should not change
    Integer[] b = new Integer[a.length];
    for (int i = 0; i < b.length; i++) {
      b[i] = a[i] - val;
    }
    Arrays.sort(b, new Comparator<Integer>() {

      @Override
      public int compare(Integer arg0, Integer arg1) {
        return Integer.valueOf(Math.abs(arg0)).compareTo(Math.abs(arg1));
      }
    });
    int[] c = new int[k];
    int w = 0;
    for (int i = b.length - 1; i > b.length - k - 1; i--) {
      c[w] = b[i] + val;
      w++;
    }
    return c;
  }

public static int[]farthestK（int[]a，int-val，int-k）{//此行不应更改
整数[]b=新整数[a.length]；
for（int i=0；ib.length-k-1；i--）{
c[w]=b[i]+val；
w++；
}
返回c；
}

ABS（a[i]-val）

这是您的排序标准，因此您需要实现一个将其应用于要比较的两个值的方法，并返回两个结果值的比较结果

public static int[] farthestK(int[] a, int val, int k) {
    // copy into an array of non primitive integers 
    // for using in the sort method
    Integer[] b = new Integer[a.length];
    for(int i = 0; i < a.length; i++) {
        b[i] = a[i];
    }

    final int v = val; // make val final for access in anonymous class
    Arrays.sort(b, new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            int v1 = Math.abs(o1.intValue() - v);
            int v2 = Math.abs(o2.intValue() - v);
            return - (v1 - v2); // return inverted result of comparison
                                // for convenient copying later
                                // or just (v2 - v1)
        }
    });

    // copy first k elements
    int[] c = new int[k];
    for(int i = 0; i < k; i++) {
        c[i] = b[i];
    }
    return c;
}

基本上，你甚至可以自己做所有的复制，甚至可以摆脱导入

还请注意，实际上并不需要对mersort的所有左数组和右数组进行所有复制。只需要一个与原始数组长度相同的新数组，并使用开始/结束索引来标识左数组和右数组

ABS（a[i]-val）

这是您的排序标准，因此您需要实现一个将其应用于要比较的两个值的方法，并返回两个结果值的比较结果

public static int[] farthestK(int[] a, int val, int k) {
    // copy into an array of non primitive integers 
    // for using in the sort method
    Integer[] b = new Integer[a.length];
    for(int i = 0; i < a.length; i++) {
        b[i] = a[i];
    }

    final int v = val; // make val final for access in anonymous class
    Arrays.sort(b, new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            int v1 = Math.abs(o1.intValue() - v);
            int v2 = Math.abs(o2.intValue() - v);
            return - (v1 - v2); // return inverted result of comparison
                                // for convenient copying later
                                // or just (v2 - v1)
        }
    });

    // copy first k elements
    int[] c = new int[k];
    for(int i = 0; i < k; i++) {
        c[i] = b[i];
    }
    return c;
}

基本上，你甚至可以自己做所有的复制，甚至可以摆脱导入

---

还要注意的是，实际上并不需要对mersort的所有左数组和右数组进行所有复制。您只需要一个与原始数组长度相同的新数组，并使用开始/结束索引来标识左数组和右数组。

好吧，因为您只能使用数组，也许您可以使用DSU模式（装饰-排序-取消装饰）。我不太熟悉在Java中这样做，但我认为您也必须实现一个自定义比较器。这可能是太多的工作了。因为您只能使用数组，也许您可以使用DSU模式（装饰-排序-取消装饰）。我不太熟悉在Java中这样做，但我想你也必须实现一个自定义比较器。可能工作量太大。当我测试上面的测试用例时，它报告：SelectorTest.Java:48:error:class Selector中的方法farthestK无法应用于给定的类型；int[]actual=Selector.farthestK（a，4，4）；^必需：整数[]，int，找到的int:int[]，int，int原因：实际参数int[]无法转换为整数[]by method invocation conversion 1 Error您没有为SelectorTest类提供代码。我使用您提供的方法进行了测试。但是，您的farthestK方法签名表示您正在传入一个整数[]，而我编写的代码示例需要整数[]。我只是使用整数[]内部原因是这使得使用比较器进行排序更容易。我更新了我的SelectorTest.java代码。请检查它！谢谢！这段代码为我运行，只是从上面复制了代码和您的测试用例。工作起来很有魅力。尝试重建类/刷新您的IDE。当我测试上面的测试用例时，它报告：SelectorTest.java:48:error:methodod类选择器中的farthestK