Thread.currentThread().getStackTrace()通常包含您从中调用它的方法，但存在一些陷阱（参见 Javadoc）：

在某些情况下，某些虚拟机可能会从堆栈跟踪中省略一个或多个堆栈帧。在极端情况下，允许没有与此线程相关的堆栈跟踪信息的虚拟机从此方法返回零长度数组。

2009 年 1 月：
完整的代码是（考虑到 @Bombe 的警告）：

/**
 * Get the method name for a depth in call stack. <br />
 * Utility function
 * @param depth depth in the call stack (0 means current method, 1 means call method, ...)
 * @return method name
 */
public static String getMethodName(final int depth)
{
  final StackTraceElement[] ste = Thread.currentThread().getStackTrace();

  //System. out.println(ste[ste.length-depth].getClassName()+"#"+ste[ste.length-depth].getMethodName());
  // return ste[ste.length - depth].getMethodName();  //Wrong, fails for depth = 0
  return ste[ste.length - 1 - depth].getMethodName(); //Thank you Tom Tresansky
}

更多关于这个问题。

2011 年 12 月更新：

蓝色评论：

我使用 JRE 6 并给了我不正确的方法名称。
如果我写，它就会起作用ste[2 + depth].getMethodName().

• 0是getStackTrace()
• 1是和getMethodName(int depth)
• 2正在调用方法。

Virgo47 的答案（点赞）实际上计算了要应用的正确索引，以便取回方法名称。

从技术上讲，这将起作用......

String name = new Object(){}.getClass().getEnclosingMethod().getName();

但是，在编译期间将创建一个新的匿名内部类（例如 ）。因此，这将为部署此技巧的每个方法创建一个文件。此外，在运行时的每次调用中都会创建一个未使用的对象实例。因此，这可能是一个可以接受的调试技巧，但它确实会带来巨大的开销。YourClass$1.class.class

此技巧的一个优点是返回可用于检索方法的所有其他信息，包括注释和参数名称。这样就可以区分具有相同名称的特定方法（方法重载）。getEnclosingMethod()java.lang.reflect.Method

请注意，根据这个技巧的 JavaDoc 不应该抛出一个，因为内部类应该使用相同的类加载器加载。因此，即使存在安全管理器，也无需检查访问条件。getEnclosingMethod()SecurityException

请注意：它需要用于构造函数。在（命名）方法之外的块期间，返回 .getEnclosingConstructor()getEnclosingMethod()null

我们使用此代码来缓解堆栈跟踪索引中的潜在可变性 - 现在只需调用 methodName util：

public class MethodNameTest {
    private static final int CLIENT_CODE_STACK_INDEX;

    static {
        // Finds out the index of "this code" in the returned stack trace - funny but it differs in JDK 1.5 and 1.6
        int i = 0;
        for (StackTraceElement ste : Thread.currentThread().getStackTrace()) {
            i++;
            if (ste.getClassName().equals(MethodNameTest.class.getName())) {
                break;
            }
        }
        CLIENT_CODE_STACK_INDEX = i;
    }

    public static void main(String[] args) {
        System.out.println("methodName() = " + methodName());
        System.out.println("CLIENT_CODE_STACK_INDEX = " + CLIENT_CODE_STACK_INDEX);
    }

    public static String methodName() {
        return Thread.currentThread().getStackTrace()[CLIENT_CODE_STACK_INDEX].getMethodName();
    }
}

似乎过度设计了，但我们对 JDK 1.5 有一些固定的数字，当我们迁移到 JDK 1.6 时，它的变化有点惊讶。现在在 Java 6/7 中也是一样的，但你永远不知道。这并不能证明该索引在运行时发生了变化 - 但希望 HotSpot 不会做得那么糟糕。:-)

使用以下代码：

    StackTraceElement[] stacktrace = Thread.currentThread().getStackTrace();
    StackTraceElement e = stacktrace[1];//coz 0th will be getStackTrace so 1st
    String methodName = e.getMethodName();
    System.out.println(methodName);

最快的方式我发现：

import java.lang.reflect.Method;

public class TraceHelper {
    // save it static to have it available on every call
    private static Method m;

