我经常陷入这种状态。Logcat为空。调试工作，我可以击中断点。没有设置过滤器。日志级别为“Verbose”。我通过以下反复循环来修复它:

重新启动logcat(参见上面Zatziky的回答) 将日志级别更改为Debug(或其他级别)，然后返回Verbose。 拔下并插回设备 运行adb kill-server && adb start-server 关闭Android Studio并在命令行上启动ddms。 重启Android Studio

最后，如果一切都失败了，重新启动计算机。

这个问题是间歇性的，我认为Android Studio就是有bug。

这可能不是你的问题，但我发现当Android Studio打开多个窗口时，logcat只指向其中一个，而不一定是正在运行活动应用程序的那个。

例如，窗口1是我开发一字棋应用程序的地方，窗口2是我开发天气应用程序的地方。如果我在调试模式下运行天气应用程序，可能只有窗口1能够显示logcat条目。

需要连续两次按“Alt+6”重新启动logcat窗口。这样它就会显示日志输出。

问题主要发生在调试模式。

在Android studio 0.8.0中，您应该在运行应用程序之前通过Tools -> Android启用ADB集成。然后日志猫将正常工作。请注意，如果您在应用程序运行时禁用ADB集成，然后再次启用它，那么日志猫不会显示任何东西，除非您重新构建项目。

Logcat的右边有一个小图标。您可以使用该图标打开和关闭logcat。我通常可以通过单击图标(可能几次)使logcat激活。

重新启动logcat总是对我有帮助。

在Android Studio 0.8.9中，我打开Android设备监视器，从设备列表中选择模拟器，并在LogCat选项卡中获得输出。

之后，我回到Android Studio的主视图，在Android DDMS选项卡的右侧选择Restore Logcat视图，它就在那里!

如果这不起作用，你可以在Android设备监视器中看到你的日志猫，就像我在第一句话中解释的那样。

全核解决方案。只有在尝试了所有其他方法后才使用这个方法，因为这将删除您所有的设置和首选项，以及存储的图像和所有使您的模拟器运行的东西，直到您重新安装和重新配置。以我为例，这两个步骤都花了大约20分钟，因为除了使用Darcula外，我没有进行太多自定义。

删除你的。androidstudiobeta配置文件目录

对于linux用户，这可以在/home/[username]/下找到。AndroidStudioBeta 对于windows用户，我不确定。在我看来，关于它的文件相当模糊。可能在C:\Users[你的用户]\Application Data下面

检查它是否工作，如果不能，然后重新安装SDK。

相当激烈，但我尝试了这个页面上的所有其他东西，连接设备，没有过滤器，重新启动服务，这个页面上的所有东西，它就是不工作。

对我来说，它不仅适用于我的应用程序，它正在工作，如果没有选择过滤器(右侧的选项)。但我只需要看到我的应用程序，因此我发现，如果我做我自己的过滤器，过滤它的包名，它是工作，因为它应该。我希望它也能帮助到你:)

我的问题解决了，在我添加android:debuggable="true"下应用程序在你的androimanifes .xml(甚至ide标记为错误的语法!????)

确保您已经在build variables上下文菜单中启用了构建变量以“调试”。(你可以在窗口的左下角找到它)。如果您之前已经为应用程序签署了apk，则此选项将被设置为发布模式。这将导致调试消息不显示在日志猫中。

今天也遇到了同样的问题。

显然，我也运行了eclipse，所有的logcat输出都被重定向到eclipse。由于日志只能在一个地方显示，请确保您没有运行多个调试器。

在android Studio应用程序中，您需要单击调试应用程序选项(Shift+f9)以调试模式运行并启用LogCat。

所有这些都无济于事，我的日志猫功能失常。

After a lot of angry searching I found a solution that seems to work: 1. Make sure logcat itself is working (use DDMS from Tools->Android) and if it does close DDMS window again 2. Now go to Tab 5 (Debug), there select Logcat (this is not the same logcat as in Window 6!) 3. The window is empty just like Window 6, but now start a debugging run. For me logcat in the Debug window now started to show all the stuff again! Also when normally running the application the Debug->logcat view is still functional while the Tool Window #6 "logcat" is disfunctional as before

这是一个黑客，但是它会导致正常的logcat行为，突出显示您调试和开发所需的行和语法。 从现在开始，您需要通过调试窗口访问它。

在“设备logcat”选项卡的右侧有一个按钮“只显示所选进程的logcat”。它并不完美，因为每次我运行另一个进程时，我都需要再次推动它，但这是唯一适合我的解决方案。到目前为止…

