DouKaku?

using System;
using System.Collections.Generic;
using System.Reflection;

namespace Doukaku270 {
    class Program {
        static void Main(string[] args) {
            int classCount = 0;
            SortedDictionary<int, List<Type>> result = new SortedDictionary<int, List<Type>>();
            foreach (AssemblyName name in typeof(Program).Assembly.GetReferencedAssemblies()) {
                Assembly asm = Assembly.Load(name);
                if (asm != null) {
                    foreach (Type type in asm.GetTypes()) {
                        int methodCount = type.GetMethods().Length;
                        if (!result.ContainsKey(methodCount)) {
                            result[methodCount] = new List<Type>();
                        }
                        result[methodCount].Add(type);
                        classCount++;
                    }
                }
            }

            List<int> keyList = new List<int>(result.Keys);
            keyList.Reverse();
            int count = 0;
            foreach (int key in keyList.GetRange(0, 10)) {
                foreach (Type type in result[key]) {
                    Console.WriteLine("{0}: {1}", type.FullName, key);
                    count++;
                }
                if (count >= 10)
                    break;
            }
            Console.WriteLine("全クラス数: {0}", classCount);
        }
    }
}

package doukaku;

import java.io.File;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.jar.*;

public class HugeClasses {
    public static void main(String[] args) throws Exception {
        final File rt = new File(System.getProperty("java.home"), "lib/rt.jar");

        if (!rt.exists()) {
            System.err.println("rt.jarが見つかりません。");
            return;
        }

        final int topN = 10;
        NavigableSet<ClassHolder> sortSet = new TreeSet<ClassHolder>();

        for (JarEntry entry : Collections.list(new JarFile(rt).entries())) {
            String name = entry.getName();
            if ((name.startsWith("java/") || name.startsWith("javax/"))
                    && name.endsWith(".class")) {

                String className = name.substring(0, name.length() - 6)
                        .replace('/', '.');
                Class<?> clazz = Class.forName(className);
                sortSet.add(new ClassHolder(clazz));
                if (sortSet.size() > topN) sortSet.pollFirst();
            }
        }

        for (ClassHolder classHolder : sortSet) {
            System.out.printf("%-60s: %d%n", classHolder.className,
                    classHolder.methodCount);
        }
    }

    private static class ClassHolder implements Comparable<ClassHolder> {
        private static final AtomicInteger idCounter = new AtomicInteger(0);
        private String className;
        private int methodCount;
        private int id;

        ClassHolder(Class<?> clazz) {
            id = idCounter.getAndIncrement();
            className = clazz.getName();
            methodCount = clazz.getMethods().length;
        }

        @Override
        public int compareTo(ClassHolder o) {
            return methodCount != o.methodCount ?
                    methodCount - o.methodCount
                    : id - o.id;
        }
    }
}

//全クラス数 : 3634
//System.Linq.Expressions.Expression : 387
//System.Convert : 313
//System.Linq.ParallelEnumerable : 210
//System.Runtime.InteropServices.Marshal : 203
//System.Linq.Enumerable : 203
//Microsoft.Win32.Win32Native : 199
//System.Linq.Expressions.Strings : 180
//System.Linq.Expressions.Error : 146
//System.Linq.Queryable : 124
//System.Console : 117

using System;
using System.Linq;
using System.Reflection;

class Program
{
    static void Main(string[] args)
    {
        //var classTypes = typeof(Program).Assembly.GetReferencedAssemblies().Select(assemblyName => Assembly.Load(assemblyName).GetTypes()).SelectMany(classType => classType);
        //var classCountDict = classTypes.ToDictionary(classType => classType, classType => classType.GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly).Count());
        //var result = classCountDict.OrderByDescending(pair => pair.Value).Take(10);
        var classCountDict = typeof(Program).Assembly.GetReferencedAssemblies().Select(assemblyName => Assembly.Load(assemblyName).GetTypes()).SelectMany(classType => classType).ToDictionary(classType => classType, classType => classType.GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.DeclaredOnly).Count());
        Console.WriteLine("全クラス数 : {0}", classCountDict.Keys.Count());
        foreach (var obj in classCountDict.OrderByDescending(pair => pair.Value).Take(10))
        {
            Console.WriteLine("{0} : {1}", obj.Key, obj.Value);
        }
        Console.ReadLine();
    }
}

| clsCount result |
clsCount := 0.
result := Dictionary new.
SystemNavigation default allBehaviorsDo: [:class |
    clsCount := clsCount + 1.
    result at: class put: class selectors size].
^{#全クラス数 -> clsCount. (result associations sort: [:a :b | a value > b value]) first: 10}


"=> {#全クラス数 -> 4384. {
    Morph -> 1165. 
    Player -> 620. 
    PasteUpMorph -> 469. 
    Preferences class -> 450. 
    Object -> 436. 
    ParagraphEditor -> 284. 
    SyntaxMorph -> 250. 
    Behavior -> 243. 
    ScriptLoader -> 236. 
    String -> 233
}} "

