Substring with Concatenation of All Words, 返回字符串中包含字符串数组所有字符串元素连接而成的字串的位置

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


public class SubstringwithConcatenationofAllWords {
    
    public List<Integer> findSubstring(String s, String[] words) {
        
        ArrayList<Integer> result = new ArrayList<Integer>();
        if(s==null||s.length()==0||words==null||words.length==0){
            return result;
        } 
     
        //frequency of words
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        for(String w: words){
            if(map.containsKey(w)){
                map.put(w, map.get(w)+1);
            }else{
                map.put(w, 1);
            }
        }
     
        int len = words[0].length();
     
        for(int j=0; j<len; j++)
        {
            HashMap<String, Integer> currentMap = new HashMap<String, Integer>();
            int start = j;//起始下标，因为len为窗口大小，所以起始下标只需在0-len之间循环，就像取模一样，超过了，就重复了。
            int count = 0;//记录满足的字符串数量
     
            for(int i=j; i<=s.length()-len; i=i+len)
            {
                String sub = s.substring(i, i+len);
                if(map.containsKey(sub))
                {
                    if(currentMap.containsKey(sub))
                    {
                        currentMap.put(sub, currentMap.get(sub)+1);
                    }
                    else
                    {
                        currentMap.put(sub, 1);
                    }
     
                    count++;
                    //只要发现子字符串中有重复的字符数组中的元素，那么就从起始位置循环删除字符串.
                    //也就是说重复了，就逆向操作，直至只包含一个重复的那个字符串。
                    while(currentMap.get(sub)>map.get(sub))
                    {
                        //四个基本逆向操作。重复了或匹配成功了都要进行窗口滑动。
                        String left = s.substring(start, start+len);
                        currentMap.put(left, currentMap.get(left)-1);
                        count--;
                        start = start + len;
                    }
     
     
                    if(count==words.length)//字符串包含所有字符数组中的元素,
                    {
                        result.add(start); //将起始位置加入result
                        //四个基本逆向操作。窗口滑动。窗口值为len
                        String left = s.substring(start, start+len);
                        currentMap.put(left, currentMap.get(left)-1);
                        count--;
                        start = start + len;
                    }
                }
                else
                {
                    currentMap.clear();
                    start = i+len;
                    count = 0;
                }
            }
        }
     
        return result;
    }
}

public int strStr(String haystack, String needle) {
        
        if(haystack == null || needle == null)
        {
            return -1;
        }
        
        for (int i = 0; i <= (haystack.length()-needle.length()); i++) 
        {
            int m = i;
            for (int j = 0; j < needle.length(); j++) 
            {
                if (needle.charAt(j) == haystack.charAt(m)) 
                {
                    m++;
                    if((m-i) == needle.length())
                    {
                        return i;
                    }
                } 
                else 
                {
                    break;
                }
            }
        }
        return -1;
    }