    static {
        try {
            m = Throwable.class.getDeclaredMethod("getStackTraceElement",
                    int.class);
            m.setAccessible(true);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static String getMethodName(final int depth) {
        try {
            StackTraceElement element = (StackTraceElement) m.invoke(
                    new Throwable(), depth + 1);
            return element.getMethodName();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

它直接访问本机方法 getStackTraceElement（int depth）。并将可访问的 Method 存储在静态变量中。

这是对 virgo47 答案（上图）的扩展。

它提供了一些静态方法来获取当前和调用类/方法的名称。

/* Utility class: Getting the name of the current executing method 
 * https://stackoverflow.com/questions/442747/getting-the-name-of-the-current-executing-method
 * 
 * Provides: 
 * 
 *      getCurrentClassName()
 *      getCurrentMethodName()
 *      getCurrentFileName()
 * 
 *      getInvokingClassName()
 *      getInvokingMethodName()
 *      getInvokingFileName()
 *
 * Nb. Using StackTrace's to get this info is expensive. There are more optimised ways to obtain
 * method names. See other stackoverflow posts eg. https://stackoverflow.com/questions/421280/in-java-how-do-i-find-the-caller-of-a-method-using-stacktrace-or-reflection/2924426#2924426
 *
 * 29/09/2012 (lem) - added methods to return (1) fully qualified names and (2) invoking class/method names
 */
package com.stackoverflow.util;

public class StackTraceInfo
{
    /* (Lifted from virgo47's stackoverflow answer) */
    private static final int CLIENT_CODE_STACK_INDEX;

    static {
        // Finds out the index of "this code" in the returned stack trace - funny but it differs in JDK 1.5 and 1.6
        int i = 0;
        for (StackTraceElement ste: Thread.currentThread().getStackTrace())
        {
            i++;
            if (ste.getClassName().equals(StackTraceInfo.class.getName()))
            {
                break;
            }
        }
        CLIENT_CODE_STACK_INDEX = i;
    }

    public static String getCurrentMethodName()
    {
        return getCurrentMethodName(1);     // making additional overloaded method call requires +1 offset
    }

    private static String getCurrentMethodName(int offset)
    {
        return Thread.currentThread().getStackTrace()[CLIENT_CODE_STACK_INDEX + offset].getMethodName();
    }

    public static String getCurrentClassName()
    {
        return getCurrentClassName(1);      // making additional overloaded method call requires +1 offset
    }

    private static String getCurrentClassName(int offset)
    {
    return Thread.currentThread().getStackTrace()[CLIENT_CODE_STACK_INDEX + offset].getClassName();
    }

    public static String getCurrentFileName()
    {
        return getCurrentFileName(1);     // making additional overloaded method call requires +1 offset
    }

    private static String getCurrentFileName(int offset)
    {
        String filename = Thread.currentThread().getStackTrace()[CLIENT_CODE_STACK_INDEX + offset].getFileName();
        int lineNumber = Thread.currentThread().getStackTrace()[CLIENT_CODE_STACK_INDEX + offset].getLineNumber();

        return filename + ":" + lineNumber;
    }

    public static String getInvokingMethodName()
    {
        return getInvokingMethodName(2); 
    }

    private static String getInvokingMethodName(int offset)
    {
        return getCurrentMethodName(offset + 1);    // re-uses getCurrentMethodName() with desired index
    }

    public static String getInvokingClassName()
    {
        return getInvokingClassName(2); 
    }

    private static String getInvokingClassName(int offset)
    {
        return getCurrentClassName(offset + 1);     // re-uses getCurrentClassName() with desired index
    }

    public static String getInvokingFileName()
    {
        return getInvokingFileName(2); 
    }

    private static String getInvokingFileName(int offset)
    {
        return getCurrentFileName(offset + 1);     // re-uses getCurrentFileName() with desired index
    }

    public static String getCurrentMethodNameFqn()
    {
        return getCurrentMethodNameFqn(1);
    }

    private static String getCurrentMethodNameFqn(int offset)
    {
        String currentClassName = getCurrentClassName(offset + 1);
        String currentMethodName = getCurrentMethodName(offset + 1);

        return currentClassName + "." + currentMethodName ;
    }

    public static String getCurrentFileNameFqn()
    {
        String CurrentMethodNameFqn = getCurrentMethodNameFqn(1);
        String currentFileName = getCurrentFileName(1);

        return CurrentMethodNameFqn + "(" + currentFileName + ")";
    }

    public static String getInvokingMethodNameFqn()
    {
        return getInvokingMethodNameFqn(2);
    }

    private static String getInvokingMethodNameFqn(int offset)
    {
        String invokingClassName = getInvokingClassName(offset + 1);
        String invokingMethodName = getInvokingMethodName(offset + 1);

        return invokingClassName + "." + invokingMethodName;
    }

    public static String getInvokingFileNameFqn()
    {
        String invokingMethodNameFqn = getInvokingMethodNameFqn(2);
        String invokingFileName = getInvokingFileName(2);

        return invokingMethodNameFqn + "(" + invokingFileName + ")";
    }
}

 public class SomeClass {
   public void foo(){
      class Local {};
      String name = Local.class.getEnclosingMethod().getName();
   }
 }

name 的值为 foo。

String methodName =Thread.currentThread().getStackTrace()[1].getMethodName();
System.out.println("methodName = " + methodName);

public static String getCurrentMethodName() {
        return Thread.currentThread().getStackTrace()[2].getClassName() + "." + Thread.currentThread().getStackTrace()[2].getMethodName();
    }

另一种方法是创建（但不抛出）异常，并使用该对象从中获取堆栈跟踪数据，因为封闭方法通常位于索引 0 处 - 只要 JVM 存储该信息，正如上面提到的其他人一样。然而，这并不是最便宜的方法。

来自 Throwable.getStackTrace（）（至少从 Java 5 开始就是这样）：

数组的第 0 个元素（假设数组的长度不为零）表示堆栈的顶部，这是序列中的最后一个方法调用。通常，这是创建和投掷此可投掷物的点。

下面的代码片段假设该类是非静态的（因为 getClass（）），但这是题外话。

System.out.printf("Class %s.%s\n", getClass().getName(), new Exception("is not thrown").getStackTrace()[0].getMethodName());

这两个选项都适用于我的 Java：

new Object(){}.getClass().getEnclosingMethod().getName()

艺术

Thread.currentThread().getStackTrace()[1].getMethodName()

若要获取调用当前方法的方法的名称，可以使用：

new Exception("is not thrown").getStackTrace()[1].getMethodName()

这适用于我的 MacBook 和我的 Android 手机

我也试过：

Thread.currentThread().getStackTrace()[1]

但 Android 将返回“getStackTrace” 我可以用 Android 解决这个问题

Thread.currentThread().getStackTrace()[2]

但后来我在MacBook上得到了错误的答案

实用程序.java：

public static String getCurrentClassAndMethodNames() {
    final StackTraceElement e = Thread.currentThread().getStackTrace()[2];
    final String s = e.getClassName();
    return s.substring(s.lastIndexOf('.') + 1, s.length()) + "." + e.getMethodName();
}

SomeClass.java：

public class SomeClass {
    public static void main(String[] args) {
        System.out.println(Util.getCurrentClassAndMethodNames()); // output: SomeClass.main
    }
}

我有使用它的解决方案（在 Android 中）

/**
 * @param className       fully qualified className
 *                        <br/>
 *                        <code>YourClassName.class.getName();</code>
 *                        <br/><br/>
 * @param classSimpleName simpleClassName
 *                        <br/>
 *                        <code>YourClassName.class.getSimpleName();</code>
 *                        <br/><br/>
 */
public static void getStackTrace(final String className, final String classSimpleName) {
    final StackTraceElement[] steArray = Thread.currentThread().getStackTrace();
    int index = 0;
    for (StackTraceElement ste : steArray) {
        if (ste.getClassName().equals(className)) {
            break;
        }
        index++;
    }
    if (index >= steArray.length) {
        // Little Hacky
        Log.w(classSimpleName, Arrays.toString(new String[]{steArray[3].getMethodName(), String.valueOf(steArray[3].getLineNumber())}));
    } else {
        // Legitimate
        Log.w(classSimpleName, Arrays.toString(new String[]{steArray[index].getMethodName(), String.valueOf(steArray[index].getLineNumber())}));
    }
}

MethodHandles.lookup().lookupClass().getEnclosingMethod().getName();

我不知道获取当前执行方法名称背后的意图是什么，但如果这只是为了调试目的，那么像“logback”这样的日志框架可以在这里提供帮助。例如，在 logback 中，您需要做的就是在日志记录配置中使用模式“%M”。但是，应谨慎使用，因为这可能会降低性能。

以防万一您想知道的名称方法是 junit 测试方法，那么您可以使用 junit TestName 规则：https://stackoverflow.com/a/1426730/3076107

java.lang.StackWalker， 爪哇 9+

从 Java 9 开始，这可以使用 StackWalker 来完成。

public static String getCurrentMethodName() {
    return StackWalker.getInstance()
                      .walk(s -> s.skip(1).findFirst())
                      .get()
                      .getMethodName();
}

public static String getCallerMethodName() {
    return StackWalker.getInstance()
                      .walk(s -> s.skip(2).findFirst())
                      .get()
                      .getMethodName();
}

StackWalker被设计为懒惰，因此它可能比急切地为整个调用堆栈创建数组更有效。另请参阅 JEP 了解更多信息。Thread.getStackTrace

我稍微重写了 maklemenz 的答案：

private static Method m;

static {
    try {
        m = Throwable.class.getDeclaredMethod(
            "getStackTraceElement",
            int.class
        );
    }
    catch (final NoSuchMethodException e) {
        throw new NoSuchMethodUncheckedException(e);
    }
    catch (final SecurityException e) {
        throw new SecurityUncheckedException(e);
    }
}


public static String getMethodName(int depth) {
    StackTraceElement element;

    final boolean accessible = m.isAccessible();
    m.setAccessible(true);

    try {
        element = (StackTraceElement) m.invoke(new Throwable(), 1 + depth);
    }
    catch (final IllegalAccessException e) {
        throw new IllegalAccessUncheckedException(e);
    }
    catch (final InvocationTargetException e) {
        throw new InvocationTargetUncheckedException(e);
    }
    finally {
        m.setAccessible(accessible);
    }

    return element.getMethodName();
}

public static String getMethodName() {
    return getMethodName(1);
}

这里的大多数答案似乎都是错误的。

    public static String getCurrentMethod() {
            return getCurrentMethod(1);
    }
    public static String getCurrentMethod(int skip) {
            return Thread.currentThread().getStackTrace()[1 + 1 + skip].getMethodName();
    }

例：

    public static void main(String[] args) {
            aaa();
    }

    public static void aaa() {
            System.out.println("aaa  -> "  + getCurrentMethod( ) );
            System.out.println("aaa  -> "  + getCurrentMethod(0) );
            System.out.println("main -> "  + getCurrentMethod(1) );
    }

输出：

aaa  -> aaa
aaa  -> aaa
main -> main

我将此代码片段与最新的 Android Studio 和最新的 Java 更新一起使用。它可以从任何 Activity、Fragment 等调用。

public static void logPoint() {
    String[] splitPath = Thread.currentThread().getStackTrace()[3]
        .toString().split("\\.");

    Log.d("my-log", MessageFormat.format("{0} {1}.{2}",
        splitPath[splitPath.length - 3],
        splitPath[splitPath.length - 2],
        splitPath[splitPath.length - 1]
    ));
}

这样称呼它

logPoint();

输出

... D/my-log: MainActivity onCreate[(MainActivity.java:44)]

Java 9 或更高版本的首选解决方案：

private static String getCurrentMethodName() {
  return StackWalker.getInstance()
    .walk(frames -> frames.skip(1).findFirst().map(StackWalker.StackFrame::getMethodName))
    .orElse("Anything");
}

StackWalker有几个优点：

• 无需创建虚拟匿名内部类实例，即new Object().getClass() {}
• 无需急切地捕获整个堆栈跟踪，这可能代价高昂

在这篇文章中阅读更多内容。