java根据图片中绿色像素点的多少进行排序

前言

一个朋友被绿了，看见绿色就会很伤感，作为好兄弟的我当然看不下去，感觉有我必要也必须做一点什么。正好我又在写java程序，那就写一个小程序帮他把电脑里的图片排一下顺序，根据绿色的程度进行排序，最后把排好序的图片偷偷的放到他的电脑里去。为了好兄弟做这么多的事情，正所谓：事了拂衣去，功藏身与名啊！（当然是倒序排的）

一、利用for循环读取图片

相信学过图像处理的小伙伴都知道，一张图片由很多像素组成（当然，矢量图片除外，大家下来可以了解为啥矢量图片不是由像素点组成的）。因此，不管是什么图片我们都看作是一个平面，因为就可以用坐标的方式去读取图片啦！那就废话不多说直接开始！

二、代码的逻辑

1.先给大家看看主方法里面都有一些什么内容

1. public static void main(String[] args) {
2. HashMap<File, Object> imageMap = new HashMap<File, Object>();//用hashMap将文件和对应的像素点数量装到一起
3. File fileDir = new File("D:\\Download\\TestFile");//将要进行排序的文件目录
4. File[] listFiles = fileDir.listFiles();
5. for (File readFile : listFiles) {
6. getImagePixel(readFile, imageMap);//获取图片的绿色像素点数量的多少
7. }
8.  
9. HashMapSortUtils hashMapSortUtils = new HashMapSortUtils(imageMap, 1, 3, "Mus");
10. LinkedHashMap<File,Object> sortFileMap = hashMapSortUtils.sortFileMap();//将图片按照像素点的数量进行排序
11. hashMapSortUtils.renameFiles(sortFileMap);//将排好序的文件重命名（不然离开控制台就看不到文件的排序了>o<）
12.  
13. System.out.println(imageMap);//这里只是用来看具体像素点有多少的，并没有实际的意义
14. }

是不是很简单呢？跟大象装冰箱一样，只有三个步骤：
1.将文件目录下的所有图片含有的绿色像素点全部读取出来，然后将对应的文件名和像素点个数暂存在HashMap里；
2.将图片根据绿色像素点的多少进行排序；
3.将排好序的图片重命名，然后进行排序输出（Tips：文件会进行重命名的，所有不要直接在源文件上直接玩喔，注意文件的备份）；

好了，那我们就直接开始看每个方法具体是怎样实现的吧，按顺序进行讲解！（以下大家就注意看代码中的注释了，不再做重复的解释了）

2.读取图片像素点的方法

1. private static HashMap<File, Object> getImagePixel(File readFile, HashMap<File, Object> imageMap) {
2. int red = 0;//记录像素点的红色
3. int green = 0;//记录像素点的绿色
4. int blue = 0;//记录像素点的蓝色
5. int counter = 0;//程序计数器
6.  
7. BufferedImage bi = null;
8. try {
9. bi = ImageIO.read(readFile);//通过ImageIO来读取图片，以便获取图片的RGB信息
10. } catch (IOException e) {
11. e.printStackTrace();
12. }
13.  
14. int width = bi.getWidth();//获取图片的宽度
15. int height = bi.getHeight();//获取图片的高度
16. int minx = bi.getMinX();//获取图片的坐标起点x轴
17. int miny = bi.getMinY();//获取图片的坐标起点y轴
18.  
19. for(int i = minx; i < width; i++){
20. for(int j = miny; j < height; j++){
21. int pixel = bi.getRGB(i, j);
22. red = (pixel & 0xff0000) >> 16;//过滤掉图片的绿色和蓝色
23. green = (pixel & 0xff00) >> 8;//过滤掉图片的绿色
24. blue = (pixel & 0xff);//最后剩下的就是蓝色啦
25.  
26. if(green - red > 30 && green - blue > 30){//绿色的范围
27. counter++;
28. }
29. }
30. }
31. imageMap.put(readFile, counter);//将文件和像素点的个数记录到HashMap中
32.  
33. return imageMap;
34. }

