在Java中按对象获取对象变量值

我有这样的Kvote课程：

public class Kvote {
    private static int counter = 0;
    private double[] vrednost = new double[3];
    private int id; 

    public Kvote(double v1, double v2) {
        super();
        this.vrednost[1] = v1;
        this.vrednost[2] = v2;
        this.id = counter;
        counter++;

    }

    public static int getCounter(){
        return counter;
    }
}

Map<Integer, Kvote> kvotes = new HashMap<>();

// Save it in the Map
Kvote kvote = new Kvote(123D, 213D);
kvotes.put(kvotes.getId(), kvote);

// Retrieve the kvote
Kvote kvote = kvotes.get(123);

我在Main中创建了该类的几个对象：

Kvote k1 = new Kvote(2, 4.25);
Kvote k2 = new Kvote(1.85, 5);
Kvote k3 = new Kvote(1.62, 6.5);
Kvote k4 = new Kvote(1.72, 6);

所以，Kvote类的每个实例都有一些id，k1为0，k2为1，k3为2。。。 是否可以通过对象的id-var值访问对象。例如，如果我请求Id=2的对象，我得到对象k3

我很难解释为什么我需要这个，但我确实需要。基本上，我的alghorytm需要处理无限多的Kvote类对象：k1、k2、k3、k4、k5、k6、k7

试试这个：

HashMap<Integer, Kvote> map = new HashMap<Integer, Kvote>();
put(k1.getId(), k1);
put(k2.getId(), k2);
put(k3.getId(), k3);
put(k4.getId(), k4);

此外，还需要将getId（）函数添加到kNote类中。

尝试以下操作：

HashMap<Integer, Kvote> map = new HashMap<Integer, Kvote>();
put(k1.getId(), k1);
put(k2.getId(), k2);
put(k3.getId(), k3);
put(k4.getId(), k4);

此外，还需要将getId（）函数添加到kNote类中。

尝试以下操作：

HashMap<Integer, Kvote> map = new HashMap<Integer, Kvote>();
put(k1.getId(), k1);
put(k2.getId(), k2);
put(k3.getId(), k3);
put(k4.getId(), k4);

此外，还需要将getId（）函数添加到kNote类中。

尝试以下操作：

HashMap<Integer, Kvote> map = new HashMap<Integer, Kvote>();
put(k1.getId(), k1);
put(k2.getId(), k2);
put(k3.getId(), k3);
put(k4.getId(), k4);

---

此外，您还需要将getId（）函数添加到kNote类。

如果您只是按顺序给它们ID，那么您可以使用ArrayList

List<Kvote> myList = new ArrayList<Kvote>();
myList.add(new Kvote(2, 4.25));
myList.add(new Kvote(1.85, 5));
myList.add(new Kvote(1.62, 6.5));
myList.add(new Kvote(1.72, 6));

---

然而，如果你想对你的ID有更多的灵活性，那么你可以使用地图，正如@RoeyGolzarpoor在他的回答中所建议的那样。

如果你只是按顺序给他们ID，那么你可以使用ArrayList

List<Kvote> myList = new ArrayList<Kvote>();
myList.add(new Kvote(2, 4.25));
myList.add(new Kvote(1.85, 5));
myList.add(new Kvote(1.62, 6.5));
myList.add(new Kvote(1.72, 6));

---

然而，如果你想对你的ID有更多的灵活性，那么你可以使用地图，正如@RoeyGolzarpoor在他的回答中所建议的那样。

如果你只是按顺序给他们ID，那么你可以使用ArrayList

List<Kvote> myList = new ArrayList<Kvote>();
myList.add(new Kvote(2, 4.25));
myList.add(new Kvote(1.85, 5));
myList.add(new Kvote(1.62, 6.5));
myList.add(new Kvote(1.72, 6));

---

然而，如果你想对你的ID有更多的灵活性，那么你可以使用地图，正如@RoeyGolzarpoor在他的回答中所建议的那样。

