最全Android中图像变换Matrix的原理应用，2024年最新大厂面试会问什么问题

最后

下面是有几位Android行业大佬对应上方技术点整理的一些进阶资料。希望能够帮助到大家提升技术

高级UI，自定义View

UI这块知识是现今使用者最多的。当年火爆一时的Android入门培训，学会这小块知识就能随便找到不错的工作了。

不过很显然现在远远不够了，拒绝无休止的CV,亲自去项目实战，读源码，研究原理吧！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

99. //

100. //          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠

101. //          matrix.postTranslate(view.getImageBitmap().getWidth() * 1.5f, 0f);

102. //          view.setImageMatrix(matrix);

103. //

104. //          // 下面的代码是为了查看matrix中的元素

105. //          float[] matrixValues = new float[9];

106. //          matrix.getValues(matrixValues);

107. //          for(int i = 0; i < 3; ++i)

108. //          {

109. //              String temp = new String();

110. //              for(int j = 0; j < 3; ++j)

111. //              {

112. //                  temp += matrixValues[3 * i + j ] + “\t”;

113. //              }

114. //              Log.e(“TestTransformMatrixActivity”, temp);

115. //          }

116. //          // 3. 旋转(围绕坐标原点) + 平移(效果同2)

117. //          matrix.setRotate(45f);

118. //          matrix.preTranslate(-1f * view.getImageBitmap().getWidth() / 2f, -1f * view.getImageBitmap().getHeight() / 2f);

119. //          matrix.postTranslate((float)view.getImageBitmap().getWidth() / 2f, (float)view.getImageBitmap().getHeight() / 2f);

120. //

121. //          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠

122. //          matrix.postTranslate((float)view.getImageBitmap().getWidth() * 1.5f, 0f);

123. //          view.setImageMatrix(matrix);

124. //

125. //          // 下面的代码是为了查看matrix中的元素

126. //          float[] matrixValues = new float[9];

127. //          matrix.getValues(matrixValues);

128. //          for(int i = 0; i < 3; ++i)

129. //          {

130. //              String temp = new String();

131. //              for(int j = 0; j < 3; ++j)

132. //              {

133. //                  temp += matrixValues[3 * i + j ] + “\t”;

134. //              }

135. //              Log.e(“TestTransformMatrixActivity”, temp);

136. //          }

137. //          // 4. 缩放

138. //          matrix.setScale(2f, 2f);

139. //          // 下面的代码是为了查看matrix中的元素

140. //          float[] matrixValues = new float[9];

141. //          matrix.getValues(matrixValues);

142. //          for(int i = 0; i < 3; ++i)

143. //          {

144. //              String temp = new String();

145. //              for(int j = 0; j < 3; ++j)

146. //              {

147. //                  temp += matrixValues[3 * i + j ] + “\t”;

148. //              }

149. //              Log.e(“TestTransformMatrixActivity”, temp);

150. //          }

151. //

152. //          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠

153. //          matrix.postTranslate(view.getImageBitmap().getWidth(), view.getImageBitmap().getHeight());

154. //          view.setImageMatrix(matrix);

155. //

156. //          // 下面的代码是为了查看matrix中的元素

157. //          matrixValues = new float[9];

158. //          matrix.getValues(matrixValues);

159. //          for(int i = 0; i < 3; ++i)

160. //          {

161. //              String temp = new String();

162. //              for(int j = 0; j < 3; ++j)

163. //              {

164. //                  temp += matrixValues[3 * i + j ] + “\t”;

165. //              }

166. //              Log.e(“TestTransformMatrixActivity”, temp);

167. //          }

168. //          // 5. 错切 - 水平

169. //          matrix.setSkew(0.5f, 0f);

170. //          // 下面的代码是为了查看matrix中的元素

171. //          float[] matrixValues = new float[9];

172. //          matrix.getValues(matrixValues);

173. //          for(int i = 0; i < 3; ++i)

174. //          {

175. //              String temp = new String();

176. //              for(int j = 0; j < 3; ++j)

177. //              {

178. //                  temp += matrixValues[3 * i + j ] + “\t”;

179. //              }

180. //              Log.e(“TestTransformMatrixActivity”, temp);

181. //          }

182. //

183. //          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠

184. //          matrix.postTranslate(view.getImageBitmap().getWidth(), 0f);

185. //          view.setImageMatrix(matrix);

186. //

187. //          // 下面的代码是为了查看matrix中的元素

188. //          matrixValues = new float[9];

189. //          matrix.getValues(matrixValues);

190. //          for(int i = 0; i < 3; ++i)

191. //          {

192. //              String temp = new String();

193. //              for(int j = 0; j < 3; ++j)

194. //              {

