向大家推荐一个好用的 内存清理及内存工具类

1. public class MemoryUtils {  
2.       
3.     //----------> 以下为杀掉进程的几种方式  
4.       
5.     public static void cleanMemory(Context context,EditText editText) {  
6.         long beforeCleanMemory=getAvailMemory(context);  
7.         System.out.println("---> 清理前可用内存大小:"+beforeCleanMemory+"M");  
8.         ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);  
9.         RunningAppProcessInfo runningAppProcessInfo = null;  
10.         List<RunningAppProcessInfo> runningAppProcessInfoList = activityManager.getRunningAppProcesses();  
11.         for (int i = 0; i < runningAppProcessInfoList.size(); ++i) {  
12.             runningAppProcessInfo = runningAppProcessInfoList.get(i);  
13.             String processName = runningAppProcessInfo.processName;  
14.             //调用杀掉进程的方法  
15.             System.out.println("---> 开始清理:"+processName);  
16.             killProcessByRestartPackage(context, processName);  
17.         }  
18.         long afterCleanMemory=getAvailMemory(context);  
19.         System.out.println("---> 清理后可用内存大小:"+afterCleanMemory+"M");  
20.         System.out.println("---> 节约内存大小:"+(afterCleanMemory-beforeCleanMemory)+"M");  
21.         editText.setText("共清理:"+(afterCleanMemory-beforeCleanMemory)+"M");  
22.     }  
23.       
24.       
25.       
26.     //利用activityManager.restartPackage()方法杀死进程  
27.     //该方法实际调用了activityManager.killBackgroundProcesses()方法  
28.     public static void killProcessByRestartPackage(Context context,String packageName) {  
29.         ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);  
30.         activityManager.restartPackage(packageName);  
31.         System.gc();  
32.     }  
33.       
34.       
35.     //利用Process.killProcess(pid)杀死进程  
36.     //注意事项:  
37.     //1 该方式可自杀,即杀掉本进程  
38.     //2 该方式可杀掉其他普通应用进程  
39.     //3 该方式不可杀掉系统级应用即system/app应用  
40.     public static void killProcessBykillProcess(int pid){  
41.         Process.killProcess(pid);  
42.     }  
43.       
44.       
45.     //利用adb shell命令杀死进程  
46.     public static void killProcessByAdbShell(int pid) {  
47.         String cmd = "adb shell kill -9 " + pid;  
48.         System.out.println("-------> cmd=" + cmd);  
49.         try {  
50.             java.lang.Process process = Runtime.getRuntime().exec(cmd);  
51.             InputStreamReader inputStreamReader = new InputStreamReader(process.getInputStream());  
52.             BufferedReader bufferedReader = new BufferedReader(inputStreamReader);  
53.             String line = null;  
54.             while ((line = bufferedReader.readLine()) != null) {  
55.                 System.out.println("----> exec shell:" + line);  
56.             }  
57.             bufferedReader.close();  
58.         } catch (IOException e) {  
59.             e.printStackTrace();  
60.         }  
61.     }  
62.        
63.      //利用su进程的命令方式杀死进程  
64.      //1 得到su进程(super进程)  
65.      //  Runtime.getRuntime().exec("su");  
66.      //2 利用su进程执行命令  
67.      //  process.getOutputStream().write(cmd.getBytes());  
68.     public static void killProcessBySu(int pid) {  
69.         try {  
70.             java.lang.Process process = Runtime.getRuntime().exec("su");  
71.             String cmd = "kill -9 " + pid;  
72.             System.out.println("-------> cmd = " + cmd);  
73.             process.getOutputStream().write(cmd.getBytes());  
74.             if ((process.waitFor() != 0)) {  
75.                 System.out.println("-------> su.waitFor()!= 0");  
76.             } else {  
77.                 System.out.println("------->  su.waitFor()==0 ");  
78.             }  
79.         } catch (Exception e) {  
80.             e.printStackTrace();  
81.         }  
82.   
83.     }  
84.       
85.     //----------> 以上为杀掉进程的几种方式  
86.       
87.   
88.       
89.       
90.       
91.     //获取当前进程名  
92.     public static String getCurrentProcessName(Context context) {  
93.         int pid = android.os.Process.myPid();  
94.         ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);  
95.         for (RunningAppProcessInfo runningAppProcessInfo : activityManager.getRunningAppProcesses()) {  
96.             if (runningAppProcessInfo.pid == pid) {  
97.                 String processName=runningAppProcessInfo.processName;  
98.                 return processName;  
99.             }  
100.         }  
101.         return null;  
102.     }  
103.       
104.       
105.     //获取栈顶Activity名称  
106.     public static String getTopActivityName(Context context) {  
107.         String topActivityName = null;  
108.         ActivityManager activityManager = (ActivityManager) (context.getSystemService(android.content.Context.ACTIVITY_SERVICE));  
109.         List<RunningTaskInfo> runningTaskInfos = activityManager.getRunningTasks(1);  
110.         if (runningTaskInfos != null) {  
111.             ComponentName f = runningTaskInfos.get(0).topActivity;  
112.             String topActivityClassName = f.getClassName();  
113.             String temp[] = topActivityClassName.split("\\.");  
114.             topActivityName = temp[temp.length - 1];  
115.         }  
116.         return topActivityName;  
117.     }  
118.       
119.       
120.       
121.     //获取栈顶Activity所属进程的名称  
122.     public static String getTopActivityProcessName(Context context) {  
123.         String processName = null;  
124.         ActivityManager activityManager = (ActivityManager) (context.getSystemService(android.content.Context.ACTIVITY_SERVICE));  
125.         List<RunningTaskInfo> runningTaskInfos = activityManager.getRunningTasks(1);  
126.         if (runningTaskInfos != null) {  
127.             ComponentName componentName = runningTaskInfos.get(0).topActivity;  
128.             String topActivityClassName = componentName.getClassName();  
129.             int index = topActivityClassName.lastIndexOf(".");  
130.             processName = topActivityClassName.substring(0, index);  
131.         }  
132.         return processName;  
133.     }  
134.       
135.       
136.       
137.     //获取内存总大小  
138.     public static long getTotalMemory() {  
139.         // 系统的内存信息文件  
140.         String filePath = "/proc/meminfo";  
141.         String lineString;  
142.         String[] stringArray;  
143.         long totalMemory = 0;  
144.         try {  
145.             FileReader fileReader = new FileReader(filePath);  
146.             BufferedReader bufferedReader = new BufferedReader(fileReader,1024 * 8);  
147.             // 读取meminfo第一行,获取系统总内存大小  
148.             lineString = bufferedReader.readLine();  
149.             // 按照空格拆分  
150.             stringArray = lineString.split("\\s+");  
151.             // 获得系统总内存,单位KB  
152.             totalMemory = Integer.valueOf(stringArray[1]).intValue();  
153.             bufferedReader.close();  
154.         } catch (IOException e) {  
155.         }  
156.         return totalMemory / 1024;  
157.     }  
158.       
159.       
160.       
161.     //获取可用内存大小  
162.     public static long getAvailMemory(Context context) {  
163.         ActivityManager activityManager=(ActivityManager)context.getSystemService(Context.ACTIVITY_SERVICE);  
164.         MemoryInfo memoryInfo = new MemoryInfo();  
165.         activityManager.getMemoryInfo(memoryInfo);  
166.         return memoryInfo.availMem / (1024 * 1024);  
167.     }  
168.       
169.   
170. }