一个算法问题：从一组数中找出n组相同的，求大家帮忙！

[heochuan]

我现在要做一个功能，从一些图片当中找出几组相似的图片。
现在比较图片相似度的方法做完了，发现还要用到一个算法，怎么从一组数据中找出n组相似的数据？

举个例子：
现在有一组数：String[] s = {"1","10","5","3","2","3","4","5","8","5","6","7","8","9","10","10"};
想要结果：
{"10","10","10"};
{"5","5","5"};
{"3","3"};
{"8","8"};
不用排序，把相同的放到一组就行。
用什么算法能解决求大神帮帮忙！

[BoRoBoRoMe]

List<List<String>> result = Arrays.asList(s).stream() .collect(Collectors.groupingBy(p -> p)) .values().stream() .filter(list -> list.size() > 1) .collect(Collectors.toList());

[qq_39936465]

引用 楼主 heochuan 的回复:

我现在要做一个功能，从一些图片当中找出几组相似的图片。 现在比较图片相似度的方法做完了，发现还要用到一个算法，怎么从一组数据中找出n组相似的数据？ 举个例子： 现在有一组数：String[] s = {"1","10","5","3","2","3","4","5","8","5","6","7","8","9","10","10"}; 想要结果： {"10","10","10"}; {"5","5","5"}; {"3","3"}; {"8","8"}; 不用排序，把相同的放到一组就行。 用什么算法能解决求大神帮帮忙！

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String[] s = { "1", "10", "5", "3", "2", "3", "4", "5", "8", "5", "6", "7", "8", "9", "10", "10" };
		// 申明一个map key用来存放字符串的值，value用来存放重复次数
		Map<String, Integer> map = new HashMap<String, Integer>();
		List<String> list = Arrays.asList(s);
		Collections.sort(list);
		for (int i = 0; i < s.length - 1;) {
			int k = 1,t=0;
			for (int j = i + 1; j < s.length;) {
				if (s[i].equals(s[j])) {
					k++;
					j++;
				} else {
					t=j;
					break;
				}
			}
			if (k > 1) map.put(s[i], k);
			i=t;
		}
		for (Map.Entry<String, Integer> entry : map.entrySet()) {
			String mapkey = entry.getKey();
			int mapvalue = entry.getValue();
			System.out.print("{");
			for (int i = 0; i < mapvalue; i++) {
				if (i + 1 == mapvalue) {
					System.out.print(mapkey + "}");
				} else {
					System.out.print(mapkey + ",");
				}
			}
			System.out.println();
		}
	}

[paullbm]

先自定义一个类Struct，如下：

package csdn;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Struct {
	private String[] s;
	private Map<String, Integer> map = new HashMap<String, Integer>();
	private List<String> list = new ArrayList<String>();

	//构造函数，进行初始化
	public Struct(String[] _s) {
		this.s = _s;
		this.init();
	}

	private void init() {
		for (String key : this.s) {
			if (this.map.containsKey(key) == false) {
				// 使用map结构，去除重复key
				this.map.put(key, 1);
				// 首次添加进list,便于保持原顺序
				this.list.add(key);
			} else {
				int cnt = (int) this.map.get(key);
				cnt++;
				this.map.put(key, cnt);
			}
		}
	}

	/**
	 * 根据过滤条件得到相应的结果
	 * @param filterCount 元素至少要出现的次数
	 * @return List<String>
	 */
	public List<String> getResult(int filterCount) {
		List<String> resultList = new ArrayList<String>();
		for (String key : this.list) {
			int keyCount = (int) this.map.get(key);
			if (keyCount >= filterCount) {
				int count = this.map.get(key);
				StringBuffer sb = single(key, count);
				resultList.add(sb.toString());
			}
		}
		return resultList;
	}

	// 方法重载，给定默认过滤次数为2
	public List<String> getResult() {
		return this.getResult(2);
	}

	/**
	 * 根据出现的次数来拼接由元素所组成的字符串
	 * @param key
	 * @param count
	 * @return
	 */
	private StringBuffer single(String key, int count) {
		// 使用StringBuffer拼接字符串效率更高
		StringBuffer sb = new StringBuffer();
		sb.append('{');
		for (int i = 0; i < count - 1; i++) {
			sb.append('\"' + key + '\"');
			sb.append(',');
		}
		sb.append('\"' + key + '\"');
		sb.append('}');
		return sb;
	}
}

再写测试类SameFound：

package csdn;

import java.util.List;

public class SameFound {

	public static void main(String[] args) {
		String[] s = { "1", "10", "5", "3", "2", "3", "4", "5", "8", "5", "6", "7", "8", "9", "10", "10" };
//		想要结果：
//		{"10","10","10"};
//		{"5","5","5"};
//		{"3","3"};
//		{"8","8"};

		Struct struct = new Struct(s);
		List<String> list = struct.getResult();
//		List list = cls.getResult(2); //用这条执行也可
		for (String	 str : list) {
			System.out.println(str);
		}
	}
}

[三仙半]

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

public class FindEquals {

	public static void main(String[] args) {
		String[] s = { "1", "10", "5", "3", "2", "3", "4", "5", "8", "5", "6", "7", "8", "9", "10", "10" };

		// 以下为分组功能
		Map<String, List<String>> result = new HashMap<>();
		String tmp;
		List<String> tmpLst;
		for (int i = 0; i < s.length; i++) {
			tmp = s[i];
			if (result.containsKey(tmp)) {
				result.get(tmp).add(tmp);
			} else {
				tmpLst = new ArrayList<String>();
				tmpLst.add(tmp);
				result.put(tmp, tmpLst);
			}
		}

		// 以下是检查分组效果
		List<String> lst;
		String group;
		for (String key : result.keySet()) {
			lst = result.get(key);
			// //不输出没有相同结果的项目
			// if (lst.size() > 1) {
			group = "";
			for (Iterator<String> iterator = lst.iterator(); iterator.hasNext();) {
				// System.out.println("\t" + iterator.next());
				if (group.length() == 0) {
					group = iterator.next();
				} else {
					group += (", " + iterator.next());
				}
			}
			group = "{" + group + "}";
			System.out.println(group);
			// }
		}
	}
}

[qybao]

直接for循环就可以了

String[] s = {"1","10","5","3","2","3","4","5","8","5","6","7","8","9","10","10"};
List<String> buf = new ArrayList<>(Arrays.asList(s)); //把数组转成集合
List<List<String>> result = new ArrayList<>(); //结果
for (; buf.size()>0; ) { //如果集合里的还有元素
    String ss = buf.get(0); //取出集合元素
    List<String> list = new ArrayList<>(buf); //临时集合
    list.retainAll(Arrays.asList(new String[] {ss})); //保留集合中重复的元素到临时集合
    if (list.size() > 1) { //如果临时集合的元素大于1，即有重复
        result.add(list); //则保留到结果集
    }
    buf.removeAll(list); //删除已经分组的元素
}
for (List<String> l : result) { //打印结果
    System.out.println(l);
}