如果你只是按顺序给他们ID，那么你可以使用ArrayList

List<Kvote> myList = new ArrayList<Kvote>();
myList.add(new Kvote(2, 4.25));
myList.add(new Kvote(1.85, 5));
myList.add(new Kvote(1.62, 6.5));
myList.add(new Kvote(1.72, 6));

---

但是，如果您想在ID是什么方面有更多的灵活性，那么您可以使用map，正如@RoeyGolzarpoor在他的回答中所建议的那样。

a

java.util.map

是支持键值对的最常见的数据结构之一。有多种可用的实现，其中一种是

java.util.HashMap

它的工作原理如下：

public class Kvote {
    private static int counter = 0;
    private double[] vrednost = new double[3];
    private int id; 

    public Kvote(double v1, double v2) {
        super();
        this.vrednost[1] = v1;
        this.vrednost[2] = v2;
        this.id = counter;
        counter++;

    }

    public static int getCounter(){
        return counter;
    }
}

Map<Integer, Kvote> kvotes = new HashMap<>();

// Save it in the Map
Kvote kvote = new Kvote(123D, 213D);
kvotes.put(kvotes.getId(), kvote);

// Retrieve the kvote
Kvote kvote = kvotes.get(123);

---

如果您希望保持添加元素的顺序（出于算法目的），我建议您使用

LinkedHashMap

，它将能够为您记住顺序。

HashMap

不具有顺序。

A

java.util.Map

是支持键值对的最常见的数据结构之一。有多种可用的实现，其中一种是

java.util.HashMap

它的工作原理如下：

public class Kvote {
    private static int counter = 0;
    private double[] vrednost = new double[3];
    private int id; 

    public Kvote(double v1, double v2) {
        super();
        this.vrednost[1] = v1;
        this.vrednost[2] = v2;
        this.id = counter;
        counter++;

    }

    public static int getCounter(){
        return counter;
    }
}

Map<Integer, Kvote> kvotes = new HashMap<>();

// Save it in the Map
Kvote kvote = new Kvote(123D, 213D);
kvotes.put(kvotes.getId(), kvote);

// Retrieve the kvote
Kvote kvote = kvotes.get(123);

---

如果您希望保持添加元素的顺序（出于算法目的），我建议您使用

LinkedHashMap

，它将能够为您记住顺序。

HashMap

不具有顺序。

A

java.util.Map

是支持键值对的最常见的数据结构之一。有多种可用的实现，其中一种是

java.util.HashMap

它的工作原理如下：

public class Kvote {
    private static int counter = 0;
    private double[] vrednost = new double[3];
    private int id; 

    public Kvote(double v1, double v2) {
        super();
        this.vrednost[1] = v1;
        this.vrednost[2] = v2;
        this.id = counter;
        counter++;

    }

    public static int getCounter(){
        return counter;
    }
}

Map<Integer, Kvote> kvotes = new HashMap<>();

// Save it in the Map
Kvote kvote = new Kvote(123D, 213D);
kvotes.put(kvotes.getId(), kvote);

// Retrieve the kvote
Kvote kvote = kvotes.get(123);

---

如果您希望保持添加元素的顺序（出于算法目的），我建议您使用

LinkedHashMap

，它将能够为您记住顺序。

HashMap

不具有顺序。

A

java.util.Map

是支持键值对的最常见的数据结构之一。有多种可用的实现，其中一种是

java.util.HashMap

它的工作原理如下：

public class Kvote {
    private static int counter = 0;
    private double[] vrednost = new double[3];
    private int id; 

    public Kvote(double v1, double v2) {
        super();
        this.vrednost[1] = v1;
        this.vrednost[2] = v2;
        this.id = counter;
        counter++;

    }

    public static int getCounter(){
        return counter;
    }
}

Map<Integer, Kvote> kvotes = new HashMap<>();

// Save it in the Map
Kvote kvote = new Kvote(123D, 213D);
kvotes.put(kvotes.getId(), kvote);

