I am doing a coding exercise in codility and I came across this question:

> A binary gap within a positive integer N is any maximal sequence of
> consecutive zeros that is surrounded by ones at both ends in the
> binary representation of N.
> 
> For example, number 9 has binary representation 1001 and contains a
> binary gap of length 2. The number 529 has binary representation
> 1000010001 and contains two binary gaps: one of length 4 and one of
> length 3. The number 20 has binary representation 10100 and contains
> one binary gap of length 1. The number 15 has binary representation
> 1111 and has no binary gaps.
> 
> Write a function:
> 
> `class Solution { public int solution(int N); }` that, given a positive
> integer N, returns the length of its longest binary gap. The function
> should return 0 if N doesn't contain a binary gap.
> 
> For example, given N = 1041 the function should return 5, because N
> has binary representation 10000010001 and so its longest binary gap is
> of length 5.
> 
> Assume that:
> 
> N is an integer within the range [1..2,147,483,647]. Complexity:
> 
> expected worst-case time complexity is O(log(N)); expected worst-case
> space complexity is O(1).

My code looks like this:

    import java.util.*;

    class Solution {
        public static int solution(int N) {
            return Optional.ofNullable(N)
            .map(Integer::toBinaryString)
            .filter(n -> n.length() > 1)
            .map(t -> {
                List<Integer> counts = new ArrayList<>();
                int count = 0;
                for(int i = 0; i < t.length(); i++)
                {
                    if(t.charAt(i) == '0') {
                        count += 1;
                    } else if(count > 0) {
                        counts.add(count);
                        count = 0;
                    }
                }
                if(counts.size() > 0) {
                    Collections.sort(counts);
                    return counts.get(counts.size() - 1);
                }
                return 0;
            })
            .orElse(0);
        }
    }

What else can I do to improve the performance of the aforementioned code? How do I determine the big-O complexity of this program?