一键清理工具类:主要清理 1.系统的内存 2.App的缓存 3.系统的临时文件 .apk .log .tmp .temp .back
package com.hitv.process;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.lang.reflect.Method;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;

import android.app.ActivityManager;
import android.app.ActivityManager.MemoryInfo;
import android.app.ActivityManager.RunningAppProcessInfo;
import android.app.ActivityManager.RunningTaskInfo;
import android.content.Context;
import android.content.Intent;
import android.content.pm.ActivityInfo;
import android.content.pm.ApplicationInfo;
import android.content.pm.IPackageDataObserver;

import android.content.pm.IPackageStatsObserver;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.pm.PackageStats;
import android.content.pm.PackageManager.NameNotFoundException;
import android.graphics.drawable.Drawable;
import android.os.RemoteException;
import android.util.Log;

/**
 * @author DongYinPing 1045612812@qq.com
 * @version 1.0 一键清理工具类:主要清理 1.系统的内存 2.App的缓存 3.系统的临时文件 .apk .log .tmp .temp;
 * */
public class CleanUtils {

    private Context cx;
    private ActivityManager am;
    private PackageManager pm;

    public CleanUtils(Context context) {
        super();
        cx = context;
        am = (ActivityManager) cx.getSystemService(Context.ACTIVITY_SERVICE);
        pm = cx.getPackageManager();
    }

    // ################################ 清理进程 ###################################

    /**
     * 获取进程白名单
     * */
    private List<String> getFilterPackgeName() {

        List<String> filterPackgeNames = new ArrayList<String>(); // 过滤一些进程

        ActivityInfo launcherInfo = new Intent(Intent.ACTION_MAIN).addCategory(
                Intent.CATEGORY_HOME).resolveActivityInfo(pm, 0);

        filterPackgeNames.add(launcherInfo.packageName); // Launcher
        filterPackgeNames.add("com.hitv.locker"); // 定时锁屏管理
        filterPackgeNames.add(cx.getPackageName()); // 自己
        filterPackgeNames.add(getCurTopPackgeName()); // 过滤正在运行的进程      

        return filterPackgeNames;
    }

    /**
     * 系统剩余的内存
     * */
    public float getSurplusMemory() {
        MemoryInfo info = new ActivityManager.MemoryInfo();
        am.getMemoryInfo(info);
        return (float) info.availMem / 1024 / 1024;
    }