3.将图片按照像素点的数量进行排序

由于排序不光在这里可以使用，在其他情况下也可能会使用到（比如说根据文件的创建时间进行排序，都可以用到排序的）。所以我将排序写成了一个抽象类，其他情况下只需要继承这个抽象类，然后具体实现自己想要实现的方法就行了！具体的现如下：

抽象类：

1. package readcolor;
2.  
3. import java.io.File;
4. import java.util.HashMap;
5. import java.util.LinkedHashMap;
6.  
7. public abstract class HashMapSortUtil {
8. private HashMap<File, Object> sortMap;//全局变量Map，就是主方法需要传过来进行排序的Map
9. private String prefix;//前缀，用来命名自己的文件 ==> Mus
10.  
11. public abstract LinkedHashMap<File, Object> sortFileMap();//进行排序的方法
12.  
13. public abstract void renameFiles(LinkedHashMap<File, Object> linkedTimeMap);//重命名的方法
14.  
15. public HashMap<File, Object> getSortMap() {
16. return sortMap;
17. }
18.  
19. public void setSortMap(HashMap<File, Object> sortMap) {
20. this.sortMap = sortMap;
21. }
22.  
23. public String getPrefix() {
24. return prefix;
25. }
26.  
27. public void setPrefix(String prefix) {
28. this.prefix = prefix;
29. }
30. }

子类：