195. //                  temp += matrixValues[3 * i + j ] + “\t”;

196. //              }

197. //              Log.e(“TestTransformMatrixActivity”, temp);

198. //          }

199. //          // 6. 错切 - 垂直

200. //          matrix.setSkew(0f, 0.5f);

201. //          // 下面的代码是为了查看matrix中的元素

202. //          float[] matrixValues = new float[9];

203. //          matrix.getValues(matrixValues);

204. //          for(int i = 0; i < 3; ++i)

205. //          {

206. //              String temp = new String();

207. //              for(int j = 0; j < 3; ++j)

208. //              {

209. //                  temp += matrixValues[3 * i + j ] + “\t”;

210. //              }

211. //              Log.e(“TestTransformMatrixActivity”, temp);

212. //          }

213. //

214. //          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠

215. //          matrix.postTranslate(0f, view.getImageBitmap().getHeight());

216. //          view.setImageMatrix(matrix);

217. //

218. //          // 下面的代码是为了查看matrix中的元素

219. //          matrixValues = new float[9];

220. //          matrix.getValues(matrixValues);

221. //          for(int i = 0; i < 3; ++i)

222. //          {

223. //              String temp = new String();

224. //              for(int j = 0; j < 3; ++j)

225. //              {

226. //                  temp += matrixValues[3 * i + j ] + “\t”;

227. //              }

228. //              Log.e(“TestTransformMatrixActivity”, temp);

229. //          }

230. //          7. 错切 - 水平 + 垂直

231. //          matrix.setSkew(0.5f, 0.5f);

232. //          // 下面的代码是为了查看matrix中的元素

233. //          float[] matrixValues = new float[9];

234. //          matrix.getValues(matrixValues);

235. //          for(int i = 0; i < 3; ++i)

236. //          {

237. //              String temp = new String();

238. //              for(int j = 0; j < 3; ++j)

239. //              {

240. //                  temp += matrixValues[3 * i + j ] + “\t”;

241. //              }

242. //              Log.e(“TestTransformMatrixActivity”, temp);

243. //          }

244. //

245. //          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠

246. //          matrix.postTranslate(0f, view.getImageBitmap().getHeight());

247. //          view.setImageMatrix(matrix);

248. //

249. //          // 下面的代码是为了查看matrix中的元素

250. //          matrixValues = new float[9];

251. //          matrix.getValues(matrixValues);

252. //          for(int i = 0; i < 3; ++i)

253. //          {

254. //              String temp = new String();

255. //              for(int j = 0; j < 3; ++j)

256. //              {

257. //                  temp += matrixValues[3 * i + j ] + “\t”;

258. //              }

259. //              Log.e(“TestTransformMatrixActivity”, temp);

260. //          }

261. //          // 8. 对称 (水平对称)

262. //          float matrix_values[] = {1f, 0f, 0f, 0f, -1f, 0f, 0f, 0f, 1f};

263. //          matrix.setValues(matrix_values);

264. //          // 下面的代码是为了查看matrix中的元素

265. //          float[] matrixValues = new float[9];

266. //          matrix.getValues(matrixValues);

267. //          for(int i = 0; i < 3; ++i)

268. //          {

269. //              String temp = new String();

270. //              for(int j = 0; j < 3; ++j)

271. //              {

272. //                  temp += matrixValues[3 * i + j ] + “\t”;

273. //              }

274. //              Log.e(“TestTransformMatrixActivity”, temp);

275. //          }

276. //

277. //          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠

278. //          matrix.postTranslate(0f, view.getImageBitmap().getHeight() * 2f);

279. //          view.setImageMatrix(matrix);

280. //

281. //          // 下面的代码是为了查看matrix中的元素

282. //          matrixValues = new float[9];

283. //          matrix.getValues(matrixValues);

284. //          for(int i = 0; i < 3; ++i)

285. //          {

286. //              String temp = new String();

287. //              for(int j = 0; j < 3; ++j)

288. //              {

289. //                  temp += matrixValues[3 * i + j ] + “\t”;

290. //              }

291. //              Log.e(“TestTransformMatrixActivity”, temp);

292. //          }

293. //          // 9. 对称 - 垂直

294. //          float matrix_values[] = {-1f, 0f, 0f, 0f, 1f, 0f, 0f, 0f, 1f};

295. //          matrix.setValues(matrix_values);

296. //          // 下面的代码是为了查看matrix中的元素

297. //          float[] matrixValues = new float[9];

298. //          matrix.getValues(matrixValues);

299. //          for(int i = 0; i < 3; ++i)

300. //          {

301. //              String temp = new String();

302. //              for(int j = 0; j < 3; ++j)

303. //              {

304. //                  temp += matrixValues[3 * i + j ] + “\t”;