这不是一个技术性的答案，但您可能想要检查logcat的搜索框。如果输入了任何字符，你的logcat将为空，因为它将搜索特定的字符或单词，然后如果它不存在，你的logcat日志将完全为空。

检查一下你是否把它藏起来了……如果它隐藏的问题，通过给定的图像显示它或ALT + 6

Easy fix that worked for me (after trying some of these other suggestion). My logcat was sitting blank in a separate window (on my second screen). Just had to drag the Logcat tab back to it's original place in the debug panel next to the Debugger and Console tabs, and VOILA... it began immediately updating and showing all processes verbose. So (If your logcat is anywhere outside of the debugger panel (i.e. the logcat tab isn't sitting nested alongside the debugger and console tab) then it won't receive updates and will sit there blankly. Don't know if this is an issue with older versions of Android Studio. But again, easy to try and if it works... it works!!

**

如果你仍然被logcat为空所困扰，请阅读这篇文章

**

经过几个月的烦恼和麻烦，我刚刚解决了这个问题。 没有任何帮助，设备监视器在调试期间工作良好，但标准的logcat视图总是空的。

原因简单得令人恼火: logcat视图在那里，但它已被移动到0宽度的更新!

你在“ALT 6”选项卡，你看到两个选项卡“ADB日志”和“设备| logcat” Devices | logcat实际上意味着它由Devices和logcat组成，用垂直边界分隔。 垂直边界可以移动，在更新期间，它似乎已经移动到100%正确。

这将导致logcat被收集但不显示，将鼠标指针移动到工具窗口的右侧，并将logcat拖回视图。

这个解决方案不会帮助每个人，但我发现许多人与工作ADB连接仍然没有logcat输出，这些可能会受到同样的问题。

确保您导入了正确的类

import android.util.Log;

试试@Robert Karl在这篇文章中提到的观点。如果没有工作，那么你肯定可以通过android设备监视器看到日志。

启动android设备监视器 选择DDMS透视图 然后选择屏幕截图所示的设备。 您可以根据您的要求应用过滤器

修复一些不必要的更改的最佳方法是使缓存无效

转到FILE ->，单击“INVALIDATE CACHES/RESTART”，然后弹出一个对话框， 选择“无效缓存/重新启动”按钮。

Android studio将自动重新启动并重新构建索引。

执行->debug命令 如果你失去了与主机的连接，它会要求重新连接。单击yes。这样就行了。

这些帮助了我:

1.启用ADB集成 2. 进入Android设备监视器 检查您的设备是否在线，并创建所需的过滤器

我有同样的症状，但我的问题要简单得多，这真的是我的错误。我的滤镜设置错了。

解决方案只是验证我设置了正确的过滤器。

要运行Logcat，请重新启动Logcat，然后打开DDMS(要打开它，请单击Android DDMS右上角的Android图标)。设置“日志级别=调试”。然后运行你的应用。

我刚把它修好了。在DDMS显示的最右边寻找恢复Devices Logcat视图和ADB视图的小图标。

When the DDMS first came up with both the "ADB Logs" and the "Devices | logcat" tab showing. The "Devices | logcat" is the one that should be showing the device output, but was blank. Somehow I managed to hide one or the other of those tabs, I forget exactly how. But, off to the right there was a tiny icon that said "Restore ADB" view, and I clicked it and it came up. Then there was another tiny icon that said "Restore Devices logcat view". I clicked that, and all of a sudden it appeared and was showing the device output again.

我找到了三种解法。

在Android 4.0设备上调试(我之前在Android Lollipop设备上运行它)。 单击DDMS中的重启按钮。 启动Android设备监视器，你会发现logcat。祝你好运~

在我的例子中，它通过TCP连接断开，即使设备出现了。

调用

adb connect <device ip>

重启logcat OK。

我刚刚更改了applictionId和logcat停止工作。要重置它，您必须更改包的名称。只需点击右上角的下拉在Logcat窗口，显示你的应用程序包的名称，点击它，然后点击编辑过滤器配置，现在改变包的名称。它将开始工作。

尝试点击“Android”视图最右边的图标，你应该在Android视图上看到Logcat选项卡(你可以通过按Alt+6打开Android视图)

在我的情况下，我只是过滤了输出，所以即使在重新启动Logcat等后，它也显示为空。

如果同时使用多个版本的adb, Logcat可能会失败。一个在Android Studio，一个在终端。

你可能有不同版本的adb: sudo apt-get install android-tools-adb将创建/usr/bin/adb Android SDK包含{Android - SDK}/platform-tools/adb， 或者从创建/host/linux-x86/bin/adb的AOSP构建的输出

