小白学java日记day13：字符串实例

import java.util.Arrays;

/*有一个字符串hello4422world23haha2bingbing54xiaokun33hello82788hello333333world67890xiaokun8838383838hello88877haha

要求:
1.将所有的单词找出,并确定每个单词的个数
2.将单词和单词个数放入对象MyWord,将所有的MyWord对象存入数组.
3.分别按照单词个数和单词从小到大排序(使用匿名内部类和lambda表达式)

分析：
String
数组
匿名内部类
接口
面向对象处理
正则表达式
排序
lambad
Arrays工具类

1.将所有的单词找出，并确定每个单词的个数
我们需要将 4422 23  2 54 等等分别作为刀去对字符串进行切割--split（）
现在的刀-个数不一样，内容不一样，直接用固定大小的刀进行切割不合适
所以我们要使用正则表达式
要求：1.全是数字    2.长度是>=1
正则表达式:\\d+    \\d代表当前位可以取0-9之间的任意数字(\d代表一个数字，第一个\为转义字符)  +代表前面的\d可以取>=1个

确定每个单词的个数
先对数组进行排序
 */
public class Test {
    public static void main(String[] args) {
        //1.将所有的单词找出,并确定每个单词的个数
        //2.将单词和单词个数放入对象MyWord,将所有的MyWord对象存入数组.
       MyWord[] myWords= getWords();
        System.out.println("myWords"+Arrays.toString(myWords));


        //3.分别按照单词个数和单词从小到大排序(使用匿名内部类和lambda表达式)
        //先创建一个有比较功能的接口
        //然后在使用匿名内部类进行比较
        //匿名内部类
        queue(myWords, new MyComparator() {
            @Override
            public int compare(MyWord w1, MyWord w2) {
                return w1.nubmber-w2.nubmber;
            }
        });
        //lambad表达式
        queue(myWords,(w1,w2)->{
            return w1.nubmber-w2.nubmber;
        });
        //如果方法体中只有一条语句，我们可以将{}省略，如果由返回值，return可以省略，会自动返回
        queue(myWords,(w1,w2)->w1.nubmber-w2.nubmber);
        System.out.println("按照单词个数排序："+Arrays.toString(myWords));

        //按照单词排序
        queue(myWords, new MyComparator() {
            @Override
            public int compare(MyWord w1, MyWord w2) {
                return w1.word.compareTo(w2.word);
            }
        });
        System.out.println("按照单词排序："+Arrays.toString(myWords));
    }

    public static  void queue(MyWord[] myWords,MyComparator comparator){
        for (int i = 0; i < myWords.length-1; i++) {
            for (int j = 0; j < myWords.length-i-1; j++) {
                if (comparator.compare(myWords[j],myWords[j+1])>0){
                    MyWord temp= myWords[j];
                    myWords[j]=myWords[j+1];
                    myWords[j+1]=temp;
                }
            }
        }
    }
    public static MyWord[] getWords(){
        String str="hello4422world23haha2bingbing54xiaokun33hello82788hello333333world67890xiaokun8838383838hello88877haha";
        //设置刀
        String dao="\\d+";
        //使用正则表达式对字符进行切割
        String[] strings=str.split(dao);
        //展示
        System.out.println(Arrays.toString(strings));


       //确定每个单词的个数
        /*
        先对数组进行排序
        hello
        world
        haha
        bingbing
        xiaokun

        排完后:
        bingbing  haha   haha  hello hello hello hello world world xiaokun

         在对数组进行遍历，取出单词和单词个数，放入Word，再放入新的数组
         */
        //先排序
        for (int i = 0; i < strings.length; i++) {
            for (int j = 0; j < strings.length-1; j++) {
                if (strings[j].compareTo(strings[j+1])>0){
                    String temp=strings[j];
                    strings[j]=strings[j+1];
                    strings[j+1]=temp;
                }
            }
        }
        System.out.println("排序后的数组："+Arrays.toString(strings));

        //将数据封装进数组
        //设置临时字符串用于装过程中的单词
        String worStr= strings[0];
        //设置临时的记录当前单词次数
        int number=0;
        //创建一个新数组，用于装保存了一个单词以及单词的个数Word对象
        MyWord[] myWords=new MyWord[strings.length];
        //每个单词统计完后只保留一个，不会重复，代表新数组的下标--newNumber
        int newNumber=0;
        for (int i = 0; i < strings.length; i++) {
            if (worStr.equals(strings[i])){
                number++;
            }else{
                //存储当前单词以及单词个数
                MyWord myWord=new MyWord(worStr,number);
                //重新计数
                number=0;
                //让wordStr重新保存下一个单词
                worStr=strings[i];
                //将myWord放入公共数组
                myWords[newNumber]=myWord;
                newNumber++;

                //保证同一个单词中第一个单词也可以记录下来
                i--;
            }
            //当i=strings.length-1时，需要手动获取最后一个单词以及个数
            if (i==strings.length-1){
                MyWord myWord=new MyWord(worStr,number);
                myWords[newNumber]=myWord;
            }
        }
        //newNumber是下标 new
        return Arrays.copyOf(myWords,newNumber+1);
    }

    //创建内部类Word，用于装单词以及单词个数
    static class MyWord{
        private String word;
        private int nubmber;
        public MyWord(){}
        public MyWord(String word, int nubmber) {
            this.word = word;
            this.nubmber = nubmber;
        }

        public String getWord() {
            return word;
        }

        public void setWord(String word) {
            this.word = word;
        }

        public int getNubmber() {
            return nubmber;
        }

        public void setNubmber(int nubmber) {
            this.nubmber = nubmber;
        }

        @Override
        public String toString() {
            return "MyWord{" +
                    "word='" + word + '\'' +
                    ", nubmber=" + nubmber +
                    '}';
        }
    }

    //接口
    interface MyComparator{
        int compare(MyWord w1,MyWord w2);
    }
}