@Configuration
@ConditionalOnExpression("${cache.response.enabled:false}")
public class FilterRegistrationBeanConfigration {
  @Bean
  public FilterRegistrationBean filterRegistrationBean() {
    return new FilterRegistrationBean() {{
      setFilter(new OncePerRequestFilter() {
        @Override
        protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
          HttpServletResponse responseToUse = new ContentCachingResponseWrapper(response);
          filterChain.doFilter(request, responseToUse);
          ((ContentCachingResponseWrapper) responseToUse).copyBodyToResponse();
        }
      });
    }};
  }
}

Analyzer defaultAnalyzer = new PinyinAnalyzer();
Map<String,Analyzer> fieldAnalyzers = new HashMap<>();
//Defines an analyzer to use for the specified field.
fieldAnalyzers.put("name",new StandardAnalyzer());
fieldAnalyzers.put("fieldName",new SmartChineseAnalyzer());
PerFieldAnalyzerWrapper analyzerWrapper = new PerFieldAnalyzerWrapper(defaultAnalyzer,fieldAnalyzers);

private PerFieldAnalyzerWrapper analyzerWrapper;

  PerFieldAnalyzerWrapper getAnalyzerWrapper() {
    if (analyzerWrapper == null) {
      analyzerWrapper = new PerFieldAnalyzerWrapper(new PinyinAnalyzer());
    }
    return analyzerWrapper;
  }


  void addNewAnalyzer(String fieldName, Analyzer analyzer) {
    PerFieldAnalyzerWrapper wrapper = getAnalyzerWrapper();
    Map<String, Analyzer> map = new HashMap<>();
    try {
      Field field = PerFieldAnalyzerWrapper.class.getDeclaredField("fieldAnalyzers");
      field.setAccessible(true);
      if (!field.get(wrapper).equals(new HashMap<>())) {
        map = (Map<String, Analyzer>) field.get(wrapper);
      }
      map.put(fieldName, analyzer);
    } catch (Exception e) {
      e.printStackTrace();
    }
    analyzerWrapper = new PerFieldAnalyzerWrapper(new PinyinAnalyzer(), map);
  }

/**
 * Definition for ListNode.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int val) {
 *         this.val = val;
 *         this.next = null;
 *     }
 * }
 */
public class Solution {
    /**
     * @param head: The first node of linked list.
     * @return: True if it has a cycle, or false
     */
    public boolean hasCycle(ListNode head) {
        if (head == null || head.next == null){
            return false;
        }
        ListNode first = head;
        ListNode second = head;
        while (first != null && second != null && second.next != null){
            second = second.next.next;
            first = first.next;
            if (first == second){
                return true;
            }
        }
        return false;
    }
}

//代码 1
public class Solution {
    public int[] twoSum(int[] nums, int target) {
        int a[] = new int[2];
        for(int i = 0;i < nums.length -1;i++){
            a[0] = i;
            for(int j = i + 1;j < nums.length;j++){
                a[1] = j;
                if((nums[a[0]] + nums[a[1]]) == target){
                    return a;
                }
            }
        }
        return a;
    }
}

//代码2
public class Solution {
    public int[] twoSum(int[] nums, int target) {
        HashMap<Integer,Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            if (map.get(nums[i]) != null) {
                int[] result = {map.get(nums[i]), i};
                return result;
            }
            map.put(target - nums[i], i);
        }
        int[] result = {};
        return result;
    }
}

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public void deleteNode(ListNode node) {
        node.val = node.next.val;
        node.next = node.next.next;
    }
}

//递归
public class Solution {
    public int integerBreak(int n) {
        int a[] = {1,2,4,6,9};
        if(n < 7){
            return a[n-2];
        }
        else return 3 * integerBreak(n-3);
    }
}

//非递归
public class Solution {
    public int integerBreak(int n) {
        int a[] = {1,2,4,6,9};
        if(n < 7){
            return a[n-2];
        }
        int val = 1;
        while(n >= 7){
            val = 3 * val;
            n = n-3;
        }
        return a[n-2] * val;
    }
}