// Retrieve the kvote
Kvote kvote = kvotes.get(123);

---

如果您希望保持添加元素的顺序（出于算法目的），我建议您使用

LinkedHashMap

，它将能够为您记住顺序。

HashMap

不符合顺序。

我不确定您想要的结果是什么，虽然Roey的map解决方案很好，但我要补充的是，与其在类内设置计数器，不如在类外设置一个计数器，并将其值传递给构造函数，以便在实例化内设置id值：

public class Kvote {

private double[] vrednost = new double[2];
private int id; 

public Kvote(double v1, double v2, int id) {
    this.vrednost[0] = v1;
    this.vrednost[1] = v2;
    this.id = id;
}

public static int getId(){
    return this.id;
}
}

在主要类别中：

int counter = 0;

Kvote k1 = new Kvote(2, 4.25, counter++);
Kvote k2 = new Kvote(1.85, 5, counter++);
Kvote k3 = new Kvote(1.62, 6.5, counter++);
Kvote k4 = new Kvote(1.72, 6, counter++);

---

然后将它们放在映射中。

我不确定您想要的结果是什么，虽然Roey的映射解决方案很好，但我要补充的是，与其在类内设置计数器，不如在类外设置计数器，并将其值传递给构造函数，以在实例化内设置id值：

public class Kvote {

private double[] vrednost = new double[2];
private int id; 

public Kvote(double v1, double v2, int id) {
    this.vrednost[0] = v1;
    this.vrednost[1] = v2;
    this.id = id;
}

public static int getId(){
    return this.id;
}
}

在主要类别中：

int counter = 0;

Kvote k1 = new Kvote(2, 4.25, counter++);
Kvote k2 = new Kvote(1.85, 5, counter++);
Kvote k3 = new Kvote(1.62, 6.5, counter++);
Kvote k4 = new Kvote(1.72, 6, counter++);

---

然后将它们放在映射中。

我不确定您想要的结果是什么，虽然Roey的映射解决方案很好，但我要补充的是，与其在类内设置计数器，不如在类外设置计数器，并将其值传递给构造函数，以在实例化内设置id值：

public class Kvote {

private double[] vrednost = new double[2];
private int id; 

public Kvote(double v1, double v2, int id) {
    this.vrednost[0] = v1;
    this.vrednost[1] = v2;
    this.id = id;
}

public static int getId(){
    return this.id;
}
}

在主要类别中：

int counter = 0;

Kvote k1 = new Kvote(2, 4.25, counter++);
Kvote k2 = new Kvote(1.85, 5, counter++);
Kvote k3 = new Kvote(1.62, 6.5, counter++);
Kvote k4 = new Kvote(1.72, 6, counter++);

---

然后将它们放在映射中。

我不确定您想要的结果是什么，虽然Roey的映射解决方案很好，但我要补充的是，与其在类内设置计数器，不如在类外设置计数器，并将其值传递给构造函数，以在实例化内设置id值：

public class Kvote {

private double[] vrednost = new double[2];
private int id; 

public Kvote(double v1, double v2, int id) {
    this.vrednost[0] = v1;
    this.vrednost[1] = v2;
    this.id = id;
}

public static int getId(){
    return this.id;
}
}

在主要类别中：

int counter = 0;

Kvote k1 = new Kvote(2, 4.25, counter++);
Kvote k2 = new Kvote(1.85, 5, counter++);
Kvote k3 = new Kvote(1.62, 6.5, counter++);
Kvote k4 = new Kvote(1.72, 6, counter++);

---

然后将它们放入地图。

尝试使用id作为键将项目添加到地图中，请参见下面的答案。谢谢。尝试使用id作为键将项目添加到地图，请参见下面的答案。谢谢。尝试使用id作为键将项目添加到地图，请参见下面的答案。谢谢。尝试使用id作为键将项目添加到地图，请参见下面的答案。非常感谢。