1. package readcolor;
2.  
3. import java.io.File;
4. import java.util.Collections;
5. import java.util.Comparator;
6. import java.util.HashMap;
7. import java.util.LinkedHashMap;
8. import java.util.LinkedList;
9. import java.util.Map.Entry;
10. import java.util.Set;
11.  
12. public class HashMapSortUtils extends HashMapSortUtil{
13. private int counter;//计数器，默认从多少开始进行命名 ==> 1
14. private int nameLength;//命名的长度，其实就是计数器之前需要添加几个0 ==> 3
15. private int nameExpansion = 0;//记录名字超长了需要进行扩容的次数
16. //prefix（在父类里面），counter，nameLength组成的结果就是对应的Mus001
17. private HashMap<File, File> tempFileMap = new HashMap<File, File>();//记录在进行重命名时，目标文件有重复时，将源文件拷贝出来与将要命名的名字记录到HashMap里面
18.  
19. public HashMapSortUtils() {//构造方法
20. super();
21. }
22.  
23. public HashMapSortUtils(HashMap<File, Object> sortMap, Integer counter, Integer nameLength, String prefix) {//构造方法
24. super();
25. super.setSortMap(sortMap);
26. super.setPrefix(prefix);
27. this.counter = counter;
28. this.nameLength = nameLength;
29. }
30.  
31. /**
32. * 将图片按照像素点个数进行排序的方法
33. * 参数：无
34. * 返回值：无
35. * */
36. @Override
37. public LinkedHashMap<File, Object> sortFileMap() {
38. LinkedHashMap<File,Object> linkedHashMap = new LinkedHashMap<File, Object>();
39. Set<Entry<File, Object>> mapEntries = super.getSortMap().entrySet();//将传进来需要进行排序的HashMap获取到每个节点
40. LinkedList<Entry<File, Object>> timeList = new LinkedList<Entry<File, Object>>(mapEntries);//将每个节点放到List集合中，方便利用Collections的方法进行排序
41. Collections.sort(timeList, new Comparator<Entry<File, Object>>() {//利用Comparator接口进行排序
42.  
43. @Override
44. public int compare(Entry<File, Object> o1, Entry<File, Object> o2) {
45. if(o1.getValue() == o2.getValue()){//如果两个文件的绿色像素点相同，就用文件的名字进行比较
46. return o2.getKey().compareTo(o1.getKey());
47. }
48. return ((Integer) o2.getValue()).compareTo((Integer)o1.getValue());//利用文件的绿色像素点进行比较
49. }
50. });
51.  
52. for (Entry<File, Object> entry : timeList) {//将排好序之后的文件放到LinkedHashMap中，因为如果方法HashMap中的话，你会发现它的顺序又是乱的了-o-
53. linkedHashMap.put(entry.getKey(), entry.getValue());
54. }
55. return linkedHashMap;
56. }
57.  
58. /**
59. * 重命名文件的方法
60. * 参数：linkedTimeMap：需要进行文件重命名的HashMap
61. * 返回值：无
62. * */
63.  
64. @Override
65. public void renameFiles(LinkedHashMap<File, Object> linkedTimeMap) {
66. Set<Entry<File,Object>> entrySet = linkedTimeMap.entrySet();
67. for (Entry<File, Object> entry : entrySet) {
68. renameFile(entry.getKey(), createFileName(entry.getKey())/*根据之前设置文件的名字（counter、nameLength、prefix）生成文件名*/);//重命名文件
69. }
70. //最后重命名剩下的源文件的备份文件
71. renameTempFiles();
72. }
73.  
74. /**
75. * 根据之前设置文件的名字（counter、nameLength、prefix）生成文件名
76. * 参数：oldFile：源文件
77. * 返回值：生成名字之后的文件
78. * */
79. private File createFileName(File oldFile) {
80. //通过父类获取到prefix
81. String prefix = super.getPrefix();
82. //获取结束
83. String newFileName = "";
84. newFileName += prefix;//先将前缀拼接上
85. int nameLen = String.valueOf(counter).length();//获取计数器的长度
86. if(nameLen > nameLength){//如果计数器超长了，那么命名的长度（nameLength）就需要进行扩容，不然会出现文件名重复的情况
87. nameLength++;
88. nameExpansion++;//这里记录是因为，当后面的操作出现错误时，这里可能需要将原来的长度进行恢复
89. }
90.  
91. if(nameLen <= nameLength){
92. int d_Value = String.valueOf(Math.pow(10, nameLength) - 1).length() - String.valueOf(counter).length() - 2;//计算需要填补的0的个数，这里减2是因为去除double数据后面的.0
93. for (int i = 0; i < d_Value; i++) {
94. newFileName += "0";
95. }
96. }
97. newFileName += counter;//将计数器添加到名字上
98.  
99. String oldFileName = oldFile.getName();//获取源文件的名字
100. String dirName = oldFile.getParentFile().getAbsolutePath();//获取源文件的上级文件夹的路径
101. File newFile = new File(dirName + File.separator + newFileName + oldFileName.substring(oldFileName.lastIndexOf(".")));//利用新的文件名生成文件
102. counter++;//计数器需要进行+1
103. return newFile;
104. }
105.  
106. /**
107. * 将源文件重命名为新文件的名字
108. * 参数：oldFile：源文件， newFile：新文件
109. * 返回值：无
110. * */
111. private void renameFile(File oldFile, File newFile) {
112. //=================如果源文件和新文件都存在，并且源文件和新文件的名字不相同，那么就需要将源文件备份处理，等其他文件重命名完之后再执行这类文件的重命名操作=================
113. if(oldFile.exists() && oldFile.isFile() && newFile.exists() && newFile.isFile()){
114. if(!newFile.getName().equals(oldFile.getName())){
115. //===============================将源文件做备份处理===============================
116. File oldFileTemp = null;
117. int fileTempCounter = 0;
118. //使用do...while...循环确保暂存文件中没有重复的名字
119. do{
120. oldFileTemp = new File(oldFile.getAbsolutePath() + fileTempCounter + System.currentTimeMillis());
121. fileTempCounter++;
122. }while(oldFileTemp.exists() && oldFileTemp.isFile());
123.  
124. //将源文件的内容复制到备份文件中
125. try{
126. new FileServiceImpl().copyFile(oldFile, oldFileTemp);
127. }catch (Exception e){
128. e.printStackTrace();
129. }
130. //删除源文件
131. oldFile.delete();
132. //将源文件的备份文件和源文件需要重命名的名字记录到HashMap里面，最后进行这部分文件的命名操作
133. tempFileMap.put(oldFileTemp, newFile);
134. return;
135. }
136. }
137.  
138. //如果目标文件不存在或者目标文件名与源文件名相同，就直接进行重命名的操作
139. if(oldFile.exists() && oldFile.isFile()){
140. if(oldFile.renameTo(newFile)){
141. System.out.println("重命名成功：" + oldFile.getAbsolutePath() + "==>" + newFile.getAbsolutePath());
142. return;
143. }
144. }
145.  
146. //重命名失败就将计数器减一，并且将命名的长度还原到原来的长度
147. System.out.println("====================================重命名失败：" + oldFile.getAbsolutePath() + "====================================");
148. counter--;
149. nameLength -= nameExpansion;
150. }
151.  
152. /**
153. * 重命名剩下的源文件的备份文件
154. * 参数：无
155. * 返回值：无
156. * */
157. private void renameTempFiles() {
158. Set<Entry<File, File>> entrySet = tempFileMap.entrySet();
159. for (Entry<File, File> entry : entrySet) {
160. //调用重命名的方法进行重命名
161. renameFile(entry.getKey(), entry.getValue());
162. }
163. }
164.  
165. public int getCounter() {
166. return counter;
167. }
168.  
169. public void setCounter(int counter) {
170. this.counter = counter;
171. }
172.  
173. public int getNameLength() {
174. return nameLength;
175. }
176.  
177. public void setNameLength(int nameLength) {
178. this.nameLength = nameLength;
179. }
180.  
181. }

