Extract a list from list of lists

Question

I have a list of lists in java.

static ArrayList<List> permutationS = new ArrayList<List>();

The inner list is an ArrayList of integers.

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

Now I want to select an innerList, If it contains a particular integer. How can I achieve this?

Do you want every list that contains at least one instance of that integer? — k.krol.27, Jul 11 '17 at 14:37
@k.krol.27 there will be only one list containing a particular integer. Here is an example:[[0, 6, 13, 14], [1, 10, 11, 18], [2, 22, 4, 20], [3, -1, 21, 12], [5, 9, 17, 16], [7, 15, 19, 8]] — sheldon cooper, Jul 11 '17 at 14:38

Willi Mentzel · Accepted Answer · 2017-07-11T14:43:19.697

1

Do it like this:

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

// list initialization here

int i = 5; // the Integer you are searching for

for(List<Integer> innerList : permutationS) {
   if(innerList.contains(i)) {
     // found, do something with innerList
   }
}

edited Jul 11 '17 at 14:43

answered Jul 11 '17 at 14:38

Willi Mentzel

27,862
20
113
121

Jacob G. · Answer 2 · 2017-07-11T14:46:03.163

1

One solution would be to remove all of the List<Integer>s that do not contain a particular integer (10, for example):

permutationS.removeIf(list -> !list.contains(10));

Another solution would be to use streams and filtering to accomplish it:

permutationS.stream()
            .filter(list -> list.contains(10))
            .collect(Collectors.toList());

If you're only looking for a single List<Integer>, then you could use the following:

List<Integer> newList = permutationS.parallelStream()
                                    .filter(list -> list.contains(10))
                                    .findAny()
                                    .orElseGet(ArrayList::new);

edited Jul 11 '17 at 14:46

answered Jul 11 '17 at 14:39

Jacob G.

28,856
5
62
116

`parallelStream()` offers no advantages other than the possibility of faster execution when more cores are available. `parallelStream()` _doesn't always guarantee faster results_. In fact, A parallel stream has a much higher overhead compared to a sequential one. There are only certain cases in which you'd want to use `parallelStream()`. – Ousmane D. Jul 11 '17 at 22:19

score 0 · Answer 3 · answered Jul 11 '17 at 14:37

0

As of I do not know which Java version you are using I suggest looping throught it like

List<List<Integer>> Permutation_S = new ArrayList<List<Integer>>(); 
for(List<Integer> listInList: Permutation_S){
    for(Integer integerValue: listInList){
        if(integerValue == 2 /*your desired value*/){
            //DO SOMETHING
        }
    }
}

Of course you can use streams, if you are on Java 8 or higher

answered Jul 11 '17 at 14:37

Pwnstar

2,333
2
29
52

permutationS is of type List> not List> – Wietlol Jul 11 '17 at 14:38
so List> ? – Pwnstar Jul 11 '17 at 14:39
(actually worse as it uses the rawtype but it is considered the same as a wildcard type) Type> is the same as Type extends Object> as everything extends Object, but T is not provided so T is out of the question... next to which iirc, its E instead of T – Wietlol Jul 11 '17 at 14:41
But he asked for Integer – Pwnstar Jul 12 '17 at 06:21

Alberto Trindade Tavares · Answer 4 · 2017-07-11T14:43:25.457

0

A solution with stream:

int x = 3; // the number to be looked

List<Integer> selectedInnerList = permutationS.stream()
                                              .filter(s -> s.contains(x))
                                              .findFirst()
                                              .get();

Note that findFirst() returns an Optional object, so get() will throw an exception if there is no such element

edited Jul 11 '17 at 14:43

answered Jul 11 '17 at 14:38

Alberto Trindade Tavares

10,056
5
38
46

This will throw an exception if no list contains `x` – Jacob G. Jul 11 '17 at 14:41
@JacobG. Edited my answer to clarify this – Alberto Trindade Tavares Jul 11 '17 at 14:43
@AlbertoTrindadeTavares what is from where is s coming? – sheldon cooper Jul 11 '17 at 15:02
@sheldoncooper s is the parameter of the lambda (an anonymous function). We don't need to declare it explicitly – Alberto Trindade Tavares Jul 11 '17 at 15:57

score 0 · Answer 5 · answered Jul 11 '17 at 14:38

0

How about:

public List getList(Object value) {

    for (List inner : Permutation_S) {
        if (inner.contains(value))
            return inner;
    }
}

answered Jul 11 '17 at 14:38

Pablo notPicasso

3,031
3
17
22

score 0 · Answer 6 · edited Jul 11 '17 at 15:00

0

Maybe with a structure like this ?

for (List<Integer> lists : permutationS) {
    for(Integer integers : lists){
        //Your tests 
    }
}

edited Jul 11 '17 at 15:00

msanford

11,803
11
66
93

answered Jul 11 '17 at 14:40

Alex

33
12

azro · Answer 7 · 2017-07-11T14:50:45.160

This will allow you to get the list which contains the value you want, and if no-one of the inner lists contains it, it will return a new empty list :

int val = 10;
List<Integer> innerList = permutationS.stream()    //iterate over inner lists
        .filter(list -> list.contains(val))        //keep one which contains the value
        .findAny()                                 //keep only one if exists
        .orElse(new ArrayList<>());                // if no-one return new List

Example :

permutationS.add(Arrays.asList(0, 6, 13, 14));
permutationS.add(Arrays.asList(1, 10, 11, 18, 6, 78, 79, 9));
permutationS.add(Arrays.asList(2, 22, 4, 20));

List<Integer> innerList = permutationS.stream().filter(list -> list.contains(10))
                                               .findAny().orElse(new ArrayList<>());
innerList.size(); // = 8

List<Integer> innerList2 = permutationS.stream().filter(list -> list.contains(34))
                                                .findAny().orElse(new ArrayList<>());
innnerList2.size(); // = 0

Extract a list from list of lists

7 Answers7