要查看这个问题是否影响到你，使用“Help -> Show Log in Files”打开idea.log，并寻找类似于“Initializing adb using:/home/repkap11/android-sdk/platform-tools/adb”的行。将此路径与终端中的“which adb”进行比较。如果它们不匹配，这个问题就会影响到您。

Android studio寻找{Android -sdk}/platform-tools/adb，并不关心你的PATH。我用符号链接替换了android-sdk中的adb版本，但简单地“sudo apt-get remove android-tools-adb”也可以。

试着关闭项目，然后重新打开它。这对我很有用。日志将重新出现。

就我而言，我试图用其他答案来解决这个问题，但没有结果。我无意中发现，空标签几乎从未显示(Android Studio 1.4)。因此，尝试在TAG中放入任何字母(空格无效)。

Log.wtf("x", "Android Studio Team, solve this, please!");

一些自定义rom出于性能原因禁用日志记录(尽可能压缩%)检查rom的内置应用程序或调整rom的菜单来启用此功能。

我在我的i9505上运行贵山的Galaxy S4 Rom，我不知道它默认禁用了日志记录，以获得最分钟的性能提升，但显然这在定制的“性能”导向型Rom上并不罕见。我花了一段时间才发现这一点-非常烦人，因为它会显示我有多少消息被记录，而不是他们的细节。

对我来说，问题是我有两个名称相同的模拟器(我创建了它，删除了它，然后用相同的名称再次创建它)。在logcat下拉菜单中有两个模拟器条目，它连接到错误的一个。我所要做的就是换到另一个。我通过重命名模拟器永久地避免了这个问题。

我的手机上有一个自定义ROM，由于某种原因没有输出logcat，但是模拟器和另一个设备可以输出。擦除并安装ROM使logcat重新工作。

我有同样的问题，但我解决了以下步骤，试一次。

1)在android工作室。

2)打开android Monitor窗口(android studio底部)

3)你可以看到右下角的下拉(旋转器)

4) select—只显示选中的应用程序。

重新启动Android Studio帮助了我。

在我的例子中，在开发人员选项菜单中有一个名为

撤销USB调试授权。

一旦你撤销所有现有的授权，它会再次要求信任你正在使用的计算机，之后它开始再次显示日志。

在我的例子中，我从右边的小下拉列表中删除了“image”。在那之后一切都很好。这是因为它将在日志中搜索搜索框中的关键字，因此如果没有找到任何匹配项，它将返回空白

首先确保在您的设备中启用了开发人员选项。 设备已连接。 详细的。 只显示选中的应用程序。

我尝试了上面的建议。然而，没有一个成功。然后我做了下面的事情，结果出乎意料地奏效了:

断开设备的USB接口 使用adb tcpip 5555和adb connect <device ip>命令通过Wi-Fi连接设备 使用adb kill-server断开设备与adb的连接 通过USB重新连接设备

然后LogCat显示日志。尽管在第2步时日志可用，但以下步骤在通过USB连接时为我解决了这个问题。

对我来说，问题在于设备是在“仅充电”模式下连接的。

将模式更改为媒体设备(MTP)(或在某些设备中传输文件)解决了问题。

这偶尔发生在我使用模拟器。我只需插入一个设备并运行应用程序。Logcat就可以继续工作，当我回到模拟器时它也可以这样做。 我想只要切换两个设备和/或模拟器就可以了。

确保在模拟器开发人员菜单选项中有记录器缓冲区大小适当值。

奇怪的是，即使是在最近版本的Android Studio上，仍然会遇到这个问题。我通读了一长串的解决方案，但它们对我不起作用。 接受的答案适用于早期版本的Android Studio(我猜是v2.3)

我做了以下让Logcat再次工作:

Logcat >只显示选中的应用>不显示过滤器

Logcat >不过滤>只显示选中的应用

我期望重置logcat应该理想地给我同样的效果，但它没有。手动切换滤镜是唯一有效的方法。

这是在Android Studio 3.0.1(稳定)(我不能在完成当前项目之前更新它) 问题发生在我早上启动Android工作室继续我晚上留下的工作时。我希望开发人员能研究一下这个问题。从stackoverflow中尝试了超过15个解决方案，仍然没有看到任何结果。为这个问题的未来受害者揭示另一种解决方案甚至令人恼火。

在终端中执行此命令。它将重新开始工作。

adb kill-server && adb start-server

好吧，我已经试过了所有其他的答案，没有一个对可怜的日志猫有效。 我对logcat的问题是，它从来没有工作开始。 当我安装Android studio并最终能够将设备连接到adb时，它从未给我输出。 这可能是由我的32位Windows 7设置造成的… 所以我写了一个批处理脚本，通过终端运行应用程序与logcat。