    /**
     * 系统总内存
     * */
    public float getTotalMemory() {
        String str1 = "/proc/meminfo";
        String str2;
        String[] arrayOfString;
        long initial_memory = 0;
        try {
            FileReader fileReader = new FileReader(str1);
            BufferedReader bufferedReader = new BufferedReader(fileReader, 8192);
            str2 = bufferedReader.readLine();
            arrayOfString = str2.split("\\s+");
            initial_memory = Integer.valueOf(arrayOfString[1]);
            bufferedReader.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return (float) (initial_memory / 1024);
    }

    /**
     * 系统内存:当前使用百分比/字符串格式
     * */
    public String usePercentNumString() {
        float surplus_size = getSurplusMemory();// 剩余MB
        float all_size = getTotalMemory();// 总共MB
        // 小数不足2位,以0补足
        DecimalFormat decimalFormat = new DecimalFormat("0.00");
        String percentnum = decimalFormat
                .format((1 - surplus_size / all_size) * 100);
        return percentnum;
    }

    /**
     * 系统内存:当前使用百分比/数字格式
     * */
    public float usePercentNum() {// 用于清理后UI更新
        float surplus_size = getSurplusMemory();// 剩余MB
        float all_size = getTotalMemory();// 总共MB
        return (1 - surplus_size / all_size) * 100;
    }

    /**
     * 使用反射方法调用系统隐藏api：forceStopPackage 通过包名杀死进程
     * */
    public boolean forceStopPackageByPackageName(String packageName) {
        boolean forceSucceed = false;
        Class<ActivityManager> clazz = ActivityManager.class;
        Method method;
        try {
            method = clazz.getDeclaredMethod("forceStopPackage", String.class);
            method.invoke(am, packageName);
            forceSucceed = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return forceSucceed;
    }

    /**
     * 判断是否属于系统app
     * */
    public boolean isSystemApp(ApplicationInfo info) {
        if ((info.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0) {
            return false;// 表示是系统程序，但用户更新过，也算是用户安装的程序
        } else if ((info.flags & ApplicationInfo.FLAG_SYSTEM) == 0) {
            return false; // 一定是用户安装的程序
        }
        return true;
    }

    /**
     * 获取最顶层的app包名,若是自己，则指定为其上一个
     * */
    public String getCurTopPackgeName() {
        String curAppTaskPackgeName = null;
        String myPackageName = cx.getPackageName();
        List<RunningTaskInfo> appTask = am.getRunningTasks(Integer.MAX_VALUE);
        if (appTask.size() > 0) {
            curAppTaskPackgeName = appTask.get(0).topActivity.getPackageName();
            if (appTask.size() > 1) {
                if (curAppTaskPackgeName.equals(myPackageName)
                        && appTask.get(1) != null) {
                    curAppTaskPackgeName = appTask.get(1).topActivity
                            .getPackageName();
                }
            }
        }
        return curAppTaskPackgeName;
    }

    /**
     * 遍历所有正在运行的进程列表,将所有应用的信息传入AppInfo中
     * */
    public List<AppInfo> getRunningAppProcesses() {
        List<RunningAppProcessInfo> runningAppProcessInfos = am
                .getRunningAppProcesses();// 正在运行的进程
        List<AppInfo> appInfos = new ArrayList<AppInfo>();
        List<String> filterPackgeName = getFilterPackgeName();
        for (RunningAppProcessInfo appProcessInfo : runningAppProcessInfos) {
            AppInfo info = new AppInfo();
            int id = appProcessInfo.pid;
            info.setId(id);
            String appProcessName = appProcessInfo.processName;
            info.setIsFilterProcess(filterPackgeName.contains(appProcessName));// 需过滤的包名
            info.setPackageName(appProcessName);// 设置进程名
            try {
                ApplicationInfo applicationInfo = pm.getPackageInfo(
                        appProcessName, 0).applicationInfo;
                Drawable icon = applicationInfo.loadIcon(pm);
                info.setIcon(icon);
                String name = applicationInfo.loadLabel(pm).toString();
                info.setName(name);
                info.setIsSystemProcess(isSystemApp(applicationInfo));
                android.os.Debug.MemoryInfo[] memoryInfo = am
                        .getProcessMemoryInfo(new int[] { id });
                int memory = memoryInfo[0].getTotalPrivateDirty();
                info.setMemorySize(memory);
                appInfos.add(info);
                info = null;
            } catch (Exception e) {
                // e.printStackTrace();
                info.setName(appProcessName);
                info.setIsSystemProcess(true);
            }
        }
        return appInfos;
    }

    /**
     * 过滤掉系统和白名单进程 获取最终要杀死的进程列表
     * */
    public ArrayList<AppInfo> getKillRunningAppProcesses() {
        ArrayList<AppInfo> killRunningAppProcesses = new ArrayList<AppInfo>();
        List<AppInfo> runningAppProcessInfos = getRunningAppProcesses();// 正在运行的进程
        for (int i = 0; i < runningAppProcessInfos.size(); i++) {
            AppInfo info = runningAppProcessInfos.get(i);
            if (!info.getIsSystemProcess() && !info.getIsFilterProcess()) {
                killRunningAppProcesses.add(info);
            }
        }
        return killRunningAppProcesses;
    }

    /**
     * 遍历进程列表并杀死
     * */
    public String killProcesses(ArrayList<AppInfo> appInfos) {
        float killMemorySize = 0;
        for (AppInfo appInfo : appInfos) {
            if (forceStopPackageByPackageName(appInfo.getPackageName())) {
                float size = appInfo.getMemorySize();
                Log.d("1----- DYP -----1","killProcesses-->>   packageName:" + appInfo.getPackageName()+ " | size:" + size);
                killMemorySize = killMemorySize + appInfo.getMemorySize();
            }
        }
        return numToString((float) killMemorySize / 1024);
    }

    // ################################ 清理文件 ###################################
    /**
     * 获取单个文件大小
     * */

    public float getFileSize(File file) {
        float size = 0;
        FileInputStream inputStream = null;
        try {
            inputStream = new FileInputStream(file);
            size = inputStream.available();
        } catch (Exception e) {
            Log.d("--- DYP --- getFileSize", "catch");
            // e.printStackTrace();
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (java.io.IOException e) {
                    e.printStackTrace();
                }
            }
        }

        return (float) size / 1024;
    }

    /**
     * 删除文件，并返回文件大小
     * */
    public String deleteFile(List<File> files) {
        float allFileSize = 0;
        float size = 0;
        for (File file : files) {
            size = getFileSize(file);
            Log.d("3----- DYP -----3", "deleteFile-->>  filePath:" + file.getPath()+ " | size:" + size);
            if(file.delete()){
                allFileSize = allFileSize + getFileSize(file);
            }
        }
        // list.clear();
        return numToString((float) allFileSize / 1024);
    }

    /**
     * 查找指定目录下的文件，
     * */
    List<File> fileList = new ArrayList<File>();

    public List<File> getallFiles(String sd, String[] clearType) {

        try {//遍历可能遇到.开头的文件

            File file = new File(sd);
            if (file.exists()) {
                File[] files = file.listFiles();
                for (int i = 0; i < files.length; i++) {
                    if (files[i].isDirectory()) {
                        getallFiles(files[i].getAbsolutePath(), clearType);// 递归查找
                    } else {
                        for (int j = 0; j < clearType.length; j++) {
                            if (files[i].getAbsolutePath().endsWith((clearType[j]))) {// 以.apk这些结尾
//                          if (files[i].getAbsolutePath().endsWith(".apk")) {
//                              if (isInstallApp(files[i].getAbsolutePath())) {// 安装过可以删除
//                                  fileList.add(files[i]);
//                              }
//                          } else {
//                              fileList.add(files[i]);
//                          }
                                fileList.add(files[i]);
                            }
                        }
                    }
                }
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return fileList;
    }

    // ################################ 清理缓存 ###################################

    float cacheSize = 0;

    /**
     * 使用反射方法调用系统隐藏api： getPackageSizeInfo 获取app缓存大小
     * */
    public float getPackageSizeInfo(final String packageName) {
        cacheSize = 0;
        try {
            Method method = PackageManager.class.getMethod(
                    "getPackageSizeInfo", new Class[] { String.class,
                            IPackageStatsObserver.class });
            method.invoke(pm, new Object[] { packageName,
                    new IPackageStatsObserver.Stub() {
                        @Override
                        public void onGetStatsCompleted(PackageStats pStats,
                                boolean succeeded) throws RemoteException {
                            cacheSize = pStats.cacheSize;
                        }
                    } });
        } catch (Exception e) {
            cacheSize = 0;
            // e.printStackTrace();
        }
        return cacheSize;
    }

    boolean isCleanCacheSucceed = false;

    /**
     * 使用反射方法调用系统隐藏api： deleteApplicationCacheFiles 返回清除是否成功
     * */
    private boolean deleteApplicationCacheFiles(String packageName) {
        isCleanCacheSucceed = false;
        try {
            Method method = PackageManager.class.getMethod(
                    "deleteApplicationCacheFiles", new Class[] { String.class,
                            IPackageDataObserver.class });
            method.invoke(pm, packageName, new IPackageDataObserver.Stub() {
                @Override
                public void onRemoveCompleted(String packageName,
                        boolean succeeded) throws RemoteException {
                    if(succeeded){
                        Log.d("DYP", "deleteApplicationCacheFiles -->> succeeded "+succeeded);
                        Log.d("DYP", "deleteApplicationCacheFiles -->> packageName "+packageName);
                    }
                    isCleanCacheSucceed = succeeded;
                }
            });
        } catch (Exception e) {
            // e.printStackTrace();
            Log.d("DYP", "deleteApplicationCacheFiles -->> catch ");
        }
        return isCleanCacheSucceed;
    }

    float allCacheSize = 0;

    /**
     * 清除所有安装app 返回的总缓存
     * */
    public String cleanCache(List<PackageInfo> packageInfos) {
        allCacheSize = 0;
        for (int i = 0; i < packageInfos.size(); i++) {
            String packageName = packageInfos.get(i).packageName;
            if (packageName != null) {
                float size = getPackageSizeInfo(packageName);
                //Log.d("2----- DYP -----2", "cleanCache-->  packageName:" + packageName+ " | size:" + size);
                if(deleteApplicationCacheFiles(packageName)){
                    allCacheSize = allCacheSize + size;
                    Log.d("2----- DYP -----2", "cleanCache-->  packageName:" + packageName+ " | size:" + size);
                }
            }
        }
        return numToString((float) allCacheSize / 1024);
    }

    /**
     * 判断app是否安装
     * */
    public boolean isInstallApp(String abPath) {
        PackageManager pm = cx.getPackageManager();
        try {
            pm.getPackageInfo(abPath, PackageManager.GET_ACTIVITIES);
            return true;
        } catch (NameNotFoundException e) {
            return false;
        }
    }

    /**
     * 获取所有已经安装的应用程序 ,包括那些卸载了的，但没有清除数据的应用程序
     * */
    public List<PackageInfo> getPackageInfos() {
        List<PackageInfo> packageInfos = pm.getInstalledPackages(PackageManager.GET_UNINSTALLED_PACKAGES);
        // List<ApplicationInfo> listAppcations = pm.getInstalledApplications(PackageManager.GET_UNINSTALLED_PACKAGES);
        return packageInfos;
    }

    // #############################  将float转化为字符串形式返回 #########################

    public String numToString(float f) {
        // 小数不足2位,以0补足
        DecimalFormat decimalFormat = new DecimalFormat("0.00");
        String s = decimalFormat.format(f);
        return s;
    }
    // ############################# 开始清理 并返回清理数据的大小 #########################
    /** 清除指定垃圾文件 */
    String[] clearType = { ".apk", ".log", ".tmp", ".temp", ".bak" };
    String SDCARD_ROOT = "/mnt/sdcard";

    public String startDeleteFile() {
        return deleteFile(getallFiles(SDCARD_ROOT, clearType));
    }

    public String startCleanCache() {
        return cleanCache(getPackageInfos());
    }

    public String startkillProcesses() {
        return killProcesses(getKillRunningAppProcesses());
    }
}

在Android设备中，我们经常会看到与系统或者应用相关的清除功能有：清除数据、清除缓存、一键清理，这么多清除功能对于一个程序猿就够难理解了，偏偏很多安卓设备上都有这些功能，对于用户来说就更难理解，趁着在把玩手机的时候想到了这一点，索引追根究底了解他们的具体区别。

清除数据和清除缓存

一键清理

清除数据、清除缓存、一键清理的区别

清除数据

  清除数据主要是清除用户配置，比如SharedPreferences、数据库等等，这些数据都是在程序运行过程中保存的用户配置信息，清除数据后，下次进入程序就和第一次进入程序时一样；

清除缓存

  缓存是程序运行时的临时存储空间，它可以存放从网络下载的临时图片，从用户的角度出发清除缓存对用户并没有太大的影响，但是清除缓存后用户再次使用该APP时，由于本地缓存已经被清理，所有的数据需要重新从网络上获取，注意：为了在清除缓存的时候能够正常清除与应用相关的缓存，请将缓存文件存放在getCacheDir()或者 getExternalCacheDir()路径下。比如对微信清除缓存，则聊天记录、朋友圈缓存的用户头像、图片、文字等信息都会被清除掉，清除缓存后再次进入微信时你会发现消息记录被清空了，朋友圈的图片和用户头像需要加载一会才能正常显示。

一键清理

  一键清理是系统级别的功能，它主要是杀后台进程，以达到释放内存的目的，但杀掉哪些进程和清理时设置的重要值阈值有关，重要值越大说明进程重要程度越低，如果在清理时某个进程的重要值大于该阈值，该进程就会被杀掉。比如微信等应用在后台，一件清理后会将微信和与之相关的服务都杀掉（有的服务做了特殊处理，杀不死！！！）。

参考资料

    What’s the difference between clear cache & clear data in android settings

    Android中系统设置中的清除数据究竟会清除哪些数据

    Android 一键清理、内存清理功能实现

    How to delete files created by the application on uninstall?

说明

  为了让程序被卸载后不在文件系统中留下毫无关联的无用文件，建议将应用相关的配置和缓存文件存放在程序被卸载时会删掉的文件夹下面（音乐文件、视频文件、图片、电子书这种适合多个应用阅读和浏览的文件除外），具体路径有：

    /data/data/package/

    getFilesDir()

    getCacheDir()

    getExternalCacheDir()(是否能够在程序被卸载时被删除与API的等级有关)

    getExternalFilesDir()(是否能够在程序被卸载时被删除与API的等级有关)

    在Android手机里面，缓存的位置分为两类，一类是Internal Storage，即内部存储，另外一类是External Storage，即外部存储。

    比较老的手机，有一个手机内部存储，还有一个SD卡存储，就是分别对应这两种存储位置，因为以前的SD卡是可以扩展的，即可拆卸的，所以可以用是否可拆卸作为内外存储的分类标准。

    但是现在最新的设备，比如小米、锤子、华为等，都取消了可拆卸的SD卡，直接与机身焊接在一起，分为16G、32G版本，所以现在内外存储的分类不再以是否可拆卸作为标准，而是以下面的几方面作为新的标准：

    内部存储

        总是可用的

        这里的文件默认是只能被你的app所访问的。

        当用户卸载你的app的时候，系统会把internal里面的相关文件都清除干净。

        Internal是在你想确保不被用户与其他app所访问的最佳存储区域。

    外部存储

        并不总是可用的，因为用户可以选择把这部分作为USB存储模式，这样就不可以访问了。

        是大家都可以访问的，因此保存到这里的文件是失去访问控制权限的。

        当用户卸载你的app时，系统仅仅会删除external根目录（getExternalFilesDir()）下的相关文件。

        External是在你不需要严格的访问权限并且你希望这些文件能够被其他app所共享或者是允许用户通过电脑访问时的最佳存储区域。

    文件位置

    内部存储

        getFileDir() 通过此方法可以获取到你的APP内部存储的文件，路径为/data/data/pacgage_name/files

        getCacheDir() 通过此方法可以获取到你的APP内部存储的文件，路径为/data/data/package_name/cache

        openFileOutput() 通过此方法，我们可以获取到一个输出流，输出流的保存路径是/data/data/package_name/files ，和getFileDir()的路径一致

    外部存储

    私有存储

        Context.getExternalCacheDir()

        Context.getExternalFilesDir()

    创建的私有文件的地址是/sdcard/Android/date/package_name下面，Android文件夹是隐藏文件夹，用户无法操作。

    如果我们想缓存图片等比较耗空间的文件，推荐放在getExternalCacheDir()所在的文件下面，这个文件和getCacheDir()很像，都可以放缓存文件，在APP被卸载的时候，都会被系统删除，而且缓存的内容对其他APP是相对私有的。

    公共存储

    你的APP产生的文件不需要隐藏，即对用户是可见的，那么你可以把文件放在外部的公共存储文件下面。这个方法不是Context的方法，而是Environment的两个方法，第一个方法获取到的其实是外部存储的根目录，而第二个方法获取到得则是外部存储的公共目录。其实在访问权限上是没有区别的，不同点是getExternalStoragePublicDirectory()在运行的时候，会需要你带有一个特定的参数来指定这些public的文件类型，以便于与其他public文件进行分类。

        Environment.getExternalStorageDirectory()

        Environment.getExternalStoragePublicDirectory()

    表现

    内部存储

    你的app的internal storage 目录是以你的app的包名作为标识存放在Android文件系统的特定目录下[data/data/com.example.xx]。 从技术上讲，如果你设置文件为可读的，那么其他app就可以读取你的internal文件。然而，其他app需要知道你的包名与文件名。若是你没有设置为可读或者可写，其他app是没有办法读写的。因此只要你使用MODE_PRIVATE ，那么这些文件就不可能被其他app所访问。

    另外记住一点，内部存储在你的APP卸载的时候，会一块被删除，因此，我们可以在cache目录里面放置我们的图片缓存，而且cache与files的差别在于，如果手机的内部存储控件不够了，会自行选择cache目录进行删除，因此，不要把重要的文件放在cache文件里面，可以放置在files里面，因为这个文件只有在APP被卸载的时候才会被删除。还有要注意的一点是，如果应用程序是更新操作，内部存储不会被删除，区别于被用户手动卸载。

    外部存储

    不管你是使用 getExternalStoragePublicDirectory() 来存储可以共享的文件，还是使用 getExternalFilesDir() 来储存那些对与你的app来说是私有的文件，有一点很重要，那就是你要使用那些类似DIRECTORY_PICTURES 的API的常量。那些目录类型参数可以确保那些文件被系统正确的对待。例如，那些以DIRECTORY_RINGTONES 类型保存的文件就会被系统的media scanner认为是ringtone而不是音乐。

    清除数据、清除缓存的区别

        清除数据主要是清除用户配置，比如SharedPreferences、数据库等等，这些数据都是在程序运行过程中保存的用户配置信息，清除数据后，下次进入程序就和第一次进入程序时一样

        缓存是程序运行时的临时存储空间，它可以存放从网络下载的临时图片，从用户的角度出发清除缓存对用户并没有太大的影响，但是清除缓存后用户再次使用该APP时，由于本地缓存已经被清理，所有的数据需要重新从网络上获取。为了在清除缓存的时候能够正常清除与应用相关的缓存，请将缓存文件存放在getCacheDir()或者 getExternalCacheDir()路径下。

 

前言

  在Android设备中，我们经常会看到与系统或者应用相关的清除功能有：清除数据、清除缓存、一键清理，这么多清除功能对于一个程序猿就够难理解了，偏偏很多安卓设备上都有这些功能，对于用户来说就更难理解，趁着在把玩手机的时候想到了这一点，索引追根究底了解他们的具体区别。







清除数据、清除缓存、一键清理的区别



清除数据

  清除数据主要是清除用户配置，比如SharedPreferences、数据库等等，这些数据都是在程序运行过程中保存的用户配置信息，清除数据后，下次进入程序就和第一次进入程序时一样；



清除缓存

  缓存是程序运行时的临时存储空间，它可以存放从网络下载的临时图片，从用户的角度出发清除缓存对用户并没有太大的影响，但是清除缓存后用户再次使用该APP时，由于本地缓存已经被清理，所有的数据需要重新从网络上获取，注意：为了在清除缓存的时候能够正常清除与应用相关的缓存，请将缓存文件存放在getCacheDir()或者 getExternalCacheDir()路径下。比如对微信清除缓存，则聊天记录、朋友圈缓存的用户头像、图片、文字等信息都会被清除掉，清除缓存后再次进入微信时你会发现消息记录被清空了，朋友圈的图片和用户头像需要加载一会才能正常显示。



一键清理

  一键清理是系统级别的功能，它主要是杀后台进程，以达到释放内存的目的，但杀掉哪些进程和清理时设置的重要值阈值有关，重要值越大说明进程重要程度越低，如果在清理时某个进程的重要值大于该阈值，该进程就会被杀掉。比如微信等应用在后台，一件清理后会将微信和与之相关的服务都杀掉（有的服务做了特殊处理，杀不死！！！）。



参考资料

What’s the difference between clear cache & clear data in android settings
Android中系统设置中的清除数据究竟会清除哪些数据
Android 一键清理、内存清理功能实现
How to delete files created by the application on uninstall?
说明

  为了让程序被卸载后不在文件系统中留下毫无关联的无用文件，建议将应用相关的配置和缓存文件存放在程序被卸载时会删掉的文件夹下面（音乐文件、视频文件、图片、电子书这种适合多个应用阅读和浏览的文件除外），具体路径有：

/data/data/package/
getFilesDir()
getCacheDir()
getExternalCacheDir()(是否能够在程序被卸载时被删除与API的等级有关)
getExternalFilesDir()(是否能够在程序被卸载时被删除与API的等级有关)

 

 

前言

 

  在Android设备中，我们经常会看到与系统或者应用相关的清除功能有：清除数据、清除缓存、一键清理，这么多清除功能对于一个程序猿就够难理解了，偏偏很多安卓设备上都有这些功能，对于用户来说就更难理解，趁着在把玩手机的时候想到了这一点，索引追根究底了解他们的具体区别。





清除数据、清除缓存、一键清理的区别

清除数据

  清除数据主要是清除用户配置，比如SharedPreferences、数据库等等，这些数据都是在程序运行过程中保存的用户配置信息，清除数据后，下次进入程序就和第一次进入程序时一样；

清除缓存

  缓存是程序运行时的临时存储空间，它可以存放从网络下载的临时图片，从用户的角度出发清除缓存对用户并没有太大的影响，但是清除缓存后用户再次使用该APP时，由于本地缓存已经被清理，所有的数据需要重新从网络上获取，注意：为了在清除缓存的时候能够正常清除与应用相关的缓存，请将缓存文件存放在getCacheDir()或者 getExternalCacheDir()路径下。比如对微信清除缓存，则聊天记录、朋友圈缓存的用户头像、图片、文字等信息都会被清除掉，清除缓存后再次进入微信时你会发现消息记录被清空了，朋友圈的图片和用户头像需要加载一会才能正常显示。

一键清理

  一键清理是系统级别的功能，它主要是杀后台进程，以达到释放内存的目的，但杀掉哪些进程和清理时设置的重要值阈值有关，重要值越大说明进程重要程度越低，如果在清理时某个进程的重要值大于该阈值，该进程就会被杀掉。比如微信等应用在后台，一件清理后会将微信和与之相关的服务都杀掉（有的服务做了特殊处理，杀不死！！！）。

参考资料


	
What’s the difference between clear cache & clear data in android settings
	
	

	
Android中系统设置中的清除数据究竟会清除哪些数据
	
	

	
Android 一键清理、内存清理功能实现
	
	

	
How to delete files created by the application on uninstall?
	
说明

  为了让程序被卸载后不在文件系统中留下毫无关联的无用文件，建议将应用相关的配置和缓存文件存放在程序被卸载时会删掉的文件夹下面（音乐文件、视频文件、图片、电子书这种适合多个应用阅读和浏览的文件除外），具体路径有：


	
/data/data/package/
	
	

	
getFilesDir()
	
	

	
getCacheDir()
	
	

	
getExternalCacheDir()(是否能够在程序被卸载时被删除与API的等级有关)
	
	

	
getExternalFilesDir()(是否能够在程序被卸载时被删除与API的等级有关)
	
 

--------------------------------------------------

 

 

Android 一键清理、内存清理功能实现：

 

360桌面、金山清理大师等都提供了一键清理、一键加速等功能，其实就是杀一些后台进程来达到释放内存的目的。

   基本思路就是列出所有运行的进程，查看其重要值（RunningAppProcessInfo.importance，值越大说明进程重要程度越低），可以设定一个阈值，

如果该进程的重要值大于该阈值，就可以杀掉该进程。

进程的重要值有以下几个等级：

[java]  view plain  copy

/** 
	
         * Constant for {@link #importance}: this is a persistent process. 
	
         * Only used when reporting to process observers. 
	
         * @hide 
	
         */  
	
        public static final int IMPORTANCE_PERSISTENT = 50;  
	
  
	
        /** 
	
         * Constant for {@link #importance}: this process is running the 
	
         * foreground UI. 
	
         */  
	
        public static final int IMPORTANCE_FOREGROUND = 100;  
	
          
	
        /** 
	
         * Constant for {@link #importance}: this process is running something 
	
         * that is actively visible to the user, though not in the immediate 
	
         * foreground. 
	
         */  
	
        public static final int IMPORTANCE_VISIBLE = 200;  
	
          
	
        /** 
	
         * Constant for {@link #importance}: this process is running something 
	
         * that is considered to be actively perceptible to the user.  An 
	
         * example would be an application performing background music playback. 
	
         */  
	
        public static final int IMPORTANCE_PERCEPTIBLE = 130;  
	
          
	
        /** 
	
         * Constant for {@link #importance}: this process is running an 
	
         * application that can not save its state, and thus can't be killed 
	
         * while in the background. 
	
         * @hide 
	
         */  
	
        public static final int IMPORTANCE_CANT_SAVE_STATE = 170;  
	
          
	
        /** 
	
         * Constant for {@link #importance}: this process is contains services 
	
         * that should remain running. 
	
         */  
	
        public static final int IMPORTANCE_SERVICE = 300;  
	
          
	
        /** 
	
         * Constant for {@link #importance}: this process process contains 
	
         * background code that is expendable. 
	
         */  
	
        public static final int IMPORTANCE_BACKGROUND = 400;  
	
          
	
        /** 
	
         * Constant for {@link #importance}: this process is empty of any 
	
         * actively running code. 
	
         */  
	
        public static final int IMPORTANCE_EMPTY = 500;  


直接上代码：

[java]  view plain  copy

package com.android.clearmemory;  
	
  
	
import android.app.Activity;  
	
import android.app.ActivityManager;  
	
import android.app.ActivityManager.MemoryInfo;  
	
import android.app.ActivityManager.RunningAppProcessInfo;  
	
import android.content.Context;  
	
import android.os.Bundle;  
	
import android.util.Log;  
	
import android.view.View;  
	
import android.widget.Button;  
	
import android.widget.Toast;  
	
  
	
import java.util.List;  
	
  
	
public class ClearMemoryActivity extends Activity {  
	
    private static final String TAG = "ClearMemoryActivity";  
	
  
	
    /** 
	
     * Called when the activity is first created. 
	
     */  
	
    @Override  
	
    public void onCreate(Bundle savedInstanceState) {  
	
        super.onCreate(savedInstanceState);  
	
        setContentView(R.layout.main);  
	
  
	
        Button clear = (Button) findViewById(R.id.clear);  
	
        clear.setOnClickListener(new View.OnClickListener() {  
	
            @Override  
	
            public void onClick(View v) {  
	
                //To change body of implemented methods use File | Settings | File Templates.  
	
                ActivityManager am = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);  
	
                List<RunningAppProcessInfo> infoList = am.getRunningAppProcesses();  
	
                List<ActivityManager.RunningServiceInfo> serviceInfos = am.getRunningServices(100);  
	
  
	
                long beforeMem = getAvailMemory(ClearMemoryActivity.this);  
	
                Log.d(TAG, "-----------before memory info : " + beforeMem);  
	
                int count = 0;  
	
                if (infoList != null) {  
	
                    for (int i = 0; i < infoList.size(); ++i) {  
	
                        RunningAppProcessInfo appProcessInfo = infoList.get(i);  
	
                        Log.d(TAG, "process name : " + appProcessInfo.processName);  
	
                        //importance 该进程的重要程度  分为几个级别，数值越低就越重要。  
	
                        Log.d(TAG, "importance : " + appProcessInfo.importance);  
	
  
	
                        // 一般数值大于RunningAppProcessInfo.IMPORTANCE_SERVICE的进程都长时间没用或者空进程了  
	
                        // 一般数值大于RunningAppProcessInfo.IMPORTANCE_VISIBLE的进程都是非可见进程，也就是在后台运行着  
	
                        if (appProcessInfo.importance > RunningAppProcessInfo.IMPORTANCE_VISIBLE) {  
	
                            String[] pkgList = appProcessInfo.pkgList;  
	
                            for (int j = 0; j < pkgList.length; ++j) {//pkgList 得到该进程下运行的包名  
	
                                Log.d(TAG, "It will be killed, package name : " + pkgList[j]);  
	
                                am.killBackgroundProcesses(pkgList[j]);  
	
                                count++;  
	
                            }  
	
                        }  
	
  
	
                    }  
	
                }  
	
  
	
                long afterMem = getAvailMemory(ClearMemoryActivity.this);  
	
                Log.d(TAG, "----------- after memory info : " + afterMem);  
	
                Toast.makeText(ClearMemoryActivity.this, "clear " + count + " process, "  
	
                            + (afterMem - beforeMem) + "M", Toast.LENGTH_LONG).show();  
	
            }  
	
        });  
	
  
	
        ClearMemoryFloatView.instance(getApplicationContext()).createView();  
	
    }  
	
  
	
    //获取可用内存大小  
	
    private long getAvailMemory(Context context) {  
	
        // 获取android当前可用内存大小  
	
        ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);  
	
        MemoryInfo mi = new MemoryInfo();  
	
        am.getMemoryInfo(mi);  
	
        //mi.availMem; 当前系统的可用内存  
	
        //return Formatter.formatFileSize(context, mi.availMem);// 将获取的内存大小规格化  
	
        Log.d(TAG, "可用内存---->>>" + mi.availMem / (1024 * 1024));  
	
        return mi.availMem / (1024 * 1024);  
	
    }  
	
}  
 

注意：

 

我这里选择阈值是IMPORTANCE_VISIBLE级别的，也就是非可见的后台进程和服务会被杀掉（一些系统进程肯定除外）。

清理的效果跟金山清理大师和360桌面的一键清理效果差不多。

如果不想杀的太凶，可以选择IMPORTANCE_SERVICE级别，杀掉那些长时间没用或者空进程了，

这个级别的清理力度不够大，达不到金山清理大师的效果。