305. //              }

306. //              Log.e(“TestTransformMatrixActivity”, temp);

307. //          }

308. //

309. //          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠

310. //          matrix.postTranslate(view.getImageBitmap().getWidth() * 2f, 0f);

311. //          view.setImageMatrix(matrix);

312. //

313. //          // 下面的代码是为了查看matrix中的元素

314. //          matrixValues = new float[9];

315. //          matrix.getValues(matrixValues);

316. //          for(int i = 0; i < 3; ++i)

317. //          {

318. //              String temp = new String();

319. //              for(int j = 0; j < 3; ++j)

320. //              {

321. //                  temp += matrixValues[3 * i + j ] + “\t”;

322. //              }

323. //              Log.e(“TestTransformMatrixActivity”, temp);

324. //          }

325. //          // 10. 对称(对称轴为直线y = x)

326. //          float matrix_values[] = {0f, -1f, 0f, -1f, 0f, 0f, 0f, 0f, 1f};

327. //          matrix.setValues(matrix_values);

328. //          // 下面的代码是为了查看matrix中的元素

329. //          float[] matrixValues = new float[9];

330. //          matrix.getValues(matrixValues);

331. //          for(int i = 0; i < 3; ++i)

332. //          {

333. //              String temp = new String();

334. //              for(int j = 0; j < 3; ++j)

335. //              {

336. //                  temp += matrixValues[3 * i + j ] + “\t”;

337. //              }

338. //              Log.e(“TestTransformMatrixActivity”, temp);

339. //          }

340. //

341. //          // 做下面的平移变换，纯粹是为了让变换后的图像和原图像不重叠

342. //          matrix.postTranslate(view.getImageBitmap().getHeight() + view.getImageBitmap().getWidth(),

343. //                  view.getImageBitmap().getHeight() + view.getImageBitmap().getWidth());

344. //          view.setImageMatrix(matrix);

345. //

346. //          // 下面的代码是为了查看matrix中的元素

347. //          matrixValues = new float[9];

348. //          matrix.getValues(matrixValues);

349. //          for(int i = 0; i < 3; ++i)

350. //          {

351. //              String temp = new String();

352. //              for(int j = 0; j < 3; ++j)

353. //              {

354. //                  temp += matrixValues[3 * i + j ] + “\t”;

355. //              }

356. //              Log.e(“TestTransformMatrixActivity”, temp);

357. //          }

358. view.invalidate();

359. }

360. return true;

361. }

362. }
     

363. 
       

第三部分 应用

在这一部分，我们会将前面两部分所了解到的内容和Android手势结合起来，利用各种不同的手势对图像进行平移、缩放和旋转，前面两项都是在实践中经常需要用到的功能，后一项据说苹果也是最近才加上的，而实际上在Android中，咱们通过自己的双手，也可以很轻松地实现之。

首先创建一个Android项目PatImageView，同时创建一个Activity：PatImageViewActivity。完成这一步后， 记得在AndroidManifest.xml中增加如下许可：

uses-permissionandroid:name=_“android.permission.VIBRATE”_/

因为我们将要通过短按还是长按，来确定将图片到底是缩放还是旋转。

现在来创建一个ImageView的派生类：PatImageView，其代码(PatImageView.java)如下(2011-11-22 revised)：

[java]  view plain copy

1. package com.pat.imageview;

2. import android.app.Service;

3. import android.content.Context;

4. import android.graphics.Matrix;

5. import android.graphics.PointF;

6. import android.os.Vibrator;

7. import android.util.FloatMath;

8. import android.view.GestureDetector;

9. import android.view.MotionEvent;

10. import android.view.View;

11. import android.widget.ImageView;

12. public class PatImageView extends ImageView

13. {

14. private Matrix matrix;

15. private Matrix savedMatrix;

16. private boolean long_touch = false;

17. private static int NONE = 0;

18. private static int DRAG = 1;    // 拖动

19. private static int ZOOM = 2;    // 缩放

20. private static int ROTA = 3;    // 旋转

21. private int mode = NONE;

22. private PointF startPoint;

23. private PointF middlePoint;

24. private float oldDistance;

25. private float oldAngle;

26. private Vibrator vibrator;

27. private GestureDetector gdetector;

28. public PatImageView(final Context context)

29. {

30. super(context);

31. matrix = new Matrix();

32. savedMatrix = new Matrix();

33. matrix.setTranslate(0f, 0f);

34. setScaleType(ScaleType.MATRIX);

35. setImageMatrix(matrix);

36. startPoint = new PointF();

37. middlePoint = new PointF();

38. oldDistance = 1f;

39. gdetector = new GestureDetector(context, new GestureDetector.OnGestureListener()

40. {

41. @Override

42. public boolean onSingleTapUp(MotionEvent e)

43. {

44. return true;

45. }

46. @Override

47. public void onShowPress(MotionEvent e)

48. {

49. }

50. @Override

51. public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY)

52. {

53. return true;

54. }

55. @Override

56. public void onLongPress(MotionEvent e)

57. {

58. long_touch = true;

59. vibrator = (Vibrator) context.getSystemService(Service.VIBRATOR_SERVICE);

60. // 振动50ms，提示后续的操作将是旋转图片，而非缩放图片

61. vibrator.vibrate(50);

62. }

63. @Override

64. public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY)

65. {

66. return true;

67. }

68. @Override

69. public boolean onDown(MotionEvent e)

70. {

71. return true;

72. }

73. });

