public static Character[] sort(Map map){ Map<Integer,Character> mp=new HashMap<Integer,Character>(); Character[] strArr = new Character[map.size()]; Integer[] intArr = new Integer[map.size()]; int i = 0;
for (Object o : map.keySet()) { intArr[i] = (Integer)map.get(o); mp.put((Integer)map.get(o), (Character)o); i++; } array.sort(intArr);
import java.util.*;
public class str {
private String strings="123ewewed333eddfs";
public Map<String,Integer> dealstr(){
int count=0;
char ch;
Map mp=new HashMap();
for(int i=0;i<strings.length();i++){
ch=strings.charAt(i);
if(mp.containsKey(ch)){
mp.put(ch,mp.get(ch).toString()+1);
}else{
mp.put(ch,1);
}
}
return mp;
}
}这里只记录了每个字符和对应的出现次数，然后排序就可以了。但怎么排序？
public class str {
private String strings="123ewewed333eddfs";
public Map<Character,Integer> dealstr(){
char ch;
Map<Character,Integer> mp=new HashMap<Character,Integer>();
for(int i=0;i<strings.length();i++){
ch=strings.charAt(i);
if(mp.containsKey(ch)){
mp.put(ch,mp.get(ch).intValue()+1);
}else{
mp.put(ch,1);
}
}
return mp;
}
public static void main(String[] args){
System.out.println(new str().dealstr());
}
}
把map 转为set,定义一个ArrayList,添加所以的value,之后用Collention.Sort();排序·
对应的构造函数为：LinkedHashMap(指定初始容量，负载因子，true)；
public class Test { /**
* @param args
*/
private static Arrays array = null;
private static String strings="aaabbcccc666666666666";
public static Map<Character,Integer> dealstr(){
char ch;
Map<Character,Integer> mp=new HashMap<Character,Integer>();
for(int i=0;i<strings.length();i++){
ch=strings.charAt(i);
if(mp.containsKey(ch)){
mp.put(ch,mp.get(ch).intValue()+1);
}else{
mp.put(ch,1);
}
}
return mp;
}
public static Character[] sort(Map map){
Map<Integer,Character> mp=new HashMap<Integer,Character>();
Character[] strArr = new Character[map.size()];
Integer[] intArr = new Integer[map.size()];
int i = 0;
for (Object o : map.keySet()) {
intArr[i] = (Integer)map.get(o);
mp.put((Integer)map.get(o), (Character)o);
i++;
}
array.sort(intArr);
for (int j = 0; j < intArr.length; j++) {
strArr[j] = mp.get(intArr[j]);
}
return strArr;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Character[] chaArr = sort(dealstr());
for(int i = 0; i < chaArr.length; i++){
System.out.println(chaArr[i]);
}
}
}
select 字符串,count(*) as cnt from table group by 字符串 order by cnt desc
mp.put((Integer)map.get(o), (Character)o);//value的值是可以重复的，这样当两个value值相等的情况下会出错
Character[] strArr = new Character[map.size()];
Integer[] intArr = new Integer[map.size()];
int k = 0; for (Object o : map.keySet()) {
intArr[k] = (Integer) map.get(o);
strArr[k] = (Character) o;
k++;
} for (int i = 0; i < intArr.length; i++) {
for (int j = i + 1; j < intArr.length; j++) {
if (intArr[i] < intArr[j]) {
int itmp = intArr[i];
intArr[i] = intArr[j];
intArr[j] = itmp;
Character ctmp = strArr[i];
strArr[i] = strArr[j];
strArr[j] = ctmp;
}
}
} return strArr;
}
冒泡算法
import java.io.InputStreamReader;
import java.util.Arrays;public class NumberSplit { public StringBuffer getString(String str) {
StringBuffer strbuf = new StringBuffer("t");
boolean flag = true;
for (int i = 0; i < str.length(); i++) {
char c = str.charAt(i);
// 判断是否是数字
if (c >= '0' && c <= '9') {
// 判断和字符串中的数字是否重复
for (int j = 1; j < strbuf.length(); j++) {
if (c == strbuf.charAt(j)) {
// 如果重复,标志位数值为false,并跳出循环;否则标志位设置为true.
flag = false;
break;
} else
flag = true;
} // 只有在即是数字又不重复的情况下才将改字符拼接到字符串上.
if (flag) {
strbuf.append(c);
}
}
}
return strbuf;
} public static void main(String args[]) throws Exception {
System.out.println("请输入一段字符串,并以回车结束");
BufferedReader buf = new BufferedReader(
new InputStreamReader(System.in));
String str = buf.readLine();
StringBuffer strbuf = new NumberSplit().getString(str);
// 将返回的StringBuffer转换为字符数组
char c[] = strbuf.deleteCharAt(0).toString().toCharArray();
// 对字符数组排序
Arrays.sort(c);
// 输出字符数组
for (int i = 0; i < strbuf.length(); i++) {
System.out.print(c[i]);
} }
}
import java.util.*;
public class str {
private String strings="sdfasdfasdfa33333323sdsddsdsdsdsfdfdc";
public Map<Character,Integer> dealstr(){
char ch;
Map<Character,Integer> mp=new HashMap<Character,Integer>();
for(int i=0;i<strings.length();i++){
ch=strings.charAt(i);
if(mp.containsKey(ch)){
mp.put(ch,mp.get(ch).intValue()+1);
}else{
mp.put(ch,1);
}
}
System.out.println(mp);
return mp;
}
public void sort(Map mp){
Object[] k=mp.keySet().toArray();
Object[] it=mp.values().toArray();
int count=it.length;
for(int i=0;i<count;i++){
for(int j=i;j<count-1;j++){
int va1=((Integer)it[i]).intValue();
int va2=((Integer)it[j+1]).intValue();
if(va1<va2){
Object temp;
Object temp1;
temp=it[i];
it[i]=it[j+1];
it[j+1]=temp;
temp1=k[i];
k[i]=k[j+1];
k[j+1]=temp1;
}
}
}
for(int i=0;i<it.length;i++){
System.out.println(((Character)k[i]).charValue());
//System.out.println(((Integer)it[i]).intValue());
}
}
public static void main(String[] args){
str st=new str();
Map mp=st.dealstr();
st.sort(mp);
}
}有没有不需要写排序算法的呀
import java.util.*;
public class Test { /**
* @param args
*/
private static Arrays array = null;
private static String strings="aaabbcccckkkkuuuu66";
public static Map<Character,Integer> dealstr(){
char ch;
Map<Character,Integer> mp=new HashMap<Character,Integer>();
for(int i=0;i<strings.length();i++){
ch=strings.charAt(i);
if(mp.containsKey(ch)){
mp.put(ch,mp.get(ch).intValue()+1);
}else{
mp.put(ch,1);
}
}
return mp;
}
public static Character[] sort(Map map){
Map<Integer,Character> mp=new HashMap<Integer,Character>();
Character[] strArr = new Character[map.size()];
ArrayList tmepList = new ArrayList();
Collection tempSet = map.values();
int i = 0;
HashSet hashSet = new HashSet();
hashSet.addAll(tempSet);
Integer[] intArr = new Integer[hashSet.size()];
intArr = (Integer[])hashSet.toArray(intArr);
array.sort(intArr);
for (int j = 0; j < intArr.length; j++) {
for (Object o : map.keySet()) {
if ((Integer) map.get(o) == intArr[j]) {
strArr[i] = (Character) o;
i++;
}
}
}
return strArr;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Character[] chaArr = sort(dealstr());
for(int i = 0; i < chaArr.length; i++){
System.out.println(chaArr[i]);
}
}
}
BufferedReader bfReader = new BufferedReader(inStream);
HashSet<Character> charSet = new HashSet<Character>();
HashSet<Integer> intSet = new HashSet<Integer>();
HashMap<Character, Integer> map = new HashMap<Character, Integer>();
String charString = null;
Integer countOccurs = 0;
//读字符串
try {
charString = bfReader.readLine();
} catch (IOException e1) {
e1.printStackTrace();
return;
}
//把字符串转化成字符数组
char[] charArray = charString.toCharArray();
//把字符和字符出现的次数分别存放到set里。并把键值对存放到map中
for (int i = 0; i < charArray.length; i++) {
if (charSet.contains(charArray[i])) {
continue;
}
charSet.add(charArray[i]);
countOccurs = countOccurs(charArray[i], charString);
if (!intSet.contains(countOccurs)) {
intSet.add(countOccurs);
}
map.put((Character) charArray[i], countOccurs);
} Integer[] list = sort(intSet);
for (int i = 0; i < list.length; i++) {
valueToKey(map, list[i]);
}
}
//输出字符和字符出现的次数
private static void valueToKey(HashMap<Character, Integer> map,
Integer value) { Set entries = map.entrySet();
Iterator it = entries.iterator();
while (it.hasNext()) {
Map.Entry entry = (Entry) it.next();
if (entry.getValue() == value) {
Character ch = (Character) entry.getKey();
System.out.println(ch + "Occurs " + value + "times!");
}
} }
//计算字符在字符串中出现的次数
private static int countOccurs(Character ch, String str) { int count = 0;
int frontIndex = str.indexOf(ch);
int lastIndex = str.lastIndexOf(ch);
if (frontIndex == lastIndex) {
count = 1;
return count;
}
while (frontIndex < lastIndex) {
count++;
frontIndex = str.indexOf(ch, frontIndex + 1);
if (frontIndex == lastIndex) {
count++;
break;
}
}
return count;
} //set中字符出现的次数从大到小排序
public static Integer[] sort(HashSet<Integer> intSet) { Integer[] list = new Integer[intSet.size()];
int count = 0;
for (Integer i : intSet) {
list[count++] = i;
}
for (int i = 1; i < list.length; i++) {
int t = list[i];
int j = i;
while ((j > 0) && (list[j - 1] < t)) {
list[j] = list[j - 1];
--j;
}
list[j] = t;
}
return list;
}
}
这个比较烦，但是可以实现功能 我刚才试过了
//之所以不用Set，是因为考虑到Set不能容纳重复的对象，字符串中有可能会出现多个字符的个数是一样的import java.io.*;
import java.util.*;public class StringTest
{
public static void main(String[] args)
{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
try
{
int count=1; //定义一个计数变量count
String str=br.readLine(); //从键盘读入字符串
LinkedList ll=new LinkedList();
char[]ch=new char[str.length()];
for(int i=0;i<str.length();i++)
{
ch[i]=str.charAt(i); //将字符串中的字符放入数组ch
}
Arrays.sort(ch); //对数组中的字符排序，方便计算字符的个数
for(int n=0;n<ch.length;)
{
if(ch[n]==ch[ch.length-1])
{
ll.add(new Integer(ch.length-n));
//如果字符ch[n]与末尾字符相同，则循环结束，该字符的个数为length-n
break;
}
for(int j=n+1;j<ch.length;j++)
{
if(ch[n]==ch[j])
{
count++; //遇到相同字符，计数变量count加1
}
else
{
n=j; //遇到ch[j]!=ch[n]，则赋值n=j，数组位置调整为j，向后循环
break;
}
}
ll.add(new Integer(count)); //将字符个数count包装成Integer类型，加到LinkedList的尾端
count=1; //计数变量count重新赋值为1，准备计算下一个字符的个数
}
Object []o=ll.toArray(); //将LinkedList转换为数组
Arrays.sort(o); //对数组排序（升序）
for(int k=o.length-1;k>=0;k--)
{
System.out.println(o[k]); //倒序输出该数组，即可得到如题的答案
}
}
catch(IOException e)
{
System.out.println(e.getMessage());
}
}}
for (Object o : map.keySet()) {
if ((Integer) map.get(o) == intArr[j]) {
strArr[i] = (Character) o;
i++;
}
}
像这个strings="aaabbcccckkkkuuuu66"; 当cku都是四次的会出问题吧
for (Object o : map.keySet()) {
if ((Integer) map.get(o) == intArr[j]) {
strArr[i] = (Character) o;
i++;
}
}
像这个strings="aaabbcccckkkkuuuu66"; 当cku都是四次的会出问题吧
package com.feng.csdn;import java.util.*;
public class CsdnOne {
public Map<Character,Integer> dealstr(){
System.out.println("输入任意字符串：");
Scanner scanner = new Scanner(System.in);
String strings = scanner.nextLine();
char ch;
Map<Character,Integer> mp=new HashMap<Character,Integer>();
for(int i=0;i<strings.length();i++){
ch=strings.charAt(i);
if(mp.containsKey(ch)){
mp.put(ch,mp.get(ch).intValue()+1);
}else{
mp.put(ch,1);
}
}
System.out.println(mp);
return mp;
}
public void sort(Map mp){
Object[] k=mp.keySet().toArray();
Object[] it=mp.values().toArray();
int count=it.length;
for(int i=0;i<count;i++){
for(int j=i;j<count-1;j++){
int va1=((Integer)it[i]).intValue();
int va2=((Integer)it[j+1]).intValue();
if(va1<va2){
Object temp;
Object temp1;
temp=it[i];
it[i]=it[j+1];
it[j+1]=temp;
temp1=k[i];
k[i]=k[j+1];
k[j+1]=temp1;
}
}
}
System.out.println("字符出现次数从高到低排列：");
for(int i=0;i<it.length;i++){
System.out.println(((Character)k[i]).charValue());
//System.out.println(((Integer)it[i]).intValue());
}
}
public static void main(String[] args){
CsdnOne st=new CsdnOne();
Map mp=st.dealstr();
st.sort(mp);
}
}
import java.util.Arrays;
import java.util.Hashtable;public class SortString implements Comparable
{
String src="";
public int compareTo(Object o)
{
int current=Integer.parseInt(src.split(";")[1]);
SortString s=(SortString)o;
int oCurrent=Integer.parseInt(s.src.split(";")[1]);
if(current>oCurrent)
return -1;
else
return 1;
}
public SortString(String src)
{
this.src=src;
}
public static void main(String[] args)
{
String srcString="ssssddwweeeggggg";
char srcChar[]=srcString.toCharArray();
Hashtable<Character, Integer> ht=new Hashtable<Character, Integer>();
for(char s : srcChar)
{
if(ht.containsKey(s))
ht.put(s, ht.get(s)+1);
else
ht.put(s, 1);
}
int i=0;
SortString all[]=new SortString[ht.size()];
for(Object o:ht.keySet().toArray())
{
all[i++]=new SortString(o.toString()+";"+ht.get(o.toString().charAt(0)));
}
Arrays.sort(all);
for(SortString o:all)
{
SortString sortString=(SortString)o;
System.out.println(sortString.src.split(";")[0]+"出现次数:"+sortString.src.split(";")[1]);
}
}}运行结果：
g出现次数:5
s出现次数:4
e出现次数:3
d出现次数:2
w出现次数:2
import java.util.Arrays;
import java.util.Hashtable;
import java.util.Scanner;public class SortString implements Comparable
{
String src="";
public int compareTo(Object o)
{
int current=Integer.parseInt(src.split(";")[1]);
SortString s=(SortString)o;
int oCurrent=Integer.parseInt(s.src.split(";")[1]);
if(current>oCurrent)
return -1;
else
return 1;
}
public SortString(String src)
{
this.src=src;
}
public static void main(String[] args)
{ Scanner sc=new Scanner(System.in);
String srcString=sc.nextLine();
//String srcString="ssssddwweeeggggg";
char srcChar[]=srcString.toCharArray();
Hashtable<Character, Integer> ht=new Hashtable<Character, Integer>();
for(char s : srcChar)
{
if(ht.containsKey(s))
ht.put(s, ht.get(s)+1);
else
ht.put(s, 1);
}
int i=0;
SortString all[]=new SortString[ht.size()];
for(Object o:ht.keySet().toArray())
{
all[i++]=new SortString(o.toString()+";"+ht.get(o.toString().charAt(0)));
}
Arrays.sort(all);
for(SortString o:all)
{
SortString sortString=(SortString)o;
System.out.println(sortString.src.split(";")[0]+"出现次数:"+sortString.src.split(";")[1]);
}
}}
Map<Character, Integer> map = new HashMap<Character, Integer>();
for (int i = 0, x = a.length(); i < x; i++) {
Character c = a.charAt(i);
Integer y = map.get(c);
y = y == null ? 0 : y;
map.put(c, y + 1);
}
int[][] arr = new int[map.size()][2];
int i = 0;
for (Character c : map.keySet()) {
arr[i][0] = c;
arr[i++][1] = map.get(c);
}
Arrays.sort(arr, new Comparator<int[]>() { public int compare(int[] o1, int[] o2) {
return o2[1] - o1[1];
//return (o2[1] - o1[1]) * Character.MAX_VALUE + (o1[0] - o2[0]);//次数相同，字符升序
//return (o2[1] - o1[1]) * Character.MAX_VALUE + (o2[0] - o1[0]);//次数相同，字符降序
}
});
for (int[] is : arr) {
System.out.println((char) is[0] + " " + is[1]);
}
}
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;public class Compositor { public static void main(String[] args) {
Map<Character, Integer> m = new HashMap<Character, Integer>();
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.println("请输入任意字符串：");
String s;
try {
s = br.readLine();
char[] c = s.toCharArray(); for (int i = 0; i < c.length; i++) {
if (m.containsKey(c[i])) {
m.put(c[i], m.get(c[i]).intValue() + 1);
} else {
m.put(c[i], 1);
}
}
Collection<Integer> ce = m.values();
HashSet<Integer> hs = new HashSet<Integer>();
hs.addAll(ce);
Integer[] I = new Integer[hs.size()];
I = (Integer[]) hs.toArray(I);
Arrays.sort(I); int j = 0;
for (int i = I.length; i > 0; i--) { for (Object o : m.keySet()) {
char ch = (Character) o;
if (I[i - 1] == m.get(ch)) {
System.out.println(ch + "出现的次数为：" + m.get(ch));
} j++;
}
}
} catch (IOException e) { e.printStackTrace();
} }}
import java.util.Arrays;public class ChangeQueue {
public static void main(String[] args){
System.out.println("Please input a string: ");
Scanner sca = new Scanner(System.in);
String s = sca.next();
char[] ch = s.toCharArray();
char[] ch2 = new char[ch.length];
Arrays.sort(ch);
for(int i=0;i<ch.length;i++){
ch2[i] = ch[ch.length-i-1];
}
System.out.print(ch2);
}
}
sort()里面没参数 就是按默认的规定排序
这里要重新实现一个排序类接口
comparator 自己定义排序方式其实只要理解 方法arrays.sort() collections.sort()是怎么实现的
什么排序都可以解决 前天不是有个加精排序的帖子 排序方法差不多