my %cnt;
my $top = '*main::';
count_subs($top,\%cnt);
--$cnt{$top}; # sub count_subs の分を差し引く
my $i=0;
$\="\n";
print for map { "@{[substr($_->[0],1,-2)]} --- $_->[1]" }
grep { ++$i <= 10 }
sort {$b->[1] <=> $a->[1]}
map { [$_, $cnt{$_}] } keys %cnt;

my %counted;
sub count_subs
{
  my ($mod, $cnt) = @_;
  return if exists $cnt->{$mod};
  $cnt->{$mod} = 0;
  return if !defined %{$mod};
  while (my ($k,$v) = each %{$mod}) {
    if ( substr($k, -2) eq '::' ) {
      count_subs($v, \%cnt);
    }
    elsif (defined &{$v} && !exists $counted{$v}) {
      ++$cnt->{$mod};
      $counted{$v}=undef;
    }
  }
}

(use srfi-1)

(define *builtin-identifiers*
  (let1 module (find-module 'gauche)
    (filter-map
      (cut global-variable-ref module <> #f)
      (remove (cut eq? '~$ <>)
              (hash-table-map (module-table module)
                              (lambda (sym _) sym))))))

(define *builtin-classes*
  (filter (cut is-a? <> <class>) *builtin-identifiers*))

(define *builtin-generic-functions*
  (filter (cut is-a? <> <generic>) *builtin-identifiers*))

(define (direct-methods class)
  (filter-map (lambda (method)
                (let1 specs (slot-ref method 'specializers)
                  (and (member class specs)
                       method)))
              (append-map (cut slot-ref <> 'methods)
                          *builtin-generic-functions*)))

(define (main args)
  (for-each
    (lambda (x) (format #t "~10a : ~2d~%" (class-name (car x)) (cdr x)))
    (take (sort-by (map (lambda (class)
                          (cons class (length (direct-methods class))))
                        *builtin-classes*)
                   cdr
                   >)
          10))
  0)

(loop for p in (list-all-packages) collect
  (list (package-name p)
        (loop for s being each present-symbol in p count (fboundp s)))
  into x
  finally (format t "~10{~{~15A : ~A~}~%~}~%"
                  (sort x #'> :key #'cadr)))

import java.io.*;
import java.lang.reflect.*;
import java.util.Map.Entry;
import java.util.jar.*;
import java.util.*;

public class Sample {

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Map<String, Integer> classMap = new HashMap<String, Integer>();
        for (String jarName : System.getProperty("sun.boot.class.path").split(System.getProperty("path.separator"))) {
            File jar = new File(jarName);
            if (jar.isFile()) {
                JarFile jf = new JarFile(jar);
                for (Enumeration<JarEntry> i = jf.entries(); i.hasMoreElements();) {
                    String entry = i.nextElement().getName();
                    if (entry.endsWith(".class")) {
                        String className = entry.substring(0, entry.length() - 6).replaceAll("/", ".");
                        Class<?> cc = Class.forName(className, false, null);
                        int staticCount = 0, memberCount = 0;
                        for (Method m : cc.getDeclaredMethods()) {
                            if ((m.getModifiers() & Modifier.STATIC) != 0)
                                staticCount++;
                            else 
                                memberCount++;
                        }
                        classMap.put(className, memberCount);
                        classMap.put(className + " static", staticCount);
                    }
                }
            }
        }
        Map.Entry<String, Integer>[] a = classMap.entrySet().toArray(new Map.Entry[0]);
        Arrays.sort(a, new Comparator<Map.Entry<String, Integer>> () {
            public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) {
                return -o1.getValue().compareTo(o2.getValue());
            }    
        });
        for (int i = 0; i < 10; i++) {
            System.out.printf("%s -> %d%n", a[i].getKey(), a[i].getValue());        
        }
    }

}

class Doukaku270
{
    static const Int numClassesToDisplay := 10

    Void main() {
        Int:Type[] counts := [:] // 連想配列: メソッド数 -> クラスのリスト

        // countsを埋める
        Pod.list.each |Pod pod| {
            pod.types.each |Type type| {
                numMethods := type.methods.findAll {
                    // 継承したものでなく、このクラスで実装されたものを選ぶ
                    it.toStr.startsWith("${type.toStr}.")
                }.size
                counts[numMethods] = counts.get(numMethods, [,]).add(type)
            }
        }

        numPrints := 0  // 出力済みの行数
        keys := counts.keys.sortr
        while (numPrints < numClassesToDisplay) {
            numMethods := keys.removeAt(0)
            counts[numMethods].each |Type type| {
                echo("${type.toStr}, $numMethods")
            }
            numPrints += counts[numMethods].size
        }
    }
}

list = []
ObjectSpace.each_object(Class) do |klass|
  info = {
    :name => klass.name,
    :methods => {
      :instance_methods => {
        :public => klass.public_instance_methods,
        :protected => klass.protected_instance_methods,
        :private => klass.private_instance_methods
      },
      :class_methods => {
        :public => klass.class.public_instance_methods,
        :protected => klass.class.protected_instance_methods,
        :private => klass.class.private_instance_methods
      }
    }
  }
  info.instance_eval do |obj|
    def name
      self[:name]
    end
    def method_count
      [:instance_methods, :class_methods].inject(0) do |c, t|
        c + [:public, :protected, :private].inject(0) do |r, s|
          r + self[:methods][t][s].size
        end
      end
    end
  end
  list << info
end
puts "total:\t#{list.size}"
list.sort { |a,b| b.method_count <=> a.method_count }[0..9].each do |e|
  puts "#{e.name}:\t#{e.method_count}"
end

import scala.collection.jcl.Conversions
import java.io.File
import java.util.Collections
import java.util.jar.{JarEntry,JarFile}

object MethodCount {
    def getClassInformations(l:List[String]):List[Pair[String,Int]] = {
        def getInfo(n:String):Pair[String,Int] =
            try { (n, Class.forName(n).getDeclaredMethods.size) } catch { case _ => (n, -1) }
        def isClass(n:String):Boolean = n.endsWith(".class") && !n.matches("\\$\\$anonfun\\$")
        def getClassName(n:String):String = n.substring(0, n.length - 6).replace('/', '.')
        def getJarEntries(f:File):List[JarEntry] =
            Conversions.convertList(Collections.list((new JarFile(f)).entries)).toList
        def getFiles(l:List[String]):List[File] =
            l.map(new File(System.getProperty("scala.home"), _)).filter(_.exists)
        getFiles(l).map(getJarEntries).flatten(identity(_)).map(_.getName).filter(isClass).map(getClassName).map(getInfo)
    }
    def main(args:Array[String]):Unit = {
        val l:List[Pair[String,Int]] = getClassInformations(List("lib/scala-library.jar", "lib/scala-swing.jar"))
        Console.printf("total:\t%d\n", l.size)
        l.sort(_._2 > _._2).take(10).foreach((i) => Console.printf("%s:\t%d\n", i._1, i._2))
    }
}

import Data.List
import Data.Ord
import System.Process

data ClassInfo = CI { className :: String, numberOfMethods :: Int }

main = do { res <- readProcess "ghc" ["-e",":browse Prelude"] []
          ; let cis = classInfos [] $ lines res
          ; let n = length cis
          ; putStr $ unlines {- $ take 10 -}
          $ map showClassInfo $ sortBy (flip (comparing numberOfMethods)) cis
          ; putStr $ unlines ["...","number of classes : "++show n]
          }

showClassInfo :: ClassInfo -> String
showClassInfo (CI name n) = name ++ " (" ++ show n ++ ")"

classInfos :: [ClassInfo] -> [String] -> [ClassInfo]
classInfos a [] = a
classInfos a (l:ls)
 | head lw /= "class" = classInfos a ls
 | otherwise = classInfos (ci:a) ls''
   where 
     lw = words l
     ci = CI name (if null ls' then 1 else length ls')
     (ls',ls'') = break (not . ("  " `isPrefixOf`)) ls
     name = case break ("=>"==) lw of
       (_,[])  -> head $ tail lw
       (_,lw') -> head $ tail lw'

local tab =
{
    function count_function(cla)
    {
        local ret = 0;
        foreach(k,v in cla) if (type(v) == "function") ret++;
        return ret;
    }

    function main()
    {
        local result = [{ key="roottable", val=count_function(getroottable()) }];
        foreach(k,v in getroottable()) if (type(v)=="class") result.append({ key=k, val=count_function(v) });
        result.sort(@(a, b) b.val-a.val);
        for(local i=0; i<10 && i<result.len(); i++) print(format("%-10s : %3d\n", result[i].key, result[i].val));
    }
}
tab.main();

def bi_of(name):
    return getattr(__builtins__, name)

def special_name(a):
    return a[0:2] == "__" and a[-2:] == "__"

def bi_methods_of(name):
    o = bi_of(name)
    return filter(
        lambda a: not special_name(a) and callable(getattr(o, a)),
        dir(o))

def bi_all_methods_of(name):
    o = bi_of(name)
    return filter(
        lambda a: callable(getattr(o, a)),
        dir(o))

def class_method_ranking(counter_func, limit):
    return map(
        lambda name: "%s(%d)" % (name, len(counter_func(name))),
        sorted(
            filter(
                lambda name: type(bi_of(name)) == type,
                dir(__builtins__)),
            lambda a,b: cmp(
                len(counter_func(a)),
                len(counter_func(b))
                ) * -1
        )[0:limit]
    )

print "Only regular methods: %s" % ", ".join(
    class_method_ranking(bi_methods_of, 10))
print "Including special methods: %s" % ", ".join(
    class_method_ranking(bi_all_methods_of, 10))

import org.codehaus.groovy.runtime.*

counter=[:]

[DefaultGroovyMethods,
 DefaultGroovyStaticMethods,
 SwingGroovyMethods].each {
    it.methods.each {
        if (it.parameterTypes.size() != 0) {
            cls = it.parameterTypes[0]
            counter[cls]==null? counter[cls]=1 : counter[cls]++
        }
    }
}
counter.entrySet().sort { -it.value }[0..9].eachWithIndex { it, idx ->
    println "${idx+1} : $it"
}