程序实现对数据排序并按出现次数进行排序 目录 1. 题目程序实现对数据排序并按出现次数进行排序 1 2. 思路 2 3. 效果 2 4. 代码 /00listPrj/src/Sort.java 2

程序实现对数据排序并按出现次数进行排序

 

目录

1. 题目程序实现对数据排序并按出现次数进行排序 1

2. 思路 2

3. 效果 2

4. 代码 /00listPrj/src/Sort.java 2

 

 

1. 题目程序实现对数据排序并按出现次数进行排序

程序实现对数据排序并按出现次数进行排序（注：用面向对象的方式实现，用for循环进行排序，别用comparable接口实现）{1，4，2，1，3，2，1，4}作为参数(参数可变)传入java方法中，控制台输出以下结果

1出现了3次

2出现了2次

4出现了2次

3出现了1次

 

 

 

1. 思路

数据排序

Groupby分组聚合操作（数字，次数）

倒排序操作（按照次数）

 

1. 效果

 

1. 代码 /00listPrj/src/Sort.java

 

import java.util.ArrayList;

import java.util.HashSet;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

 

import com.alibaba.fastjson.JSON;

@SuppressWarnings("all")

public class Sort {

public static void main(String[] args) {

// 定义一个长度为10的数组；

int[] array = new int[] { 1, 4, 2, 1, 3, 2, 1, 4 };

// 数组的长度

int length = array.length;

 

 

sortArray(array, length);

System.out.println("\n冒泡排序后的数组元素顺序：");

for (int m = 0; m <= length - 1; m++) {

System.out.print(array[m] + "\t");

}

 

System.out.print("\r\n");

 

 

 

//执行groupby 聚合操作，获取元素和出现次数

List<Map> rzt = getKeyAndCount_groupbyKey(array);

System.out.println( JSON.toJSONString(rzt, true));

 

//执行排序 ,按照出现次数

List<Map> rzt_final = orderByCountDesc(rzt);

System.out.println( JSON.toJSONString(rzt_final, true));

 

 

 

 

 

//输出结果

for (Map map : rzt_final) {

try {

 System.out.println(map.get("num")+"出现了"+map.get("count")+"次");

} catch (Exception e) {

// TODO: handle exception

}

 

}

 

}

 

private static List<Map> getKeyAndCount_groupbyKey(int[] array ) {

 

//分组运算，得到四个组

Set<Integer> intElementKeySet = getKeySet(array, array.length);

List<Map> rzt = new ArrayList<>();

for (Integer k : intElementKeySet) {

Map m = new LinkedHashMap<>();

m.put("num", k);

//做了count聚合运算

m.put("count", count(k, array));

rzt.add(m);

// System.out.println(k+"出现了"+getcount(k,array)+"次");

}

return rzt;

}

 

private static Set<Integer> getKeySet(int[] array, int length) {

Set<Integer> st = new LinkedHashSet<>();

 

for (int m = 0; m <= length - 1; m++) {

st.add(array[m]);

}

return st;

}

 

private static void sortArray(int[] array, int length) {

// 数值中转变量

int num = 0;

// 将数组进行9次比较

for (int n = 0; n <= length - 2; n++) {

// 将数组内元素进行9次的两两比较

for (int i = 0; i <= length - 2; i++) {

if (array[i] > array[i + 1]) {

// 比较大小后，进行位置互换

num = array[i + 1];

array[i + 1] = array[i];

array[i] = num;

}

}

}

}

//根据count字段倒排列表

private static List<Map> orderByCountDesc(List<Map> rzt) {

List<Map> rzt_final = new ArrayList<>();

for (int i = 0; i < 100; i++) {

Map max = getMax(rzt);

rzt_final.add(max);

rzt.remove(max);

}

return rzt_final;

}

 

private static Map getMax(List<Map> rzt) {

int maxcnt = 0;

Map maxMap = null;

for (Map map : rzt) {

Integer cnt = (Integer) map.get("count");

if (cnt > maxcnt) {

maxMap = map;

maxcnt = cnt;

}

 

}

return maxMap;

}

   //计算某一元素出现次数

private static Integer count(Integer k, int[] array) {

int cnt = 0;

for (int i : array) {

if (k == i)

cnt++;

}

return cnt;

}

}