adb shell am start -n "com.package.name/com.package.name.Activity" -a android.intent.action.MAIN -c android.intent.category.LAUNCHER
adb shell pidof com.package.name > pid
for /f %%i in (pid) do (set pid=%%i)
echo %pid%
adb logcat *:V --pid=%pid%
ENDLOCAL

将这些文件连同正确的目录路径和包名一起放入logcat.bat(或其他任何文件)文件中。

将文件放在AndroidStudioProjects/package_name/文件夹中，然后你就可以运行了

用户C: \ \我\ AndroidStudioProjects \ package_name > logcat(或其他)

在终点站。

注意，您可以通过更改更改logcat显示的内容

*: V

在adb logcat命令中。(示例*:E只显示(E)错误标记)。

我希望这对其他人有所帮助。

在我的情况下，我发送空标签，即

Log.d("","My Log");

而是发送一个标记名称

Log.d("Class name","My Log");

希望它能帮助到别人

重新启动我正在测试的手机就解决了这个问题。

我用的是旧的LG4和Android 6。

我试着拔了又插，重新启动Android Studio，重新启动logcat，使缓存无效-什么都没有工作。

我检查了答案，只是在检查我的日志时偶然发现我的错误。 确保右边的方框显示“只显示选定的应用程序”。我的显示的是“Firebase”，所以它显示了来自Firebase的消息。

您可以在搜索中输入一些文本并过滤掉Logcat结果。 这就是我遇到问题的原因:)

步骤1:连接你的手机与Android开发者选项和USB调试。

步骤2:进入“查看>工具窗口> Logcat”

第三步:在运行项目之前，确保你的手机连接Android Studio。然后运行应用

注意:如果不能显示Logcat，请重新启动Android Studio: File > Invalid Caches/ Restart

在Android 3.6.1中，我必须:

升级到最新的Android Studio版本(4.x.x) 重启Logcat 重启应用程序 重启Android Studio 重新启动Android测试设备

除了所有好的答案之外:如果您使用BuildConfig，请确保您导入了正确的BuildConfig。我正在使用BuildConfig。所以有一天我的IDE自动导入了错误的类

import com.google.firebase.BuildConfig;

也可能是

import com.adjust.sdk.BuildConfig;

将import更改为正确的导入后，一切正常:

import com.yourapp.BuildConfig;

当其他方法都不管用的时候，我是这么做的。由于adb logcat工作得很好，我决定依赖它。在Android Studio的嵌入式终端中运行adb logcat -v color，输出与普通的logcat类似，并且允许代码链接工作:

但这也带来了一些问题:

您不能指定要监视的包。使用——pid=<your pid >选项，您可以查看单个进程的输出。但由于每次重新启动应用程序，PID都会发生变化，因此每次重新启动时都要重新运行此命令。 (在我看来)这些颜色令人讨厌。 输出字段没有与之前的消息对齐，整个事情没有很好地格式化，这使得跟踪logcat比它应该发生的要困难得多(尽管嵌入的logcat也发生了同样的情况)。

所以我决定制作自己的工具来自动监视我的包PID并美化logcat输出:

import java.awt.AWTException;
import java.io.*;
import java.util.ArrayList;
import java.awt.Robot;
import java.awt.event.KeyEvent;

public class Logcat {

    private static final String ADB_FILE_PATH = "adb";

    // Customizations,
    private static final Color     V_COLOR = Color.RESET;
    private static final Color     D_COLOR = Color.RESET;
    private static final Color     I_COLOR = Color.RESET;
    private static final Color     W_COLOR = Color.BLUE;
    private static final Color     E_COLOR = Color.RED_BRIGHT;
    private static final Color  HINT_COLOR = Color.MAGENTA_BOLD_BRIGHT;
    private static final Color OTHER_COLOR = Color.GREEN_BOLD_BRIGHT;

    private static final int       DATE_LENGTH =   5;
    private static final int       TIME_LENGTH =  12;
    private static final int PROCESS_ID_LENGTH =   5;
    private static final int  THREAD_ID_LENGTH =   5;
    private static final int  LOG_LEVEL_LENGTH =   1;
    private static final int        TAG_LENGTH =  20;
    private static final int    MESSAGE_LENGTH = 110;

    private static final String SEPARATOR = " | ";
    private static final String CONTINUATION = "→";
    private static final String INDENTATION = "  ";

    private static final int PROCESS_IDS_UPDATE_INTERVAL_MILLIS = 1224;

    private static final int HISTORY_LENGTH = 1000;

    // State,
    private static boolean skipProcessIDCheck;
    private static ArrayList<String> processIDs = new ArrayList<String>();

