查找一个字符串中最长不含重复字符的子字符串，计算该最长子字符串的长度

[a b c]
  [b c d]
    [c d b]
      [d b e]
        [b e f]
          [e f d]
		    [f d n]

public class LeetCode {

    public static int lengthOfLongestSubstring(String s) {
        if (s == null){
            return 0;
        }
        if (s.length() == 1){
            return 1;
        }

        // set 用来存储窗口的字符
        Set<Character> set = new HashSet();

        // 指针i
        int i = 0;
        // 指针j
        int j = i;
        // 最大长度
        int max = 0;

        char[] sc = s.toCharArray();
        while(j < sc.length && i <= j){
            // 当字符没在窗口中
            if (!set.contains(sc[j])){
                set.add(sc[j]);
                // 指针j 移动
                j++;
            }else {
                // 如果字符在窗口中时, 得到当前窗口中的字符个数
                int size = set.size();
                if (max < size){
                    max = size;
                }
                // 将set中存储的字符清空
                set.clear();
                // 指针i 移动
                i++;
                // 指针j 移动到指针i 的位置
                j = i;
            }
        }
        // 当指针j 移动到字符串尾部时, 窗口中可能还存在字符
        if (set.size() > max){
            max = set.size();
            set.clear();
            set = null; // help GC
        }

        return max;
    }


    public static void main(String[] args) {
        System.out.println(lengthOfLongestSubstring("abcdbefdn"));
    }

}

[ a b c d ]

  [ b c d ]

    [ c d b e f ]

      [ d b e f ]

        [ b e f d n ]

public class LeetCode {

    public static int lengthOfLongestSubstring(String s) {
        if (s == null){
            return 0;
        }
        if (s.length() == 1){
            return 1;
        }
        // map 用来存储窗口字符, key是字符, value为字符在字符串中的下标位置
        Map<Character, Integer> map = new HashMap<Character, Integer>();

        // 指针j
        int j = 0;
        // 重复字符的位置, 默认为-1
        int i = -1;
        // 最大长度
        int max = 0;

        char[] sc = s.toCharArray();
        while(j < sc.length){
            if (map.containsKey(sc[j])){
                // 获取map中重复字符的位置
                int index = map.get(sc[j]);
                if (index > i){
                    i = index;
                }
            }
            // 指着j - 重复字符的位置 = 当前窗口的大小
            if ((j-i) > max){
                max = j-i;
            }
            // 如果map中存在重复字符的话,这里是将字符的位置进行更新 ; 如果不是重复字符的话，就直接存放到map中
            map.put(sc[j], j);
            j++;
        }
        map.clear();
        map = null; // help GC

        return max;
    }

    public static void main(String[] args) {
        System.out.println(lengthOfLongestSubstring("abcdbefdn"));
    }
}