Are there any more elegant ways of handling lists in Java ? (Python VS Java)

Question

I do like the way I can treat lists in Python. It does any recursion solution to look easy and clean. For instance the typical problem of getting all the permutations of elements in a list, in Python looks like:

def permutation_recursion(numbers,sol):
    if not numbers:
        print "this is a permutation", sol
    for i in range(len(numbers)):
        permutation_recursion(numbers[:i] + numbers[i+1:], sol + [numbers[i]])

def get_permutations(numbers):
    permutation_recursion(numbers,list())

if __name__ == "__main__":
    get_permutations([1,2,3])

I do like the way I can simple get new instances of modified lists by doing things like numbers[:i] + numbers[i+1:] or sol + [numbers[i]]

If I try to code exactly the same in Java, it looks like:

import java.util.ArrayList;
import java.util.Arrays;

class rec {
    static void permutation_recursion(ArrayList<Integer> numbers, ArrayList<Integer> sol) {
       if (numbers.size() == 0)
            System.out.println("permutation="+Arrays.toString(sol.toArray()));
       for(int i=0;i<numbers.size();i++) {
             int n = numbers.get(i);

             ArrayList<Integer> remaining = new ArrayList<Integer>(numbers);
             remaining.remove(i);

             ArrayList<Integer> sol_rec = new ArrayList<Integer>(sol);
             sol_rec.add(n);

             permutation_recursion(remaining,sol_rec);
       }
    }
    static void get_permutation(ArrayList<Integer> numbers) {
        permutation_recursion(numbers,new ArrayList<Integer>());
    }
    public static void main(String args[]) {
        Integer[] numbers = {1,2,3};
        get_permutation(new ArrayList<Integer>(Arrays.asList(numbers)));
    }
}

To create the same recursion I need to do :

ArrayList<Integer> remaining = new ArrayList<Integer>(numbers);
remaining.remove(i);

ArrayList<Integer> sol_rec = new ArrayList<Integer>(sol);
sol_rec.add(n);

Which is quite ugly and it gets worse for more complex solutions. Like in this example

So my question is ... are there any buil-in operators or helper functions in the Java API that would make this solution more "Pythonic" ?

The `more` in the title is superfluous - the question should be are there any neat way to work with lists in Java whatsoever. And afaik, no - there is none. — Nas Banov, Feb 04 '11 at 00:29

score 8 · Accepted Answer · answered Jan 11 '11 at 20:14

8

No.

But this is why Martin Odersky created Scala. He's even said that one of his goals for Scala is that it be the Python of the Java world. Scala compiles to Java bytecode and easily interops with Java compiled classes.

If that's not an option, you could take a look at the Commons Collection Library.

answered Jan 11 '11 at 20:14

sblundy

60,628
22
121
123

4

I would argue that Jython is the Python of the Java world ;-). – Michael Barker Jan 11 '11 at 20:18

score 2 · Answer 2 · answered Jan 11 '11 at 20:15

You can use the clone() function on Lists to get a shallow copy of them. That way you won’t have to instantiate a new Object yourself but can just use the copy.

ArrayList<Integer> remaining = remaining.clone().remove(i);

Other than that, no, java does not have such operators for Lists.

score 1 · Answer 3 · answered Jan 11 '11 at 20:25

1

Apache Commons solves a lot of these kinds of issues. Have a look at ArrayUtils to do slicing. Java doesn't have a lot of syntactic sugar like scripting languages do for various reasons.

answered Jan 11 '11 at 20:25

jiggy

3,828
1
25
40

score 1 · Answer 4 · answered Jan 11 '11 at 21:55

Different languages require different styles. Trying to accomplish mylist[:i] + mylist[i+1:] in java is like using a hammer with a screw. Yes, you can do it, but it's not very tidy. I believe the equivalent might be something like ArrayList temp = new ArrayList(list); temp.remove(index);

I believe the following accomplishes the same task, but does so in a slightly different fashion, but doesn't suffer readability issues. Instead of creating a new list, it modifies the list, passes it on, and returns the list to its previous state when the recursive call returns.

import java.util.Arrays;
import java.util.List;
import java.util.ArrayList;

public class Permutation {

   public static void main(String[] args) {

      List<List<Integer>> result = permutations(
                                       Arrays.asList( 
                                          new Integer[] {1,2,3}));

      for (List<Integer> permutation : result) {
         System.out.println(permutation);  
      }
   }


   public static <T> List<List<T>> permutations(List<T> input) {
      List<List<T>> out = new ArrayList<List<T>>();
      permutationsSlave(input, new ArrayList<T>(), out);
      return out;
   }

   public static <T> void permutationsSlave(List<T> input, 
            ArrayList<T> permutation, List<List<T>> result) {

      if (input.size() == chosen.size()) {
         result.add(new ArrayList<T>(permutation));
         return;
      }

      for (T obj : input) {
         if (!permutation.contains(obj)) {
            permutation.add(obj);
            permutationsSlave(input, permutation, result);
            permutation.remove(permutation.size()-1);
         }
      } 

   }
}

The python way may look easy and cleaner, but ability to look clean often hides the fact that the solution is quite inefficient (for each level of recursion it creates 5 new lists).

But then my own solution isn't terribly efficient either -- instead of creating multiple new objects it performs redundant comparisons (though some of this could be alleviated by use of accumulators).

score 0 · Answer 5 · answered Jan 11 '11 at 20:18

0

Hi 1 you can use stack, which will be more handy.

2 the for loop can be written like this : for(Number n:numbers)

answered Jan 11 '11 at 20:18

benzen

6,204
4
25
37

Are there any more elegant ways of handling lists in Java ? (Python VS Java)

5 Answers5

Linked