使用地图界面在类的实现的“结构”中查找值

Question

Im a beginner in Java, I am trying to implement a struct like data structure in Java using classes and I want to look for a match in that...This question might have been asked before, but Im not able to find it. Please help. The code is as follows:

public class operations extends DefFunctionHandler {  

public Integer stream;  
public Integer funct;  
public String name;  
public Integer funcgroup;  
public Integer source;  
}  
 //in another class
 public void execute(String x) {  

 List<operations> oplist = new ArrayList<operations>();  
 operations op = new operations();  

 for(int i=0; i< functi.size();i++){  
     op.stream = str.get(i);  
     op.funct = functi.get(i);  
     op.funcgroup = functigroup.get(i);  
     op.name = nme.get(i);  
     op.source = src.get(i);  

}  

 oplist.add(op);
 Map<String, List<operations>> map = new HashMap<String, List<operations>>();

 map.put(x, oplist);
 List<operations> ope = map.get(x);
 for (Map.Entry<String, List<operations>> entry : map.entrySet()) {
      String key = entry.getKey();
      List<operations> value = entry.getValue();
      System.out.println(value);
    } 

} 

As seen, I have a class operations , in which I have various fields. In another method called execute , I add values into those fields in the form of array. Now I get an input from the user for name , I want to search for it in the class/struct implementation and return the corresponding value for stream to the user. I understand that I have to implement a Map interface, but how do I do it? When I try to print value , I get otf.operations@3934f69a Is my implementation of Map Interface and get method correct? Im confused. Please help.

EDIT The code for the execute method now looks like this

 public void execute(String x) {

    Map<String,Operations> obs = new HashMap<String,Operations>();  

    for(int i=0; i< functi.size();i++){
        Operations op = new Operations();
        op.stream = str.get(i);
        op.funct = functi.get(i);
        op.funcgroup = functigroup.get(i);
        op.name = nme.get(i);
        op.source = src.get(i);

        obs.put(op.name, op);       

}
    System.out.println(obs.get(x));

}

Answer 1

You are trying to print a list:

System.out.println(value)

where value is a List<operations> . What you would like to do is to print the values of that list. Then do something like:

for (operations o : value) {
    System.out.println(o.stream);
    System.out.println(o.name);
}

EDIT the code you need:

public void execute(String x) {


      ArrayList<operations> ops= new ArrayList<operations>();
      for(int i=0; i< functi.size();i++) {
         operations op = new operations();
         op.stream = str.get(i);
         op.funct = functi.get(i);
         op.funcgroup = functigroup.get(i);
         op.name = nme.get(i);
         op.source = src.get(i);
         ops.add(op);
      }


     Map<String,ArrayList<operations>> map = new HashMap<String, ArrayList<operations>>();
     map.put(x, ops);

     for (operations operation : map.get(x)) {
         System.out.println(operation.name);
     }

}

Answer 2

First of all value is List<Operations> , so to iterate over each, you can do

for(Operations o : value) {
   System.out.println(o);
}

If you get a chance to see the implementation of System.out.printlin(object) , it will print object.toString()

So otf.operations@3934f69a is the string returned by the method toString() which is by default inherited from java.lang.Object class (since all classes implicitly extend Object ). The toString() of java.lang.Object looks like this

public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

to change this behavior, in your Operations class, you need to override toString() method

class Operations {

  @Overrides
  public String toString() {
     return name;
  }

}

Answer 3

A map can be thought of as a list with labels on each of the items, so that you can easily find an item in the list by its label. What is the label? Well, in the context of Java it is called a key, and can be many types. Most times it is a String, but it can also be any object which implements equals(Object obj) and hashCode() properly (which String already does).

Lets see how you would insert objects into a list:

List<operations> list = new ArrayList<operations>();
for(int i=0; i functi.size(); i++) {
  operations op = new operations();
  op.stream = str.get(i);  
  op.funct = functi.get(i);  
  op.funcgroup = functigroup.get(i);  
  op.name = nme.get(i);  
  op.source = src.get(i);

  list.add(op);   
}

Notice here that inside the loop , I am calling new operations and then I am adding it to the list. This is because I want to create a new instance of operations and add it to the list for each potential operation I can create.

What would happen if I used the same instance? I would set its members again and again with different values, and insert that same instance into the list (yes, a list can contain the same instance many times over). What it would seem like is that you inserted a list containing operations all with the same value (which happen to coincide with the last operation). This is because when you set the property of an instance, all references to the same instance get changed as well (think pointers). So, in other words, be sure to create a new instance each time (You don't have to worry about deleting it later. That gets done automatically).

In order to use a map, you only have to change the logic ever so slightly. Rather than call add, you use put, and you must provide its key. When you need it later, you must provide its key rather than its number. Here is how you would add it to a map:

Map<String, operations> map = new HashMap<String, operations>();
for(int i=0; i functi.size(); i++) {
  operations op = new operations();
  op.stream = str.get(i);  
  op.funct = functi.get(i);  
  op.funcgroup = functigroup.get(i);  
  op.name = nme.get(i);  
  op.source = src.get(i);

  map.put(op.name, op);   
}

Later, to retrieve a value, I only have to do map.get("juggling") , and if it exists in the map, it will give me that particular instance of operations , otherwise it will give me null .

You should note several things here:

• In this way, operations with duplicate names are overridden . If you have no duplicates, there is no problem. Otherwise, you may consider making your key more specific or making your map hold a List of operations instances (on first put for that key, you must create the list instance and add it to the map).
• This approach is ideal if you access only with its key. If you want to also access it as a list, you should prefer LinkedHashMap instead of HashMap (don't use unless you think you will require both, as it is slightly more expensive, but it maintains insertion order).

Also, a couple best practice notes:

• Consider adding setters and getters to operations . It may not help you in this particular program, but it is best practice and will help you in other programs without a doubt.
• Java class names start with a capital letter normally. Method names and member names are camelCase.
• You usually do not make Java class names "plural" unless it is a container of some sort. In other words, I would expect a single operation to be called Operation , and a list of Operation instances to be called Operations .

Hope that helps!

Answer 4

Some advice:

As you named it "struct" I guess you come from C. In Java you just have to create a "bean" which is an object which only has getters and setters (the attributes are usually declared as private so you'll need a getX() and setX(value) methods to access and modify them). That's your "operations" class, more or less.

Class names always start with capital letters (Java convention).

if you need to find quickly a bean/struct by a value, then store it in a Map:

Map<String, operations> map = new HashMap<String, operations>();
map.put(myOperation.getName(),myOperation);

Then, you can obtain that bean just writing map.get(name).

Last thing, you have to implement the method toString() in any object you want write easily

EDIT: I think you don't need a list, just put directly each element in a map and remove the list, something like:

Map<String,operations> oplist = new HashMap<String,Operations>();  
 operations op = new operations();  

 for(int i=0; i< functi.size();i++){  
     op.stream = str.get(i);  
     op.funct = functi.get(i);  
     op.funcgroup = functigroup.get(i);  
     op.name = nme.get(i);  
     op.source = src.get(i);
     oplist.put(op.name,op);  //You forgot this! it must be in the loop

}  

Then you can find any operation by name (I'm supposing name is unique)