Java 코드 최적화

Question

이 코드를 어떻게 최적화 할 수 있습니까? 나는 ipfilter를 만들었고 그것을 최적화해야합니다.

package com.ipfilter;

import java.util.HashMap;
import java.util.Map;

/**
 *      IPFilter
 * 
 *      Loads given IP addresses to memory, so you can  easily check if ip addres has been blocked
 */

public class IPFilter {
        private Map<Integer, IPFilter> filter = new HashMap<Integer, IPFilter>();

        /**
         * Convert String ip address to Integer array and then calls add ip method
         * @param ip
         * @return
         */
        public void addIP(String ip)
        {
                int[] numbers = convert(ip);
                addIP(numbers, 0);
        }

        /**
         * Convert String ip address to Integer array
         * @param ip
         * @return
         */
        private int[] convert(String ip) {
                String[] strings = ip.split("\\.");
                int[] numbers = new int[strings.length];
                for(int i = 0; i < strings.length; i++)
                {
                        numbers[i] = Integer.parseInt(strings[i]);
                }
                return numbers;
        }

        /**
         * Add ip address to memory
         * @param ip
         * @param level
         */
        private void addIP(int[] ip, int level) {
                if(level < ip.length)
                {
                        if (filter.containsKey(ip[level])) {
                                filter.get(ip[level]).addIP(ip, level + 1);
                        } else {
                                filter.put(ip[level], new IPFilter());
                                filter.get(ip[level]).addIP(ip, level + 1);
                        }
                }
        }

        /**
         * Checks if ip address is in filter
         * @param ip
         * @return
         */
        public boolean isBlocked(String ip)
        {
                return isBlocked(filter, convert(ip), 0);
        }

        /**
         * Check if ip address is blocked
         * @param list
         * @param ip
         * @param level
         * @return
         */
        private boolean isBlocked(Map<Integer, IPFilter> list, int[] ip, int level)
        {
                if(list.containsKey(ip[level]))
                {
                        if(level < ip.length - 1)
                        {
                                return isBlocked(list.get(ip[level]).getList(), ip, level + 1);
                        }
                        else
                        {
                                return true;
                        }
                }
                else
                {
                        return false;
                }
        }       

        /**
         * Getter for list
         * @return
         */
        protected Map<Integer, IPFilter> getList() {
                return filter;
        }
}

Answer 1

일부 일반적인 사용 사례를 통해 프로파일을 프로파일하고 해당 데이터를 사용하여 성능 병목 현상이 어디에 있는지 확인하십시오. 그 다음에, 해당 코드를 최적화하십시오.

실제로 성능 문제가 어디에 있는지 모르면 마이크로 초 절약에 많은 시간과 노력을 할 수 있습니다.

Answer 2

정확히 무엇을 최적화하려고하는지 잘 모르겠습니다. 그러나 몇 가지가 있습니다 containsKey 그 뒤에 get. 가능한 최적화는 사용하는 것입니다 get 그리고 비교 null. 예를 들어 : 대신 :

 if (filter.containsKey(ip[level])) {
      filter.get(ip[level])
 }

다음을 수행하십시오.

 IPFilter value = filter.get(ip[level]);
 if (value != null) {
      value.addIp(...);
 }

그러나 내가 당신에게 줄 수있는 가장 좋은 팁은 다음과 같습니다. 프로파일 러를 사용하십시오. Eclipse를 사용하는 경우 확인하십시오 TPTP.

Answer 3

아무것도 아니지만 IP 주소는 일반적으로 구현되는 4 바이트 정수입니다. 왜 그것에 인코딩하지 말고 그냥 다음과 같이하자.

int ipSrc = convertIpToInt(String ip); 
if ( ipSrc == ipDest ) { 
  /// 
} 

당신의 비교가 되십시오.

IPv6의 경우 Long을 사용할 수 있습니다.

다시 말하지만, 아마도 내가 할 일은 java.net.inet4address를 사용하여 세트에 저장하는 것입니다.

이미지도를 사용하고 있기 때문에 단순한 접근 방식을 시도해보십시오. inet4address.equals ()의 중간 스마트 구현은 문자열 비교가 아니라 정수 비교를 수행합니다.

물론이 방법은 와일드 카드를하고 싶다면 분해됩니다 ...-/