Android 文件读写和写入日志

已于 2022-03-13 18:16:15 修改
阅读量1.4k 收藏 2
点赞数
分类专栏： android基础 文章标签： android
于 2022-03-13 11:51:59 首次发布
原文链接：https://blog.csdn.net/huweiliyi/article/details/105658384
版权

1.读取raw下的text文件

InputStream inputStream = null;
        Reader reader = null;
        BufferedReader bufferedReader = null;
        try {
            //得到资源中的Raw数据流
            inputStream = getResources().openRawResource(R.raw.test);
            reader = new InputStreamReader(inputStream);// 字符流
            bufferedReader = new BufferedReader(reader); //缓冲流
            StringBuilder result = new StringBuilder();
            String temp;
            while ((temp = bufferedReader.readLine()) != null) {
                result.append(temp);
            }
            Log.i("MainActivity", "result:" + result);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bufferedReader != null) {
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

2.读取assets下的text文件

 InputStream inputStream = null;
        Reader reader = null;
        BufferedReader bufferedReader = null;
        try {
            //得到资源中的asset数据流
            inputStream = getResources().getAssets().open("test.txt");
            reader = new InputStreamReader(inputStream);// 字符流
            bufferedReader = new BufferedReader(reader); //缓冲流
            StringBuilder result = new StringBuilder();
            String temp;
            while ((temp = bufferedReader.readLine()) != null) {
                result.append(temp);
            }
            Log.i("MainActivity", "result:" + result);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bufferedReader != null) {
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

读写 data/data/包名 

     //写
        String text = "hello world 666";
        File file1=new File("/data/data/com.example.myapplication/","test.txt");
        FileOutputStream fileOutputStream = null;//com.example.myapplication
        try {
            fileOutputStream = new FileOutputStream(file1);
            fileOutputStream.write(text.getBytes());
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if (fileOutputStream != null) {
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }



//读

 InputStream inputStream = null;
        Reader reader = null;
        BufferedReader bufferedReader = null;
        try {
            File file=new File("/data/data/com.example.myapplication/", "test.txt");
            inputStream = new FileInputStream(file);
            reader = new InputStreamReader(inputStream);
            bufferedReader = new BufferedReader(reader);
            StringBuilder result = new StringBuilder();
            String temp;
            while ((temp = bufferedReader.readLine()) != null) {
                result.append(temp);
            }
            Log.i("MainActivity", "result:" + result);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bufferedReader != null) {
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

/mnt/sdcard目录文件读写

/storage/emulated/0/Android/data/com.example.myapplication/files

private void readSdcard() {
        InputStream inputStream = null;
        Reader reader = null;
        BufferedReader bufferedReader = null;

        File[] externalStorageVolumes =
                ContextCompat.getExternalFilesDirs(getApplicationContext(), null);
        File primaryExternalStorage = externalStorageVolumes[0];
//                File file2 = new File(this.getFilesDir().getPath() + "test5.txt"); //  写到 /data 目录下面
        Log.d("测试 primaryExternalStorage", "writeSdcard: " + primaryExternalStorage.getPath());
        File file = new File(primaryExternalStorage, "test5.txt");
        try {
            inputStream = new FileInputStream(file);
            reader = new InputStreamReader(inputStream);
            bufferedReader = new BufferedReader(reader);
            StringBuilder result = new StringBuilder();
            String temp = null;
            while (true) {
                try {
                    if (!((temp = bufferedReader.readLine()) != null)) break;
                } catch (IOException e) {
                    e.printStackTrace();
                }
                result.append(temp);
            }
            Log.i("MainActivity 读取到", "result:" + result);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bufferedReader != null) {
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }


//        if (Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())) {
//            if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
//                InputStream inputStream = null;
//                Reader reader = null;
//                BufferedReader bufferedReader = null;
//                try {
//                    File storage = Environment.getExternalStorageDirectory();
//                    File tmepfile = new File(storage.getPath());
//                    File file=new File(tmepfile, "test.txt");
//                    inputStream = new FileInputStream(file);
//                    reader = new InputStreamReader(inputStream);
//                    bufferedReader = new BufferedReader(reader);
//                    StringBuilder result = new StringBuilder();
//                    String temp;
//                    while ((temp = bufferedReader.readLine()) != null) {
//                        result.append(temp);
//                    }
//                    Log.i("MainActivity", "result:" + result);
//
//                } catch (Exception e) {
//                    e.printStackTrace();
//                } finally {
//                    if (reader != null) {
//                        try {
//                            reader.close();
//                        } catch (IOException e) {
//                            e.printStackTrace();
//                        }
//                    }
//                    if (inputStream != null) {
//                        try {
//                            inputStream.close();
//                        } catch (IOException e) {
//                            e.printStackTrace();
//                        }
//                    }
//                    if (bufferedReader != null) {
//                        try {
//                            bufferedReader.close();
//                        } catch (IOException e) {
//                            e.printStackTrace();
//                        }
//                    }
//                }
//            }
//        }
    }





 private void writeSdcard() {
        String text = "hello world 我是写入的数据";

        File[] externalStorageVolumes =
                ContextCompat.getExternalFilesDirs(getApplicationContext(), null);
        File primaryExternalStorage = externalStorageVolumes[0];
//                File file2 = new File(this.getFilesDir().getPath() + "test5.txt"); //  写到 /data 目录下面
        Log.d("测试 primaryExternalStorage", "writeSdcard: " + primaryExternalStorage.getPath());
        File file1 = new File(primaryExternalStorage, "test5.txt");
        if (!file1.exists()) {
            try {
                file1.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        FileOutputStream fileOutputStream = null;
        try {
            fileOutputStream = new FileOutputStream(file1);
            fileOutputStream.write(text.getBytes());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (fileOutputStream != null) {
                try {
                    fileOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

//        if (Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState())) {
//            if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
//                File storage = Environment.getExternalStorageDirectory();
//                File tmepfile = new File(storage.getPath());
//                if (! tmepfile.exists()) {
//                    tmepfile.mkdirs();
//                }
//                File file1=new File(tmepfile,"test.txt");
//
//                if (!file1.exists()){
//                    try {
//                        file1.createNewFile();
//                    } catch (IOException e) {
//                        e.printStackTrace();
//                    }
//                }
//                FileOutputStream fileOutputStream = null;
//                try {
//                    fileOutputStream = new FileOutputStream(file1);
//                    fileOutputStream.write(text.getBytes());
//                } catch (Exception e) {
//                    e.printStackTrace();
//                }finally {
//                    if (fileOutputStream != null) {
//                        try {
//                            fileOutputStream.close();
//                        } catch (IOException e) {
//                            e.printStackTrace();
//                        }
//                    }
//                }
//            }
//        }
    }

写的是安卓11的 注解是博主写的

 <!--文件读写权限-->
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
<application 
   android:name="builder.Myapp">
        
    </application>


//Application 
public class Myapp extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        MyLog crashHandler = MyLog.getInstance();
        crashHandler.init(this);
    }
}


public class MyLog {
    public  Context context;
    private MyLog() { }
    private static MyLog instance = new MyLog();
    public static MyLog getInstance() {
        return instance;
    }
    public MyLog init(Context context) {
        this.context = context;
        MYLOG_PATH_SDCARD_DIR="/data/data/"+context.getPackageName()+"/";
        return this;
    }
    //记得改包名
    private  String MYLOG_PATH_SDCARD_DIR ;// 日志文件的路径
    private static String MYLOG_FILE_NAME = "-Log.txt";// 日志文件名称
    private static Boolean MYLOG_SWITCH = true; // 日志文件总开关
    private static Boolean MYLOG_WRITE_TO_FILE = true;// 日志写入文件开关
    private static char MYLOG_TYPE = 'v';// 输入日志类型，w代表只输出告警信息等，v代表输出所有信息
    private static int SDCARD_LOG_FILE_SAVE_DAYS = 5;// sd卡中日志文件的最多保存天数
    private static String MYLOGFILEName = "Log.txt";// 本类输出的日志文件名称
    private static SimpleDateFormat myLogSdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// 日志的输出格式
    private static SimpleDateFormat logfile = new SimpleDateFormat("yyyy-MM-dd");// 日志文件格式

    public  void w(String tag, Object msg) { // 警告信息
        log(tag, msg.toString(), 'w');
    }
    public  void e(String tag, Object msg) { // 错误信息
        log(tag, msg.toString(), 'e');
    }
    public  void d(String tag, Object msg) {// 调试信息
        log(tag, msg.toString(), 'd');
    }
    public  void i(String tag, Object msg) {//
        log(tag, msg.toString(), 'i');
    }
    public  void v(String tag, Object msg) {
        log(tag, msg.toString(), 'v');
    }
    public  void w(String tag, String text) {
        log(tag, text, 'w');
    }
    public  void e(String tag, String text) {
        log(tag, text, 'e');
    }
    public  void d(String tag, String text) {
        log(tag, text, 'd');
    }
    public  void i(String tag, String text) {
        log(tag, text, 'i');
    }
    public  void v(String tag, String text) {
        log(tag, text, 'v');
    }

    /**
     * 根据tag, msg和等级，输出日志
     * @param tag
     * @param msg
     * @param level
     */
    private  void log(String tag, String msg, char level) {
        if (MYLOG_SWITCH) {//日志文件总开关
            if ('e' == level && ('e' == MYLOG_TYPE || 'v' == MYLOG_TYPE)) { // 输出错误信息
                Log.e(tag, msg);
            } else if ('w' == level && ('w' == MYLOG_TYPE || 'v' == MYLOG_TYPE)) {
                Log.w(tag, msg);
            } else if ('d' == level && ('d' == MYLOG_TYPE || 'v' == MYLOG_TYPE)) {
                Log.d(tag, msg);
            } else if ('i' == level && ('d' == MYLOG_TYPE || 'v' == MYLOG_TYPE)) {
                Log.i(tag, msg);
            } else {
                Log.v(tag, msg);
            }
            if (MYLOG_WRITE_TO_FILE)//日志写入文件开关
                writeLogtoFile(String.valueOf(level), tag, msg);
        }
    }

    /**
     * 打开日志文件并写入日志
     * @param mylogtype
     * @param tag
     * @param text
     */
    @SuppressLint("LongLogTag")
    private  void writeLogtoFile(String mylogtype, String tag, String text) {// 新建或打开日志文件
        Date nowtime = new Date();
        String needWriteFiel = logfile.format(nowtime);
        String needWriteMessage = myLogSdf.format(nowtime) + "    " + mylogtype + "    " + tag + "    " + text;

        // data/data/包名下面 不能直接打开看,可以用设备文件浏览器打开看 开发测试用
//        File file=new File(MYLOG_PATH_SDCARD_DIR,needWriteFiel+MYLOG_FILE_NAME);

        //内部存储设备/Android/data/包名/files 文件保存在手机上 可以打开来看
        File[] externalStorageVolumes = ContextCompat.getExternalFilesDirs(context.getApplicationContext(), null);
        File primaryExternalStorage = externalStorageVolumes[0];
        Log.d("测试 primaryExternalStorage", "writeSdcard: " + primaryExternalStorage.getPath());
        File file = new File(primaryExternalStorage, needWriteFiel+MYLOG_FILE_NAME);


        if (!file.exists()) {
            try {
                //在指定的文件夹中创建文件
                file.createNewFile();
            } catch (Exception e) {
            }
        }
        try {
            FileWriter filerWriter = new FileWriter(file, true);// 后面这个参数代表是不是要接上文件中原来的数据，不进行覆盖
            BufferedWriter bufWriter = new BufferedWriter(filerWriter);
            bufWriter.write(needWriteMessage);
            bufWriter.newLine();
            bufWriter.close();
            filerWriter.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

//    /**
//     * 删除制定的日志文件
//     */
//    public  void delFile() {// 删除日志文件
//        String needDelFiel = logfile.format(getDateBefore());
//        File dirPath = Environment.getExternalStorageDirectory();
//        File file = new File(dirPath, needDelFiel + MYLOGFILEName);// MYLOG_PATH_SDCARD_DIR
//        if (file.exists()) {
//            file.delete();
//        }
//    }
//    /**
//     * 得到现在时间前的几天日期，用来得到需要删除的日志文件名
//     */
//    private  Date getDateBefore() {
//        Date nowtime = new Date();
//        Calendar now = Calendar.getInstance();
//        now.setTime(nowtime);
//        now.set(Calendar.DATE, now.get(Calendar.DATE) - SDCARD_LOG_FILE_SAVE_DAYS);
//        return now.getTime();
//    }
}







//下面是activity 调用

    private static final int REQUEST_EXTERNAL_STORAGE = 1;
    private static String[] PERMISSIONS_STORAGE = {"android.permission.READ_EXTERNAL_STORAGE",
            "android.permission.WRITE_EXTERNAL_STORAGE"};
    private void initView() {
        checkPermission();
    }
    private void checkPermission() {
        //检查权限（NEED_PERMISSION）是否被授权 PackageManager.PERMISSION_GRANTED表示同意授权
        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE)
                != PackageManager.PERMISSION_GRANTED) {
            if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission
                    .WRITE_EXTERNAL_STORAGE)) {
                Toast.makeText(this, "请开通相关权限，否则无法正常使用本应用！", Toast.LENGTH_SHORT).show();
            }
            //申请权限
            ActivityCompat.requestPermissions(this, PERMISSIONS_STORAGE, REQUEST_EXTERNAL_STORAGE);

        }
    }
    @Override
    public void onRequestPermissionsResult(int requestCode, String permissions[], int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        switch (requestCode) {
            case REQUEST_EXTERNAL_STORAGE: {
                if (grantResults.length > 0
                        && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    MyLog.getInstance().e("*****","我是测试数据log ggg");
                } else {
                    Toast.makeText(this, "授权被拒绝！", Toast.LENGTH_SHORT).show();
                }
                return;
            }
        }
    }

日志是基于安卓11的

day_moon
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android 文件读写
清山博客
02-07 1万+
代码中有个openFileInput的方法，这个方法是Android内置的，需放在Activity中才能执行。手动获取拼接data目录下文件路径，然后用通用的文件读写方式进行读写。这个位置的读写有提供一套单独的API来读写，无需申明特殊权限。通用读写文件的辅助类，FileHelper.java。二、扩展SD卡（包括虚拟的内置SD卡和外置SD卡）；一、内置data目录下对应app名称的目录；
Android 实用工具类-日志文件的读写工具类
苏法迪的专栏
07-28 674
1. UI 效果 例如我们需要采集温度信息，可以不断写入一行一行的txt文本，读写文件操作即可 2. 调用示例 2.1 需要配置SD卡读写权限 &lt;uses-sdk android:minSdkVersion="17" android:targetSdkVersion="17" /&gt; &lt;!-- 往sdcard...
最全Android高性能日志写入方案-mmap，android高级开发工程师面试题
最新发布
2401_84520150的博客
05-10 871
希望本文对你有所启发，有任何面试上的建议也欢迎留言分享给大家。好了，今天的分享就到这里，如果你对在面试中遇到的问题，或者刚毕业及工作几年迷茫不知道该如何准备面试并突破现状提升自己，对于自己的未来还不够了解不知道给如何规划，来看看同行们都是如何突破现状，怎么学习的，来吸收他们的面试以及工作经验完善自己的之后的面试计划及职业规划。好了~如果你看到了这里，觉得文章写得不错就给个赞呗？如果你觉得那里值得改进的，请给我留言。一定会认真查询，修正不足。
Android开发创建txt文件并读写txt文件数据
Run的博客
01-08 6736
基于Android studio设计的创建txt文件并读写数据的操作设计说明
Android 日志框架使用
x995630736的博客
04-23 824
Log打印日志会记录到系统日志中，可以取出系统日志然后通过tag过滤得到自己的log，不过系统日志比较大，一般只能保存一段时间的日志，所以我们需要把日志单独记录到自己的文件中，这样就不会被系统日志冲掉了。在实际开发中，经常会遇到需要打印日志并保存到文件中，便于后面取日志分析代码运行情况，当然如果只是打印日志不需要记录文件，使用android自带的log工具就完全够了，3、创建自己的日志文件路径和文件名，我的日志路径如下，会在sdcard目录下生产LOG目录，
（原创）手写一个安卓日志框架
Android_xiong_st的博客
08-12 508
问题引入 其实之前有写过一个简单的日志框架 （原创）分享自己写的几个工具类（十）文件日志记录工具 但是这个工具类有几个问题 1：在主线程执行写日志功能，有一点不太好 2：改造不好，可能存在多个线程去读写同一个文件的问题 3：日志没有存储容量上限 4：日志无法压缩，无法适应“压缩后传送到服务器”的需求 所以我在原来工具类的基础上，做了一下优化和改造 于是一个新的日志框架诞生了！！！ 新的日志工具类，主要就是解决这几个问题的 文章尾部会贴出主代码和使用方式 现在开始对这个工具类进行一个基础介绍： 问题1 首先，
Android 逐行写入和读取文本文件Demo
09-29
总结，Android Studio 3.2中的"Android 逐行写入和读取文本文件Demo"涵盖了基本的文件操作概念，包括文件流的获取、缓冲流的使用以及文件的读写方法。这些知识对于任何Android开发者来说都是基础且重要的。通过实践...
Android日志文件的读写工具类
08-19
总结来说，Android日志文件的读写工具类简化了开发过程中与文件操作相关的任务，提供了一种便捷的方式来记录和管理应用程序的日志信息。通过合理使用此类，开发者可以更好地追踪程序运行状态，进行问题排查，同时也...
Android文件操作（写入和读取）
11-27
在Android开发中，文件操作是不可或缺的一部分，无论是存储用户数据、日志，还是保存应用程序的配置文件，都需要对文件进行读写操作。本教程将针对Android中的文件操作进行详细介绍，帮助新手快速掌握这一基础技能。...
Android读写文件工具类详解
08-19
Android读写文件工具类详解 Android读写文件工具类是一种非常实用的工具类，能够帮助开发者快速实现Android平台下的文件读写操作。下面我们将详细介绍该工具类的实现原理和使用方法。 首先，让我们来看一下该工具...
Android文件读取以及写入操作
LazyDer_Pig的博客
02-20 1669
这是过年回来后第一个周末，心血来潮想复习一下java的知识 然后就有了这篇文章。 为什么写这篇文章呢说起来有点尴尬，对于读取写入这个操作我竟然没写出来，俗话说的好，“温故而知新”在这里强调一下温习的好处，希望各位也能在空闲时间内温习一下以前的知识。 其实我在写的过程中呢遇到很多问题，最终呢也是通过google解决了，其实我一直有一个疑问有的博客他是写的东西是错误的，导致我们找不到正确的解决方法，这是我一直疑惑的一点。话不多说来看一下我们今天的内容。 在这里说明一下今天这篇文章主要讲的是data/data/.
用LogWriter将Android应用程序的日志信息写入文件
05-23
用LogWriter将Android应用程序的日志信息写入文件，存放文件的路径和命名方式都可以修改的
Android写LOG日志到SD卡文件之microlog4android使用
04-18
Android写LOG日志到SD卡文件之microlog4android使用
android 系统日志写入sd卡
zjy764219923的专栏
06-28 764
说明 公司有需求，将系统日志写入到SD卡（系统日志和内核日志）。 实现 添加位置：/device/qcom/msm8953_65 添加执行脚本：init.qcom.corelog.sh #!/system/bin/sh # # Script : init.qcom.corelog.sh # Function: Auto capture kernel,android log # Copyright (c) 2016,All rights reserved. # Author Wel
日志处理（文件的读出和写入）
zhu752050240的博客
08-20 893
前段时间公司的同事让我修复日志文件中报出的异常，上千条日志文件记录，报出的Exception和Error大同小异，若是用眼睛去看，岂不是要疯了的节奏，于是就想到了使用Java的IO读取文件和写入文件，对日志进行统计处理，然后再集中解决其中的Exception和Error。下面是代码和思路解析，菜鸟上路，欢迎指正。 gourmetgarden.com.my http://www.gourmetg
android 日志权限,入门篇：11.Android中日志系统和权限系统(示例代码)
weixin_42523104的博客
05-30 849
一、安卓中的日志系统1.java中常用的两个日志System.out.println();//普通日志System.err.println();//警告日志2.android中常用的日志种类Log.e(Tag,"错误信息");Log.w(Tag,"警告信息");Log.i(Tag,"普通信息");Log.d(Tag,"调试信息");Log.v(Tag,"无用信息");ps：这个log.v神奇的地方...
Android面试题 | 怎么写一个又好又快的日志库？
夏夏的博客
07-28 270
简单是任何一个库设计都要考虑的首要问题。“简单”和“弹性”是库设计中首要关注的两个方面。Kotlin有诸多语法特性能极大地降低代码的复杂度。真责任链模式非常适用于为日志库提供弹性。它使得动态为日志库新功能成为可能，它使得每次的处理结果得以在传递给后续处理者。用HandlerThread实现异步串行日志输出。用Okio实现高性能的日志文件化。在高频日志文件化的场景下，复用输出流能极大地提高性能。同时需要延迟消息机制保证日志的完整性。作者唐子玄链接https。......
android创建写日志文件
weixin_38125090的博客
05-08 2881
public class NaviDebug { public static NaviDebug m_instance = null; String m_filename; String SDPATH; protected NaviDebug() { SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");// 设置日期格式...
android读写文本文件,Android写入日志文本文件
weixin_42314860的博客
05-25 727
天涯尽头无女友对于那些刚接触Java日志记录和Android日志记录的人Log4j是通用的Java日志记录实现，现在是Apache软件基础的一个项目。它不是Android特定的，因此与Android有一些不兼容性。SL4J不是日志记录实现，它是一个抽象层。它有助于避免每个第三方库依赖于项目的情况，尝试使用自己的日志记录实现，如Log4j。来源。在Android中记录到txt的一些选项如下使用log...
android日志输出到文件
05-27
在Android中，您可以使用Logcat来输出日志信息。如果您想要将日志信息输出到文件中，您可以使用以下代码： ```java File logFile = new File(Environment.getExternalStorageDirectory(), "myLog.txt"); try { ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值