trjhtr

I am working on a rewrite project, where I'm supposed to change the
enhanced for-loop code used in java6 to the newer forEach loop.
Similarly, we have to use Streams API as heavily as possible.

Below is the complete scenario followed by code sample

1. Iterate over each element of List<String> list.


2. If Map<String, A> has each as key, take the corresponding A value from the Map.


3. 
   A has an instance variable, List<B> which is a list of class B objects.


4. If List<B> is null initialize new List<B> and put some value inside it. Else just add a new value to Existing List<B>.

The complete code for the problem is below:

 class A
 List<B> values;

 

 class B

 

 //Assume some values
 List<String> list = ["val1","val2"];
 //Assume some values
 Map<String, A> map = "val1" : [A object] , "val2" : [A object] ;
 B b = new B();

 //Iterate over every value in list
 for(String each: list)
 //if map has a key with the value inside the list
 A a = map.get(each);

 //A has a list called "values" of B class objects. If that list is not null or empty add a new B object (b )in our case to the a List else initialze a new List and add the value there.
 if(a.values != null && !a.values.isEmpty())
 a.values.add(b);
 else
 List<B> bList = new ArrayList<>();
 bList.add(b);
 a.values = bList;
 
 

Regardless of the java version you use, the business logic, which decides whether the object should be added and in which way, is placed in a non-OO programming paradigm. Instead of walking through other objects private parts, just add an appropriate method in the object itself and call that method:

class A 
 List<B> values;

 public void addB(B newVal) 
 if(values != null && !values.isEmpty()) 
 values.add(newVal);
 
 else 
 values = new ArrayList<>();
 values.add(newVal);
 
 

Then, the actual call of the logic is simple and clean, no matter whether you use a loop or a stream:

list.stream()
 .map(key -> map.get(key)) // alternative: map::get
 .forEach(a -> a.addB(b));

or

for(String key : list)
 map.get(key).add(b);

Non sure what is the purpose to write your code in a java 8 way, please explain this part.

I think you mean using streams.

Anyway, here is an example.

Comparing with your code I introduced a filter that guarantee the key in list exists as a key in the map.

The other part are equivalent.

UPDATE: I added the _map_part that I had forgot previously.
The map can transform your list of string in a new list of different types.

In this case you use the list of string as a filter to get elements from the map. You don't want to operate on the String keys, instead you want to access the map values that are objects of type A.

list.stream()
 .filter(key -> (map.containsKey(key)))
 .map(key -> (map.get(key)))
 .forEach(a -> 
 if (a.values == null)
 a.values = new ArrayList<>();

 a.values.add(b);
 );

I think the main difference for this approach, compared with the old fashion is that you describe more your intentions, and the purpose of the code emerges much clearly.

But in trivial examples like yours the differences are not so clear and the functional approach seems much complicated.

Not all the case can be converted properly in this way, there are still cases where you whould prefer the loop over the streams.

Here is you code example. For simplicity, I have removed the object B with String. basically forEach () loop can be use to achieve the same. However, for more complex logic, I would doing it with conventional java for loops to keep the code readable.

list.stream().forEach(val -> A a = map.get(a); if(a.values != null && !a.values.isEmpty())
 a.values.add("new obj");
else
 List<String> bList = new ArrayList<>();
 bList.add("new obj");
 a.values = bList;


);