由于counter（计数器）和nameLength（命名的长度）在进行排序和文件重命名的时候会频繁的使用到，因此我把他们放到了子类里面，避免多次调用父类的getter和setter方法。虽然我代码里面注释写得很清楚，但是还是有一些小伙伴不习惯看注释，那我稍微做一下解释，但是代码的逻辑还是要大家下来看一下！如果在博客上不太方便的话，可以直接copy到eclipse里面或者idea里面进行逻辑的分析！

（1）在主方法或其他方法需要调用到这个类型，可以直接利用该类的构造方法来调用到这个类：

1. public HashMapSortUtils(HashMap<File, Object> sortMap, Integer counter, Integer nameLength, String prefix){
2. ......
3. }

这个构造方法会将需要进行排序和重命名的HashMap加载到该类的成员变量中，该类所有方法都可以调用该HashMap，并且计数器开始的位置（counter）、命名的长度（nameLength）、命名前缀（prefix）都加载到成员变量中，其中HashMap和前缀属于父类的变量。（相信大多数人都知道，我就乱解释一番了。。。）
（2）将传进来的HashMap进行排序的方法：

1. public LinkedHashMap<File, Object> sortFileMap() {
2. ......
3. }

该方法就是利用java工具类Collections下面的sort方法进行排序，需要注意的是，最后之所以返回的是一个LinkedHashMap是因为HashMap是无序的，如果排完序还是用HashMap装排序的结果，那么就有可能没有达到排序预期的效果

（3）将排好序的HashMap中的文件重命名的方法：

1. public void renameFiles(LinkedHashMap<File, Object> linkedTimeMap) {
2. ......
3. }

该方法主要分为两个步骤：a.利用createFileName方法将之前设置好的prefix（前缀）、nameLength（命名的长度）、counter（计数器）组成新的名字；b.将HashMap中所有的entry节点利用renameFile方法进行判断是否可以直接重命名，如果可以直接重命名就直接重命名，如果需要重新命名的文件已经存在就将源文件copy一份出来，然后将拷贝文件和新的名字方法一个HashMap中，等到程序的第c步才执行这部分文件的重命名！c.将之前未进行重命名的源文件进利用renameTempFiles方法行统一的重命名！

4.文件操作的工具类

文件操作是一个公共的类，进行文件的复制、删除、获取所有文件、创建文件夹等等，都可以写做一个公共的方法，大家可以自行去了解这个类的作用，这里不再过多的赘述（嘻嘻，又可以偷波懒了），不过我这里是错误的示范，我用接口的方式来实现的，真正的生产中是不会这样做的，因为文件操作是基本上不会变的，这里我只是想单纯的联系一下接口的操做，那么废话不多说，直接上代码，都是文件操作的基础代码：