    private static String logLevelToShow="V";  // All.

    private static Process logcatProcess;
    private static boolean appClosed;
    private static boolean stopEverything;

    private static String[] history = new String[HISTORY_LENGTH];
    private static int currentLocationInHistory, historyLength;

    public static void main(final String args[]) {

        clearAndroidStudioConsole();
        System.out.println("besm Allah");

        // Get processes ids of the provided package,
        if (args.length==0) {
            skipProcessIDCheck = true;
        } else {
            skipProcessIDCheck = false;
            getProcessIDs    (args[0]);    // Do it once before we start.
            monitorProcessIDs(args[0]);    // Do it periodically from now on.
        }

        // Start capturing and prettifying logcat,
        if (!monitorLogcat()) {
            stopEverything = true;
            return;
        }

        // Handle user input,
        handleUserInput();
    }

    private static void watch(final Process process, final ProcessListener listener) {

        // Read process standard output and send it to the listener line by line,
        new Thread() {
            public void run() {
                BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
                String line = "";
                try {
                    do {
                        if (bufferedReader.ready()) {
                            line = bufferedReader.readLine();
                            if (line!=null && !line.isEmpty()) listener.onNewLine(line);
                        } else {
                            Thread.sleep(100);
                        }
                    } while (line!=null && !stopEverything);
                } catch (Exception e) { e.printStackTrace(); }
            }
        }.start();
    }

    private static void monitorProcessIDs(String packageName) {

        // Continuously monitor the process IDs of this package and update when changed,
        new Thread() {
            public void run() {
                do {
                    try { Thread.sleep(PROCESS_IDS_UPDATE_INTERVAL_MILLIS); } catch (InterruptedException e) {}
                    getProcessIDs(packageName);
                } while (!stopEverything);
            }
        }.start();
    }

    private static void getProcessIDs(String packageName) {

        // Get the process IDs associated with this package once,
        ArrayList<String> newProcessIDs = new ArrayList<String>();
        Runtime runtime = Runtime.getRuntime();
        try {
            Process getPIDProcess = runtime.exec(ADB_FILE_PATH + " shell ps");
            watch(getPIDProcess, (line) -> {
                if (line.contains(packageName)) {
                    newProcessIDs.add(removeRedundantSpaces(line).split(" ")[1]);
                }
            });
            getPIDProcess.waitFor();
            Thread.sleep(500);  // Make sure we've already handled all the input from the process.
        } catch (Exception e) { e.printStackTrace(); }

        // Return immediately if program is closed,
        if (stopEverything) return ;

        // Some action upon getting the pid(s),
        boolean shouldRepeatHistory = false;
        if (newProcessIDs.isEmpty()) {

            // Just closed,
            if (!appClosed) {
                appClosed = true;
                prettify("----- App closed -----");
            }
        } else if (appClosed) {

            // Just opened, clear,
            appClosed = false;
            clearAndroidStudioConsole();
            prettify("----- App opened -----");
            shouldRepeatHistory = true;
        } else {

            // Detect changes in processes,
            for (String pid : newProcessIDs) {
                if (!processIDs.contains(pid)) {
                    clearAndroidStudioConsole();
                    prettify("----- Process(es) changed (or app restarted - some logs could have been missed) -----");
                    shouldRepeatHistory = true;
                    break ;
                }
            }
        }

        // Set the new PID(s),
        processIDs = newProcessIDs;
        if (shouldRepeatHistory) repeatHistory();
    }

