Performing Integers operation on List

Question

I have a List of Objects which I want to convert to a List of Integers

List<Object> list = new ArrayList<>();

list.add("StringTest");
list.add(10);
list.add(5.9);
list.add(2.5f);
list.add(12L);
...            // different datatypes

List<Integer> result = new ArrayList<>();
// convert items from list and add to result

What could be a good custom implementation to add values from different datatypes of List<Object> to a List<Integer>

Strings may be appended based on their length.
Floating numbers needs to be rounded

I know standard implmentation on How to cast an Object to an int in java? but I am looking for a good structure to write a generic one.

It sounds like you already have a plan for how to implement it. Are you stuck on something? — 4castle, May 05 '17 at 05:53
It seems like Java 8 has a sneaky way of using streams to handle type conversion. Initially, I was thinking of writing method that can handle different `instanceof` operations. — Devendra Lattu, May 05 '17 at 06:11

Arthur Kushner · Answer 1 · 2017-05-05T06:25:04.467

2

If you want to add just numbers and don't process strings, than you can use this:

   List<Object> list = new ArrayList<>();

    list.add("StringTest");
    list.add(10);
    list.add(5.9);
    list.add(2.5f);
    list.add(12L);

    List<Integer> result = new ArrayList<>();

     list.stream().filter(element -> element instanceof Number)
            .map(Number.class::cast)
            .mapToDouble(Number::doubleValue)
            .mapToLong(Math::round)
            .mapToInt(Math::toIntExact) // can throw ArithmeticException if long value overflows an int
            .forEach(result::add);

If you also want to process string, than you need to replace string in list with int values of there length and then process as mentioned above.

edited May 05 '17 at 06:25

answered May 05 '17 at 05:56

Arthur Kushner

99
4

Good one Arthur. That's why I was thinking of a custom implementation where I can `round` the floating point numbers to the `nearest value`. – Devendra Lattu May 05 '17 at 06:02
Thank you for your code @Arthur. I wish I could accept multiple answers on SO. – Devendra Lattu May 05 '17 at 06:20

Vasu · Accepted Answer · 2017-05-05T06:24:42.113

2

You can use streams to process the list of Object types as shown in the below code (follow the comments):

//Collect all Number types to ints
List<Integer> output1 = list.stream().
    filter(val -> !(val instanceof String)).//filter non-String types
    map(val -> ((Number)val).floatValue()).//convert to Number & get float value
    map(val -> (int)Math.round(val)).//apply Math.round
    collect(Collectors.toList());//collect as List

//Collect all String types to int
List<Integer> output2 = list.stream().
      filter(val -> (val instanceof String)).//filter String types
       map(val -> (((String)val).length())).//get String lengths
       collect(Collectors.toList());//collect as List

//Now, merge both the lists
output2.addAll(output1);

Floating numbers needs to be rounded

You need to first convert the Number value to float using floatValue() method and then apply Math.round as shown above.

edited May 05 '17 at 06:24

answered May 05 '17 at 06:02

Vasu

21,832
11
51
67

Looks awesome. However, could you please tell me if I can use `Math.round` on this to the nearest decimal value? – Devendra Lattu May 05 '17 at 06:07
I have updated the code, have a look to use `Math.round` – Vasu May 05 '17 at 06:14
1

Thanks @javaguy for the code and explanation (comments). `streams` are powerful and I should start using them. – Devendra Lattu May 05 '17 at 06:19
yes, you are right, they are very powerful i.e., they provide clean/simpler code to process the data – Vasu May 05 '17 at 06:20

score 1 · Answer 3 · answered May 05 '17 at 06:20

The instanceof operator would make this relatively simple.

public class Convert {
    public static int toInt(Object o) {
        if (o instanceof String) {
            return ((String)o).length();
        } else if (o instanceof Number) {
            return Math.round(((Number)o).floatValue());
        } else {
            return o.hashCode(); // or throw an exception
        }
    }
}

With Java 8, you could convert the values with a Stream.

List<Object> list = new ArrayList<>();

list.add("StringTest");
list.add(10);
list.add(5.9);
list.add(2.5f);
list.add(12L);

List<Integer> result = list.stream().map(Convert::toInt).collect(Collectors.toList());

score 0 · Answer 4 · answered May 05 '17 at 06:14

With this you can add to the Integer list at the same time when you add to the object list

final List<Integer> integerList=new ArrayList<Integer>();
List<Object> list=new ArrayList<Object>(){

  public boolean add(Object e) {
    if(e instanceof String){
      integerList.add(((String)e).length());
    }
    if (e instanceof Float){
      integerList.add(Math.round((float) e));
    }
    else{
      // other cases
    }
    return super.add(e);
  };
};
list.add("StringTest");
list.add(10);
list.add(5.9);
list.add(2.5f);
list.add(12L);

Performing Integers operation on List

4 Answers4