统计一句话中重复字符、单词的个数，HashMap，Queue List

//统计一句话中重复字符的个数(Queue)-----------------------------
package day081702;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;
/**
 * 统计一句话中各个字符的个数
 */
public class MapDemo01 {

    public static void main(String[] args) {
        String str = "good good study, day day up.";

        Queue<Character> queue = toQueue(str);//把一串字符串处理为只含有小写字母的队列Queue

        Map<Character,Integer> map = new HashMap<Character,Integer>();

        while(queue.size()>0){
            Character c = queue.poll();//取出首元素，并做删除操作
            if(!map.containsKey(c)){
                map.put(c, 1);
            }else{
                map.put(c, map.get(c)+1);
            }
        }
        System.out.println(map);

    }
    /**
     * 把一串字符串处理为只含有小写字母的Queue
     * （其他无关字符过滤掉）
     * @param str
     * @return Queue<Character>
     */
    public static Queue<Character> toQueue(String str){

        //存储26个小写字母
        List<Character> list26 = new ArrayList<Character>();
        for(int i=0;i<26;i++){
            Character c = (char)('a'+i);
            list26.add(c);
        }

        //一旦是小写字母，存入queue
        Queue<Character> queue = new LinkedList<Character>();
        for(int i=0;i<str.length();i++){
            Character c = str.charAt(i);//遍历每个字符
            if(list26.contains(c)){//如果26个字母包含该字符，把该字符存入queue
                queue.offer(c);
            }
        }

        return queue;
    }

}
//统计一句话中重复字符的个数(List)--------------------------------------
package day081702;

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

public class MapDemo02 {

    public static void main(String[] args) {
        String str = "good good study,day,day,up.";


        List<Character> list = toList(str);//把一串字符串处理为只含有小写字母的List
        Map<Character,Integer> map = new HashMap<Character,Integer>();

        long start = System.currentTimeMillis();
        for(int i=list.size()-1;i>=0;i--){
            Character c = list.get(i);
            if(!map.containsKey(c)){
                map.put(c, 1);
            }else{
                map.put(c, map.get(c)+1);
            }
            list.remove(i);
        }
        System.out.println(map);
        long end = System.currentTimeMillis();
        System.out.println(end-start);
    }
    /**
     * 把一串字符串处理为只含有小写字母的List
     * （其他无关字符过滤掉）
     * @param str
     * @return List<Character>
     */
    public static List<Character> toList(String str){

        //存储26个小写字母
        List<Character> list26 = new ArrayList<Character>();
        for(int i=0;i<26;i++){
            Character c = (char)('a'+i);
            list26.add(c);
        }

        //一旦是小写字母，存入list
        List<Character> list = new ArrayList<Character>();
        for(int i=0;i<str.length();i++){
            Character c = str.charAt(i);//遍历每个字符
            if(list26.contains(c)){//如果26个字母包含该字符，把该字符存入list
                list.add(c);
            }
        }

        return list;
    }

}

//统计一句话中重复单词的个数--------------------------------------
package day081702;

import java.util.Arrays;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Queue;
import java.util.Set;
/**
 * 统计一句话中重复单词的个数
 */
public class MapDemo03 {

    public static void main(String[] args) {
        String str = "good good study,    day day up.";
        Queue<String> queue = toQueue(str);//toQueue()方法把String转为只包含单词的数组(过滤掉空格和标点符号)

        /*
         * 循环队列，放入map
         */
        Map<String,Integer> map = new LinkedHashMap<String,Integer>();//LinkedHashMap可按顺序循环输出
        //Map<String,Integer> map = new HashMap<String,Integer>();//HashMap无顺序输出
        while(queue.size()>0){
            String key = queue.poll();//取出首元素，并做删除操作
            if(!map.containsKey(key)){//如果不包含该key，则装入key，计数1
                map.put(key, 1);
            }else{
                map.put(key, map.get(key)+1);//如果已经包含该key，则value增加1
            }
        }

        /*
         * 循环key
         */
        Set<String> keySet = map.keySet();
        for(String setWord:keySet){//高级for循环
            String word = setWord;
            System.out.println(word+"的重复次数："+map.get(word));
        }

        Iterator<String> it = keySet.iterator();
        while(it.hasNext()){//用Iterator来循环
            String word = it.next();
            System.out.println(word+"的重复次数："+map.get(word));
        }

        /*
         * 循环Entry
         */

        Set<Entry<String,Integer>> entrySet = map.entrySet();
        for(Entry<String,Integer> entry: entrySet){//高级for循环
            String word = entry.getKey();
            Integer num = entry.getValue();
            System.out.println(word+"重复次数："+num);
        }

        Iterator<Entry<String,Integer>> entryIt = entrySet.iterator();
        while(entryIt.hasNext()){//用Iterator来循环
            Entry<String,Integer> tmpEntry = entryIt.next();
            String word = tmpEntry.getKey();
            Integer num = tmpEntry.getValue();
            System.out.println(word+"重复次数：：："+num);

        }


    }
    /**
     * 把String转为只包含单词的数组(过滤掉空格和标点符号)
     * @param str
     * @return Queue<String>
     */
    public static Queue<String> toQueue(String str){
        String regex = "\\,|\\.";
        str = str.replaceAll(regex, " ");//把逗号点号转为空格
        System.out.println(str);

        String regex2 = "\\ +";
        str = str.replaceAll(regex2, " ");//把多个空格转为1个空格
        System.out.println(str);

        String[] words = str.split(" ");//转为单词数组
        System.out.println(Arrays.toString(words));

        //数组转为队列queue
        Queue<String> queue = new LinkedList<String>();
        for(String word : words){
            queue.offer(word);
        }
        return queue;
    }

}