    private static boolean monitorLogcat() {

        Runtime runtime = Runtime.getRuntime();
        try {
            logcatProcess = runtime.exec(ADB_FILE_PATH + " logcat -v threadtime");
            watch(logcatProcess, (line) -> {

                // Learn history, in case we need to repeat it,
                if (appClosed || processLogcatLine(line)) {
                    history[currentLocationInHistory] = line;
                    currentLocationInHistory = (currentLocationInHistory + 1) % history.length;
                    if (historyLength<history.length) historyLength++;
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

        return true;
    }

    private static boolean processLogcatLine(String line) {
        try {
            return prettify(line);
        } catch (Exception e) {
            print(line, OTHER_COLOR);
            System.out.println();

            // Debug,
            e.printStackTrace();
            return true;
        }
    }

    // Returns true if line should be kept in history,
    private static synchronized boolean prettify(String line) {

        if (line.startsWith("-")) {
            // It's a "beginning of <something>" line,
            print(line, HINT_COLOR);
            System.out.println();
            return true;
        }

        // Get the individual fields,
        String      date = line.substring(0, line.indexOf(' ')); line = line.substring(line.indexOf(' ')+1); line = line.trim();
        String      time = line.substring(0, line.indexOf(' ')); line = line.substring(line.indexOf(' ')+1); line = line.trim();
        String processID = line.substring(0, line.indexOf(' ')); line = line.substring(line.indexOf(' ')+1); line = line.trim();

        // Break early if possible,
        if (!skipProcessIDCheck && !processIDs.contains(processID.trim())) return false;

        // Continue parsing,
        String  threadID = line.substring(0, line.indexOf(' ')); line = line.substring(line.indexOf(' ')+1); line = line.trim();
        String  logLevel = line.substring(0, line.indexOf(' ')); line = line.substring(line.indexOf(' ')+1); line = line.trim();

        // Break early if possible,
        switch (logLevel) {
            case "V": if (!"V"    .contains(logLevelToShow)) return true; break;
            case "D": if (!"VD"   .contains(logLevelToShow)) return true; break;
            case "I": if (!"VDI"  .contains(logLevelToShow)) return true; break;
            case "W": if (!"VDIW" .contains(logLevelToShow)) return true; break;
            case "E": if (!"VDIWE".contains(logLevelToShow)) return true; break;
        }

        // Continue parsing,
        String       tag = line.substring(0, line.indexOf(':')); line = line.substring(line.indexOf(':')+1); line = line.trim();

        // Because some tags have a trailing ":",
        if (line.startsWith(":")) {
            tag += ":";
            line = line.substring(1);
        }

        // Indent lines starting by "at",
        String indentation = "";
        if (line.startsWith("at ")) {
            indentation = "   " + INDENTATION;
            line = " " + INDENTATION + line;
        }

        // Print the prettified log,
        Color color;
        switch (logLevel) {
            case "V": color = V_COLOR; break;
            case "D": color = D_COLOR; break;
            case "I": color = I_COLOR; break;
            case "W": color = W_COLOR; break;
            case "E": color = E_COLOR; break;
            default:
                color = Color.RESET;
        }

        String fields = adjustLength(     date,       DATE_LENGTH) + SEPARATOR +
                        adjustLength(     time,       TIME_LENGTH) + SEPARATOR +
                        adjustLength(processID, PROCESS_ID_LENGTH) + SEPARATOR +
                        adjustLength( threadID,  THREAD_ID_LENGTH) + SEPARATOR +
                        adjustLength( logLevel,  LOG_LEVEL_LENGTH) + SEPARATOR +
                        adjustLength(      tag,        TAG_LENGTH) + SEPARATOR;

        // Split the message onto multiple lines if needed,
        String message = chunkPreservingParentheses(line, MESSAGE_LENGTH, 2);
        print(fields + message, color);
        System.out.println();

        while (line.length() > message.length()) {

            // Debug,
            //print(line, OTHER_COLOR);
            //System.out.println("Line: " + line.length() + "length: " + message.length() + ", cont: " + CONTINUATION.length() + "dent: " + indentation.length());
            //System.out.println();

            // Remove the already printed part.
            line = line.substring(message.length()-CONTINUATION.length());

            // Add a dot to make links work,
            boolean shouldAddDot=false;
            if (line.matches("^[^\\.]*\\(.*:[123456789][1234567890]*\\).*")) shouldAddDot = true;

            // Indent,
            line = (shouldAddDot ? "." : (indentation.isEmpty() ? "" : " ")) + indentation + line;

            // Take another chunk,
            message = chunkPreservingParentheses(line, MESSAGE_LENGTH, 2+indentation.length());

            // Front pad to align this part with the message body,
            String paddedMessage = message;
            for (int i=0; i<fields.length(); i++) paddedMessage = ' ' + paddedMessage;

            // Print,
            print(paddedMessage, color);
            System.out.println();
        }

        return true;  // Keep in local buffer.
    }

    private static String adjustLength(String text, int length) {
        while (text.length() < length) text += ' ';
        if (text.length() > length) {
            text = text.substring(0, length-CONTINUATION.length());
            text += CONTINUATION;
        }
        return text;
    }

    private static String chunkPreservingParentheses(String text, int length, int minChunckLength) {

        if (text.length() <= length) return text;

        // Take a chunk out of the text,
        String chunk = text.substring(0, length-CONTINUATION.length()) + CONTINUATION;

        // Check if a paranthesis was opened and not closed,
        int lastOpenParanthesisIndex = chunk.lastIndexOf('(');
        int lastCloseParanthesisIndex = chunk.lastIndexOf(')');
        if (lastCloseParanthesisIndex <= lastOpenParanthesisIndex) {  // Also works when either is not found.
            if (minChunckLength<1) minChunckLength = 1;
            if (lastOpenParanthesisIndex > minChunckLength+CONTINUATION.length()) { // Avoid endless loops.
                int includeParenthesisSize = (CONTINUATION.length()>0) ? 1 : 0;
                chunk = text.substring(0, lastOpenParanthesisIndex+includeParenthesisSize-CONTINUATION.length()) + CONTINUATION;
            }
        }

        return chunk;
    }

    private static void repeatHistory() {
        int index = currentLocationInHistory-historyLength;
        if (index < 0) index += history.length;
        for (int i=0; i<historyLength; i++) {
            processLogcatLine(history[index]);
            index = (index + 1) % history.length;
        }
    }

    private static void print(String text, Color color) {
        System.out.print(color);
        System.out.print(text);
        System.out.print(Color.RESET);
    }

    private static String removeRedundantSpaces(String text) {
        String newText = text.replace("  ", " ");
        while (!text.equals(newText)) {
            text = newText;
            newText = text.replace("  ", " ");
        }
        return text;
    }

    private static void clearAndroidStudioConsole() {

        // Couldn't find a reliable way to clear Intellij terminal scrollback, so we just print
        // a LOT of newlines,
        StringBuilder bunchOfNewLines = new StringBuilder();
        for (int i=0; i<124; i++) bunchOfNewLines.append(System.lineSeparator());
        System.out.print(bunchOfNewLines);

        // Scroll the current line to the top of the window,
        try {
            // If we are on Windows,
            new ProcessBuilder("cmd", "/c", "cls").inheritIO().start().waitFor();
        } catch (Exception e) {

            // We are not on Windows,
            bunchOfNewLines = new StringBuilder();
            for (int i=0; i<124; i++) bunchOfNewLines.append("\b\r");
            System.out.print(bunchOfNewLines);
        }
    }

    private static void handleUserInput() {

        // Line read. Unfortunately, java doesn't provide character by character reading out of the box.
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        String input = "";
        do {
            try {
                if (bufferedReader.ready()) {
                    input = input = bufferedReader.readLine().toUpperCase();

                    // Set log level,
                    if (input.equals("V")||input.equals("D")||input.equals("I")||input.equals("W")||input.equals("E")) {

                        if (!logLevelToShow.equals(input)) {
                            logLevelToShow = input;
                            clearAndroidStudioConsole();
                            repeatHistory();
                        }

                        prettify("----- Log level set to " + logLevelToShow + " -----");

                    } else if (input.equals("C")) {

                        // Clear screen and history,
                        clearAndroidStudioConsole();
                        historyLength = 0;
                    }
                } else {
                    Thread.sleep(100);
                }
            } catch (Exception e) { e.printStackTrace(); }

            // Check if the logcat process is still alive,
            if (!logcatProcess.isAlive()) {
                prettify("----- adb logcat process terminated -----");
                stopEverything = true;
            }

        } while (!stopEverything && !input.equals("Q"));

        // Allow all monitoring threads to exit,
        stopEverything = true;
    }

    interface ProcessListener {
        void onNewLine(String line);
    }

    enum Color {

        // Thanks to this answer: https://stackoverflow.com/a/51944613/1942069

        //Color end string, color reset
        RESET("\033[0m"),

        // Regular Colors. Normal color, no bold, background color etc.
        BLACK  ("\033[0;30m"),
        RED    ("\033[0;31m"),
        GREEN  ("\033[0;32m"),
        YELLOW ("\033[0;33m"),
        BLUE   ("\033[0;34m"),
        MAGENTA("\033[0;35m"),
        CYAN   ("\033[0;36m"),
        WHITE  ("\033[0;37m"),

        // Bold
        BLACK_BOLD  ("\033[1;30m"),
        RED_BOLD    ("\033[1;31m"),
        GREEN_BOLD  ("\033[1;32m"),
        YELLOW_BOLD ("\033[1;33m"),
        BLUE_BOLD   ("\033[1;34m"),
        MAGENTA_BOLD("\033[1;35m"),
        CYAN_BOLD   ("\033[1;36m"),
        WHITE_BOLD  ("\033[1;37m"),

        // Underline
        BLACK_UNDERLINED  ("\033[4;30m"),
        RED_UNDERLINED    ("\033[4;31m"),
        GREEN_UNDERLINED  ("\033[4;32m"),
        YELLOW_UNDERLINED ("\033[4;33m"),
        BLUE_UNDERLINED   ("\033[4;34m"),
        MAGENTA_UNDERLINED("\033[4;35m"),
        CYAN_UNDERLINED   ("\033[4;36m"),
        WHITE_UNDERLINED  ("\033[4;37m"),

        // Background
        BLACK_BACKGROUND  ("\033[40m"),
        RED_BACKGROUND    ("\033[41m"),
        GREEN_BACKGROUND  ("\033[42m"),
        YELLOW_BACKGROUND ("\033[43m"),
        BLUE_BACKGROUND   ("\033[44m"),
        MAGENTA_BACKGROUND("\033[45m"),
        CYAN_BACKGROUND   ("\033[46m"),
        WHITE_BACKGROUND  ("\033[47m"),

        // High Intensity
        BLACK_BRIGHT  ("\033[0;90m"),
        RED_BRIGHT    ("\033[0;91m"),
        GREEN_BRIGHT  ("\033[0;92m"),
        YELLOW_BRIGHT ("\033[0;93m"),
        BLUE_BRIGHT   ("\033[0;94m"),
        MAGENTA_BRIGHT("\033[0;95m"),
        CYAN_BRIGHT   ("\033[0;96m"),
        WHITE_BRIGHT  ("\033[0;97m"),

        // Bold High Intensity
        BLACK_BOLD_BRIGHT  ("\033[1;90m"),
        RED_BOLD_BRIGHT    ("\033[1;91m"),
        GREEN_BOLD_BRIGHT  ("\033[1;92m"),
        YELLOW_BOLD_BRIGHT ("\033[1;93m"),
        BLUE_BOLD_BRIGHT   ("\033[1;94m"),
        MAGENTA_BOLD_BRIGHT("\033[1;95m"),
        CYAN_BOLD_BRIGHT   ("\033[1;96m"),
        WHITE_BOLD_BRIGHT  ("\033[1;97m"),

        // High Intensity backgrounds
        BLACK_BACKGROUND_BRIGHT  ("\033[0;100m"),
        RED_BACKGROUND_BRIGHT    ("\033[0;101m"),
        GREEN_BACKGROUND_BRIGHT  ("\033[0;102m"),
        YELLOW_BACKGROUND_BRIGHT ("\033[0;103m"),
        BLUE_BACKGROUND_BRIGHT   ("\033[0;104m"),
        MAGENTA_BACKGROUND_BRIGHT("\033[0;105m"),
        CYAN_BACKGROUND_BRIGHT   ("\033[0;106m"),
        WHITE_BACKGROUND_BRIGHT  ("\033[0;107m");

        private final String code;

        Color(String code) { this.code = code; }
        @Override public String toString() { return code; }
    }
}

只需将这段代码转储到Logcat.java并使用以下方法进行编译:

javac Logcat.java

并在Android Studio的嵌入式终端中运行:

java Logcat <your.package.name>

例如:

java Logcat com.nomone.vr_desktop

结果如下所示:

它是高度可定制的，我在应用程序的第一部分分离了大部分选项，所以你可以很容易地调整颜色和格式。如果adb工具不在PATH环境变量中，只需在编译前在ADB_FILE_PATH变量中设置它的完整路径(在代码中)。

当应用程序正在运行时，您可以键入以下快捷方式:

C清除屏幕和本地缓冲区。 V, i, d, w, e来改变logcat的级别。 优雅地退出。Ctrl+c也可以。

不幸的是，在按完这些键后，您必须按回车键。似乎Java不允许在不编写系统特定代码的情况下从控制台输入单个字符。对不起!

免责声明

如果使用adb连接多个设备，这将不起作用。 我还没有彻底测试这个。我只在少数设备上使用过一段时间。 我还没有在Windows或Mac上测试，但我尽量避免使用任何特定于系统的东西，所以它应该仍然有效。

我希望这能解决你的问题:)

重新启动logcat。它是固定的

Windows用户:

使用脚本工具。确保您已经为系统设置了ADB环境。 Android Logcat脚本

保存到bat文件 编辑文件。用包id替换com.example.abc 双击打开文件或通过MobaXTerm打开(方便查找文本)

p/s:如果这个答案有帮助，让我们把我的回购星。谢谢!

检查log标记中是否有空格。如果标签由空格组成，则删除空格，然后运行。您将能够查看日志。

还要小心这个坏男孩(即使重新启动android studio也没有消失):

禁用并卸载您最近安装且不使用的任何插件。

如果你使用Android模拟器，你可以擦除数据，然后再次启动模拟器。只有这个对我有用

为我禁用验证应用程序通过USB和验证字节码 可调试的应用程序帮助我使logcat更加可靠。

确保您选择了正确的模拟器，并且模拟器选择器旁边的字段不为空(在Logcat控制台中)。

查看LogCat Sitteng 在我的情况下，我不检查每一件事，使我

我再次检查一切为我工作