74. setOnTouchListener(new OnTouchListener()

75. {

76. public boolean onTouch(View view, MotionEvent event)

77. {

78. switch(event.getAction() & MotionEvent.ACTION_MASK)

79. {

80. case MotionEvent.ACTION_DOWN:           // 第一个手指touch

81. savedMatrix.set(matrix);

82. startPoint.set(event.getX(), event.getY());

83. mode = DRAG;

84. long_touch = false;

85. break;

86. case MotionEvent.ACTION_POINTER_DOWN:   // 第二个手指touch

87. oldDistance = getDistance(event);   // 计算第二个手指touch时，两指之间的距离

88. oldAngle = getDegree(event);        // 计算第二个手指touch时，两指所形成的直线和x轴的角度

89. if(oldDistance > 10f)

90. {

91. savedMatrix.set(matrix);

92. middlePoint = midPoint(event);

93. if(!long_touch)

94. {

95. mode = ZOOM;

96. }

97. else

98. {

99. mode = ROTA;

100. }

101. }

102. break;

103. case MotionEvent.ACTION_UP:

104. mode = NONE;

105. break;

106. case MotionEvent.ACTION_POINTER_UP:

107. mode = NONE;

108. break;

109. case MotionEvent.ACTION_MOVE:

110. if(vibrator != null)    vibrator.cancel();

111. if(mode == DRAG)

112. {

113. matrix.set(savedMatrix);

114. matrix.postTranslate(event.getX() - startPoint.x, event.getY() - startPoint.y);

115. }

116. if(mode == ZOOM)

117. {

118. float newDistance = getDistance(event);

119. if(newDistance > 10f)

120. {

121. matrix.set(savedMatrix);

122. float scale = newDistance / oldDistance;

123. matrix.postScale(scale, scale, middlePoint.x, middlePoint.y);

124. }

125. }

126. if(mode == ROTA)

127. {

128. float newAngle = getDegree(event);

129. matrix.set(savedMatrix);

130. float degrees = newAngle - oldAngle;

131. matrix.postRotate(degrees, middlePoint.x, middlePoint.y);

132. }

133. break;

134. }

135. setImageMatrix(matrix);

136. invalidate();

137. gdetector.onTouchEvent(event);

138. return true;

139. }

140. });

最后

其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。

当然我也为你们整理好了百度、阿里、腾讯、字节跳动等等互联网超级大厂的历年面试真题集锦。这也是我这些年来养成的习惯，一定要学会把好的东西，归纳整理，然后系统的消化吸收，这样才能极大的提高学习效率和成长进阶。碎片、零散化的东西，我觉得最没有价值的。就好比你给我一张扑克牌，我只会觉得它是一张废纸，但如果你给我一副扑克牌，它便有了它的价值。这和我们收集资料就要收集那些系统化的，是一个道理。

网上学习 Android的资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。希望这份系统化的技术体系对大家有一个方向参考。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

Matrix);

152. float degrees = newAngle - oldAngle;

153. matrix.postRotate(degrees, middlePoint.x, middlePoint.y);

154. }

155. break;

156. }

157. setImageMatrix(matrix);

158. invalidate();

159. gdetector.onTouchEvent(event);

160. return true;

161. }

162. });

最后

其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。

当然我也为你们整理好了百度、阿里、腾讯、字节跳动等等互联网超级大厂的历年面试真题集锦。这也是我这些年来养成的习惯，一定要学会把好的东西，归纳整理，然后系统的消化吸收，这样才能极大的提高学习效率和成长进阶。碎片、零散化的东西，我觉得最没有价值的。就好比你给我一张扑克牌，我只会觉得它是一张废纸，但如果你给我一副扑克牌，它便有了它的价值。这和我们收集资料就要收集那些系统化的，是一个道理。

[外链图片转存中…(img-rRuCZ5SP-1715345421552)]

网上学习 Android的资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。希望这份系统化的技术体系对大家有一个方向参考。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！