文件操作的接口：

1. package readcolor;
2.  
3. import java.io.File;
4. import java.util.List;
5.  
6. public interface FileService {
7. void copyFile(String sourcePath, String targetPath) throws Exception;
8.  
9. void copyFile(File sourceFile, File targetFile) throws Exception;
10.  
11. void mkDirs(String path) throws Exception;
12.  
13. List<File> getAllFiles(String sourcePath);
14.  
15. void removeFiles(String path);
16.  
17. void removeFiles(File sourceFile);
18. }

文件操作的实现类：

1. package readcolor;
2.  
3. import java.io.File;
4. import java.io.FileInputStream;
5. import java.io.FileOutputStream;
6. import java.util.ArrayList;
7. import java.util.List;
8.  
9. public class FileServiceImpl implements FileService{
10.  
11. @Override
12. public void copyFile(String sourcePath, String targetPath) throws Exception {
13. copyFile(new File(sourcePath), new File(targetPath));
14.  
15. }
16.  
17. @Override
18. public void copyFile(File sourceFile, File targetFile) throws Exception {
19. FileInputStream fis = new FileInputStream(sourceFile);
20. FileOutputStream fos = new FileOutputStream(targetFile);
21.  
22. byte[] buffer = new byte[1024];
23. int len = 0;
24.  
25. while((len = fis.read(buffer)) != -1){
26. fos.write(buffer, 0, len);
27. fos.flush();
28. }
29.  
30. fos.close();
31. fis.close();
32. }
33.  
34. @Override
35. public void mkDirs(String path) throws Exception {
36. File destFile = new File(path);
37. if(!destFile.exists()){
38. destFile.mkdirs();
39. }
40. }
41.  
42. @Override
43. public List<File> getAllFiles(String sourcePath) {
44. ArrayList<File> files = new ArrayList<File>();
45. File file = new File(sourcePath);
46. if(file.exists() && !file.isHidden()){
47. if(file.isFile()){
48. files.add(file);
49. }
50.  
51. if(file.isDirectory()){
52. File[] fs = file.listFiles();
53. for (File f : fs) {
54. if(!f.isHidden()){
55. if(f.isFile()){
56. files.add(file);
57. }
58.  
59. if(f.isDirectory()){
60. files.addAll(getAllFiles(sourcePath + File.separator + f.getName()));
61. }
62. }
63. }
64. }
65. }
66. return files;
67. }
68.  
69. @Override
70. public void removeFiles(String path) {
71. removeFiles(new File(path));
72. }
73.  
74. @Override
75. public void removeFiles(File sourceFile) {
76. if (!sourceFile.isDirectory()){
77. if(sourceFile.delete()) System.out.println("删除文件：" + sourceFile.getAbsolutePath() + "成功");
78. }else{
79. File[] files = sourceFile.listFiles();
80.  
81. for (File file : files) {
82. if(file.isDirectory()){
83. removeFiles(file);
84. if(file.delete()) System.out.println("删除文件夹：" + file.getAbsolutePath() + "成功");
85. }else{
86. if(file.delete()) System.out.println("删除文件：" + file.getAbsolutePath() + "成功");
87. }
88. }
89. }
90. }
91. }

好的，一切准备就绪，那我们直接开始运行代码，看看效果如何：

先准备好图片：

然后设置好文件的路径：

运行java程序：

可以看到所有的文件都已经重新排序，并且已经进行重命名了，看看实际的效果：

是不是感觉前面的图片要稍微绿一点呢？该程序可以进行重复执行的，暂时没有出现命名失败的情况，如果有小伙伴试了然后报错了，记得留言喔，我看看是啥问题，然后看看能不能再优化一下。。。（闻到了头发掉落的气息）

总结

最后，我们可以稍微改动几行代码，然后将所有的图片只输出绿色像素点来做一个直观的感受：

