Android设备的内存有限，对于大图片，必须进行压缩后再进行显示，否则会出现内存溢出：OOM；
处理策略：
1.使用缩略图（Thumbnails）；
Android系统会给检测到的图片创建缩略图；可以操作Media内容提供者中的Image对图片进行操作；
2.手动压缩：
（1）根据图片和屏幕尺寸，等比压缩，完美显示；
（2）降低图片质量，压缩图片大小；
以下是自己整理的小工具类（对于按比例缩放后，在此并未再进行质量缩放，此时图片大小有可能超出我们期望的限制；假如我们有严格的大小限制需求，可先进行按比例缩放后，判断此时图片大小是否超出限制；如果超出限制，对其再进行质量缩放即可。建议使用按比例缩放，按质量缩放很有可能导致图片失真。）
1. </pre><p><pre name="code" class="java">package com.util;
3. import java.io.ByteArrayOutputStream;
4. import java.io.IOException;
5. import java.io.InputStream;
7. import android.graphics.Bitmap;
8. import android.graphics.Matrix;
9. import android.graphics.Bitmap.CompressFormat;
10. import android.graphics.BitmapFactory;
11. import android.media.ExifInterface;
13. /**
14. * 图片压缩工具类
15. *
16. * @author 丶Life_
17. *
18. */
19. public class ImageCompressUtil {
21. /**
22. * 通过降低图片的质量来压缩图片
23. *
24. * @param bmp
25. * 要压缩的图片位图对象
26. * @param maxSize
27. * 压缩后图片大小的最大值,单位KB
28. * @return 压缩后的图片位图对象
29. */
30. public static Bitmap compressByQuality(Bitmap bitmap, int maxSize) {
31. new ByteArrayOutputStream();
32. int quality = 100;
33. bitmap.compress(CompressFormat.JPEG, quality, baos);
34. "图片压缩前大小：" + baos.toByteArray().length + "byte");
35. boolean isCompressed = false;
36. while (baos.toByteArray().length / 1024 > maxSize) {
37. 10;
38. baos.reset();
39. bitmap.compress(CompressFormat.JPEG, quality, baos);
40. "质量压缩到原来的" + quality + "%时大小为："
41. "byte");
42. true;
43. }
44. "图片压缩后大小：" + baos.toByteArray().length + "byte");
45. if (isCompressed) {
46. Bitmap compressedBitmap = BitmapFactory.decodeByteArray(
47. 0, baos.toByteArray().length);
48. recycleBitmap(bitmap);
49. return compressedBitmap;
50. else {
51. return bitmap;
52. }
53. }
55. /**
56. * 传入图片url,通过压缩图片的尺寸来压缩图片大小
57. *
58. * @param pathName 图片的完整路径
59. * @param targetWidth 缩放的目标宽度
60. * @param targetHeight缩放的目标高度
61. * @return 缩放后的图片
62. */
63. public static Bitmap compressBySize(String pathName, int targetWidth,
64. int targetHeight) {
65. new BitmapFactory.Options();
66. true;// 不去真的解析图片，只是获取图片的头部信息，包含宽高等；
67. Bitmap bitmap = BitmapFactory.decodeFile(pathName, opts);
68. // 得到图片的宽度、高度；
69. int imgWidth = opts.outWidth;
70. int imgHeight = opts.outHeight;
71. // 分别计算图片宽度、高度与目标宽度、高度的比例；取大于等于该比例的最小整数；
72. int widthRatio = (int) Math.ceil(imgWidth / (float) targetWidth);
73. int heightRatio = (int) Math.ceil(imgHeight / (float) targetHeight);
74. if (widthRatio > 1 || heightRatio > 1) {
75. if (widthRatio > heightRatio) {
76. opts.inSampleSize = widthRatio;
77. else {
78. opts.inSampleSize = heightRatio;
79. }
80. }
81. // 设置好缩放比例后，加载图片进内容；
82. false;
83. bitmap = BitmapFactory.decodeFile(pathName, opts);
84. return bitmap;
85. }
87. /**
88. * 传入bitmap,通过压缩图片的尺寸来压缩图片大小
89. *
90. * @param bitmap 要压缩图片
91. * @param targetWidth缩放的目标宽度
92. * @param targetHeight 缩放的目标高度
93. * @return 缩放后的图片
94. */
95. public static Bitmap compressBySize(Bitmap bitmap, int targetWidth,
96. int targetHeight) {
97. new ByteArrayOutputStream();
98. 100, baos);
99. new BitmapFactory.Options();
100. true;
101. 0,
102. baos.toByteArray().length, opts);
103. // 得到图片的宽度、高度；
104. int imgWidth = opts.outWidth;
105. int imgHeight = opts.outHeight;
106. // 分别计算图片宽度、高度与目标宽度、高度的比例；取大于该比例的最小整数；
107. int widthRatio = (int) Math.ceil(imgWidth / (float) targetWidth);
108. int heightRatio = (int) Math.ceil(imgHeight / (float) targetHeight);
109. if (widthRatio > 1 || heightRatio > 1) {
110. if (widthRatio > heightRatio) {
111. opts.inSampleSize = widthRatio;
112. else {
113. opts.inSampleSize = heightRatio;
114. }
115. }
116. // 设置好缩放比例后，加载图片进内存；
117. false;
118. Bitmap compressedBitmap = BitmapFactory.decodeByteArray(
119. 0, baos.toByteArray().length, opts);
120. recycleBitmap(bitmap);
121. return compressedBitmap;
122. }
124. /**
125. * 通过压缩图片的尺寸来压缩图片大小，通过读入流的方式，可以有效防止网络图片数据流形成位图对象时内存过大的问题；
126. *
127. * @param InputStream要压缩图片，以流的形式传入
128. * @param targetWidth缩放的目标宽度
129. * @param targetHeight缩放的目标高度
130. * @return 缩放后的图片
131. * @throws IOException读输入流的时候发生异常
132. */
133. public static Bitmap compressBySize(InputStream is, int targetWidth,
134. int targetHeight) throws IOException {
135. new ByteArrayOutputStream();
136. byte[] buff = new byte[1024];
137. int len = 0;
138. while ((len = is.read(buff)) != -1) {
139. 0, len);
140. }
142. byte[] data = baos.toByteArray();
143. new BitmapFactory.Options();
144. true;
145. 0, data.length,
146. opts);
147. // 得到图片的宽度、高度；
148. int imgWidth = opts.outWidth;
149. int imgHeight = opts.outHeight;
150. // 分别计算图片宽度、高度与目标宽度、高度的比例；取大于该比例的最小整数；
151. int widthRatio = (int) Math.ceil(imgWidth / (float) targetWidth);
152. int heightRatio = (int) Math.ceil(imgHeight / (float) targetHeight);
153. if (widthRatio > 1 || heightRatio > 1) {
154. if (widthRatio > heightRatio) {
155. opts.inSampleSize = widthRatio;
156. else {
157. opts.inSampleSize = heightRatio;
158. }
159. }
160. // 设置好缩放比例后，加载图片进内存；
161. false;
162. 0, data.length, opts);
163. return bitmap;
164. }
166. /**
167. * 旋转图片摆正显示
168. *
169. * @param srcPath
170. * @param bitmap
171. * @return
172. */
173. public static Bitmap rotateBitmapByExif(String srcPath, Bitmap bitmap) {
174. ExifInterface exif;
175. null;
176. try {
177. new ExifInterface(srcPath);
178. if (exif != null) { // 读取图片中相机方向信息
179. int ori = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION,
180. ExifInterface.ORIENTATION_NORMAL);
181. int digree = 0;
182. switch (ori) {
183. case ExifInterface.ORIENTATION_ROTATE_90:
184. 90;
185. break;
186. case ExifInterface.ORIENTATION_ROTATE_180:
187. 180;
188. break;
189. case ExifInterface.ORIENTATION_ROTATE_270:
190. 270;
191. break;
192. }
193. if (digree != 0) {
194. new Matrix();
195. m.postRotate(digree);
196. 0, 0,
197. true);
198. recycleBitmap(bitmap);
199. return newBitmap;
200. }
201. }
202. catch (IOException e) {
203. e.printStackTrace();
204. }
205. return bitmap;
206. }
208. /**
209. * 回收位图对象
210. *
211. * @param bitmap
212. */
213. public static void recycleBitmap(Bitmap bitmap) {
214. if (bitmap != null && !bitmap.isRecycled()) {
215. bitmap.recycle();
216. System.gc();
217. null;
218. }
219. }
221. }
