using java 8 options and streams vs list and null checking

gistfile1.java

List<Class<?>> assignables = Arrays.asList(Request.class, Response.class, HttpServletRequest.class, HttpServletResponse.class);

void callMethod(final Method me, final HttpServletRequest request, final HttpServletResponse response) {
  Optional.ofNullable(me).ifPresent(m -> {
    
    Optional<Class<?>[]> typesStream = Optional.of(m.getParameterTypes());
    
    typesStream
    .filter(ctypes -> ctypes.length == 1)
    .map(types -> types[0])
    .ifPresent(type -> {
       assignables
       .stream()
       .parallel()
       .filter(c -> type.isAssignableFrom(c))
       .findFirst()
       .ifPresent(c -> {
         try {
           switch (assignables.indexOf(c)) {
            case 0: m.invoke(this, new Request(request))   ; break;
            case 1: m.invoke(this, new Response(response)) ; break;
            case 2: m.invoke(this, response)               ; break;
            case 4: m.invoke(this, request)                ; break;
           } 
         } catch (Exception e) {
           e.printStackTrace();
         }
       });
     });
    
    typesStream
    .filter(ctypes -> ctypes.length == 2)
    .ifPresent(types -> {
      try {
        if (types[0].isAssignableFrom(HttpServletRequest.class) && types[1].isAssignableFrom(HttpServletResponse.class)) {
          m.invoke(this, request, response);
        } else if (types[0].isAssignableFrom(Request.class) && types[1].isAssignableFrom(Response.class)) {
          m.invoke(this, new Request(request), new Response(response));
        }
      } catch (Exception e) {
        e.printStackTrace();
      }
    });
  });
}

public static final Stream<Method> getPublicMethods(final Class<?> clazz) {
  return Arrays.stream(clazz.getMethods())
  .filter(method -> Modifier.isPublic(method.getModifiers()));
}


////////////////////////////////
//Versus
////////////////////////////////


private void callMethod(Method m, HttpServletRequest request,
        HttpServletResponse response) {
    try {
        if (m != null) {
            Class<?>[] types = m.getParameterTypes();
            if (types.length == 1) {
                if (types[0].isAssignableFrom(Request.class)) {
                    m.invoke(this, new Request(request));
                } else if (types[0].isAssignableFrom(Response.class)) {
                    m.invoke(this, new Response(response));
                } else if (types[0]
                        .isAssignableFrom(HttpServletResponse.class)) {
                    m.invoke(this, response);
                } else if (types[0]
                        .isAssignableFrom(HttpServletRequest.class)) {
                    m.invoke(this, request);
                }
            }

            if (types.length == 2) {
                if (types[0].isAssignableFrom(HttpServletRequest.class)
                        && types[1]
                                .isAssignableFrom(HttpServletResponse.class)) {
                    m.invoke(this, request, response);
                } else if (types[0].isAssignableFrom(Request.class)
                        && types[1].isAssignableFrom(Response.class)) {
                    m.invoke(this, new Request(request), new Response(
                            response));
                }
            }
        }
    } catch (IllegalAccessException | IllegalArgumentException
            | InvocationTargetException e) {
        e.printStackTrace();
    }
}

public static final List<Method> getPublicMethods(Class<?> clazz) {
    List<Method> methods = new ArrayList<Method>();
    for (Method method : clazz.getMethods()) {
        if (Modifier.isPublic(method.getModifiers())) {
            methods.add(method);
        }
    }
    return Collections.unmodifiableList(methods);
}