Question

我是Java的新手，我想存储一对双打的数组。我的代码如下所示：

import java.util.ArrayList;
import java.util.Map.Entry;

List<Entry<Double, Double>> values = new ArrayList<>();
Entry<Double, Double> pair;
// set pair values:
// pair.setKey(0.5); // this method does not exists
// pair.setValue(3.6);
values.add(pair);

如何初始化pair变量？是否有更好的结构来存储我的双打数组？

Answer 1

创建自己的类来表示一对，并添加一个带有两个参数的构造函数：

public class MyPair
{
    private final Double key;
    private final Double value;

    public MyPair(Double aKey, Double aValue)
    {
        key   = aKey;
        value = aValue;
    }

    public Double key()   { return key; }
    public Double value() { return value; }
}

请参阅此答案，了解Java中不存在Pair的原因：What is the equivalent of the C++ Pair<L,R> in Java?

Answer 2

你不想使用Entry这是一个INTERFACE，而不是CLASS。当您在实现Map的类上调用entrySet（）时，该接口由Set的实现使用。它基本上允许您操作已实现的Map，就好像它是一个Set。

你会做什么（但不能）就是这样。如果您尝试这样做，您将看到编译器错误的行“无法实例化Map.Entry类型”。那是因为Map.Entry是一个接口，而不是一个类。接口不包含任何实际代码，因此这里没有真正的构造函数。

Entry<Double, Double> pair = new Entry<Double, Double>();

如果你看下面的文档，你可以在顶部清楚地看到它是一个“Interface Map.Entry”，这意味着它是一个界面。 http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Map.Entry.html

你应该做什么而不是试图实例化一个接口，这是不可能的，就是创建你自己的一个名为Pair的类。像这样的东西。如果您使用以下代码，请记得更改包。

package org.mike.test;

public class Pair {
    private double x = 0.0;
    private double y = 0.0;

    public Pair(double x, double y)
    {
        this.x = x;
        this.y = y;
    }

    public Pair()
    {

    }

    public double getX() {
        return x;
    }

    public void setX(double x) {
        this.x = x;
    }

    public double getY() {
        return y;
    }

    public void setY(double y) {
        this.y = y;
    }


}

编写Pair类后，您的代码现在看起来像这样。

package org.mike.test;

import java.util.ArrayList;
import org.mike.test.Pair; //You don't need this if the Pair class is in the same package as the class using it

public class tester {

    /**
     * @param args
     */
    public static void main(String[] args) {
        ArrayList<Pair> values = new ArrayList<Pair>();
        Pair pair = new Pair();
        // set pair values:
        pair.setY(3.6);
        pair.setX(3.6);
        values.add(pair);
    }

}

Answer 3

你能不能只使用

public class MyClass<A,B> extends ArrayList{
private A first;
private B second;
public MyClass(A first, B second){
super();
this.first = first;
this.second = second;}
}

然后添加某种形式的添加方法，以及第一和第二访问者＆amp;变异法？我对编程很新，但这种方式似乎可以工作，除了DOUBLE之外的其他东西都可以访问（如果你想要使用其他类型的话，比如Integer，甚至String）

Answer 4

您可以使用地图来解决此问题。

Answer 5

Entry是您定义的课程吗？您使用new实例化它。

Entry<Double, Double> pair = new Entry<Double, Double>(d1, d2);

注意我假设你定义了一个带2个双精度的构造函数，并且你有d1和d2的引用。

我建议你不要使用Map.Entry课程。该类的语义是这样的，值是一个键和一个值，适合地图的工作方式。

Answer 6

如果您有权访问Entry类，则可以创建一个以键和值为参数的构造函数。

Entry<Double, Double> pair = new Entry<Double, Double>(0.5, 3.6);
values.add(pair);

Answer 7

您尝试使用的Map.Entry类型只是一个接口，因此无法实例化。如果您想（错误地）使用Map的内部类型，那么具体的Map.Entry实现HashEntry将是一个选项。

然而，实现自己的Pair类型是一个更好的主意。或者如果适合您需要使用Map而不是数组。

Answer 8

另一种方法，也许是存储和双对数组的最有效方法是使用单个双精度数组，并使用（2 * i）和（2 * i + 1）作为索引方案。此外，您还可以获得在创建阵列时将阵列初始化为全0的优势，无需额外步骤。不幸的是，实现add（）和remove（）会有一些额外的编码开销，但令人惊讶的是，它可能不会为该对创建自己的容器类。

class MyClass {
    double[] values;
    int count;

    MyClass(int initialCapacity) {
        values = new double[initialCapacity*2];
    }

    // adding a pair
    void addPair(double x, double y) {
        if (count*2 >= values.length) {
            values = Arrays.copyOf(values, values.length*2);
        }
        values[count*2] = x;
        values[count*2 + 1] = y;
        count++;
    }

    void remove(int index) {
        if (index >= count) throw new IndexOutOfBoundsException();

        if (index < --count) {
            System.arraycopy(values, (index+1)*2, values, index*2, (count - index) * 2);
        }
    }

    int size() { return count; }

    // both these should check that index < count.
    double getX(int index) { return values[index*2]; }
    double getY(int index) { return values[index*2 + 1]; }

    void exampleIteration() {
        // getX/Y accessors are examples of how to get
        // the values, but it will be more efficient
        // in most cases to just access the array
        // array directly as so...
        for (int i=0 ; i<count ; ++i) {
            System.out.printf("%d: (%f,%f)%n", i, values[i*2], values[i*2+1]);
        }
    }
}

Answer 9

对于有人参与竞争性编程或编码面试问题的人，您可能需要将所有代码写在一个文件/编辑器窗口中

在这种情况下，您可以使用内部类方便地配对然后将该类的对象配对使用

如果要创建一个成对的堆栈，可以创建一个成对对象并将其放入堆栈中

import java.util.*;
public class PairArray
{
    static class Pair{
        int a,b;
        Pair(int a,int b){
            this.a=a;
            this.b=b;
        }
    }
    static void main()
    {
        int a,b,l=10;
        Scanner sc = new Scanner(System.in);
        Pair array[]= new Pair[l];
        for(int i=0;i<l;i++){
           a=sc.nextInt();
           b=sc.nextInt();
           array[i]=new Pair(a,b);
        }
        for(int i=0;i<l;i++){
           System.out.println(array[i].a+" "+array[i].b);
        }

    }
}

Answer 10

请在下面找到给出数组中可用对数的程序。

int getPairsCount(int n, int[] arr) {

    HashMap<Integer, Integer> hm = new HashMap<>();

    for (int i = 0; i < arr.length; i++) {
        if (hm.containsKey(arr[i])) {
            hm.replace(arr[i], hm.get(arr[i]) + 1);
        } else {
            hm.put(arr[i], 1);
        }
    }

    int sum = 0;
    for (Map.Entry<Integer, Integer> hmm : hm.entrySet()) {
        if (hmm.getValue() / 2 > 0) {
            sum += (hmm.getValue() / 2);
        }
    }
    return sum;
}

如何在Java中存储一对数组？

10 个答案: