As originally reported by Martin Buchholz here:
 http://mail.openjdk.java.net/pipermail/core-libs-dev/2014-October/029272.html

The profile shows the hot call tree sub-branch here:

  | | +- 15.981 (18%) java.lang.Class.getMethods()
  | | | +- 15.971 (18%) java.lang.Class.privateGetPublicMethods()
  | | | | +- 15.791 (18%) java.lang.Class$MethodArray.removeByNameAndDescriptor(java.lang.reflect.Method)
  | | | | | +- 10.687 (12%) java.lang.Class$MethodArray.matchesNameAndDescriptor(java.lang.reflect.Method, java.lang.reflect.Method)
  | | | | | | +- 0.020 (0%) java.lang.reflect.Method.getParameterTypes()
  | | | | | | +- 0.010 (0%) java.lang.Object.clone()
  | | | | | +- 0.020 (0%) java.lang.Class$MethodArray.remove(int)
  | | | | +- 0.100 (0%) java.lang.Class.privateGetDeclaredMethods(boolean)
  | | | | +- 0.050 (0%) java.lang.Class.privateGetPublicMethods()
  | | | | +- 0.020 (0%) java.lang.Class$MethodArray.addAllIfNotPresent(java.lang.Class$MethodArray)

This is what happens. Class.getMethods() ends up calling

    private Method[] privateGetPublicMethods() {
       ...

                MethodArray supers = new MethodArray();
                supers.addAll(c.privateGetPublicMethods());
                // Filter out concrete implementations of any
                // interface methods
                for (int i = 0; i < supers.length(); i++) {
                    Method m = supers.get(i);
                    if (m != null &&
                            !Modifier.isAbstract(m.getModifiers()) &&
                            !m.isDefault()) {
                        inheritedMethods.removeByNameAndDescriptor(m);
                    }
                }

       ....

       // Filter out all local methods from inherited ones
        for (int i = 0; i < methods.length(); i++) {
            Method m = methods.get(i);
            inheritedMethods.removeByNameAndDescriptor(m);
        }

...which tries to filter out the inherited methods for the current class. Unfortunately, the call to removeByNameAndDescriptor yields *another* loop of "inherited" methods:

        void removeByNameAndDescriptor(Method toRemove) {
            for (int i = 0; i < length; i++) {
                Method m = methods[i];
                if (m != null && matchesNameAndDescriptor(m, toRemove)) {
                    remove(i);
                }
            }
        }

...and this yields quadratic complexity. We should try to do better lookups instead of linear searches here.