1. package readcolor;
2.  
3. import java.awt.image.BufferedImage;
4. import java.io.File;
5. import java.io.FileNotFoundException;
6. import java.io.IOException;
7. import java.util.HashMap;
8. import java.util.LinkedHashMap;
9.  
10. import javax.imageio.ImageIO;
11.  
12. public class ReadColor {
13. private static int count = 0;
14. public static void main(String[] args) {
15. HashMap<File, Object> imageMap = new HashMap<File, Object>();//用hashMap将文件和对应的像素点数量装到一起
16. File fileDir = new File("D:\\Download\\TestFile");//将要进行排序的文件目录
17. File[] listFiles = fileDir.listFiles();
18. for (File readFile : listFiles) {
19. getImagePixel(readFile, imageMap);//获取图片的绿色像素点数量的多少
20. }
21.  
22. HashMapSortUtils hashMapSortUtils = new HashMapSortUtils(imageMap, 1, 3, "Mus");
23. LinkedHashMap<File,Object> sortFileMap = hashMapSortUtils.sortFileMap();//将图片按照像素点的数量进行排序
24. hashMapSortUtils.renameFiles(sortFileMap);//将排好序的文件重命名（不然离开控制台就看不到文件的排序了>o<）
25.  
26. System.out.println(imageMap);
27. }
28.  
29. private static HashMap<File, Object> getImagePixel(File readFile, HashMap<File, Object> imageMap) {
30. int red = 0;//记录像素点的红色
31. int green = 0;//记录像素点的绿色
32. int blue = 0;//记录像素点的蓝色
33. int counter = 0;//程序计数器
34.  
35. BufferedImage bi = null;
36. try {
37. bi = ImageIO.read(readFile);//通过ImageIO来读取图片，以便获取图片的RGB信息
38. } catch (IOException e) {
39. e.printStackTrace();
40. }
41.  
42. int width = bi.getWidth();//获取图片的宽度
43. int height = bi.getHeight();//获取图片的高度
44. int minx = bi.getMinX();//获取图片的坐标起点x轴
45. int miny = bi.getMinY();//获取图片的坐标起点y轴
46.  
47. for(int i = minx; i < width; i++){
48. for(int j = miny; j < height; j++){
49. int pixel = bi.getRGB(i, j);
50. red = (pixel & 0xff0000) >> 16;//过滤掉图片的绿色和蓝色
51. green = (pixel & 0xff00) >> 8;//过滤掉图片的绿色
52. blue = (pixel & 0xff);//最后剩下的就是蓝色啦
53.  
54. if(green - red > 30 && green - blue > 30){//绿色的范围
55. counter++;
56. }else{
57. bi.setRGB(i, j, 0xffffff);
58. }
59. }
60. }
61. imageMap.put(readFile, counter);//将文件和像素点的个数记录到HashMap中
62.  
63. try {
64. ImageIO.write(bi, "jpg", new File("D:\\Download\\TestFile1\\" + count +".jpg"));
65. } catch (FileNotFoundException e) {
66. e.printStackTrace();
67. } catch (IOException e) {
68. e.printStackTrace();
69. }
70. count++;
71. return imageMap;
72. }
73. }

将图片的非绿色像素点修改为白色，然后存到一个新的文件夹里，看看是什么效果：

是不是只提取出了绿色像素点呢，大家在这个的基础上就可以选择自己喜欢的颜色进行排序了。反正我把这个程序送给我朋友的时候，遭到了他半个小时的感谢（问候），大家只是自己可以玩一玩，千万别去乱动别人的硬盘喔！（最后的最后，程序并没有什么实际的使用价值，只是学习了一些新的方法或者技巧，实际上我进行图像处理的时候都是直接选用photoshop进行操作的，哈哈啊哈哈！）

到此这篇关于java根据图片中绿色像素点的多少进行排序的文章就介绍到这了,更多相关java绿色像素点排序内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://blog.csdn.net/mouguangjun/article/details/114138245