Die Optimierung von Java-Code

Question

Wie kann ich diesen Code zu optimieren? Ich habe IPFilter und ich brauche es zu optimieren.

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

Profil es durch einige typische Anwendungsfälle und diese Daten verwenden, um herauszufinden, wo die Performance-Engpässe sind. DANN , optimieren, dass Code.

Ohne wirklich zu wissen, wo die Performance-Problem ist, Sie viel Zeit und Mühe sparende Mikrosekunden verbringen können.

Answer 2

Ich bin mir nicht sicher, was genau wollen Sie zu optimieren. Sie haben jedoch ein paar containsKey von get gefolgt. Eine mögliche Optimierung ist get zu bedienen und zu vergleichen, um null. Zum Beispiel statt:

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

Gehen Sie wie folgt:

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

Aber ich denke, der beste Tipp, den ich Ihnen geben kann ist: einen Profiler verwenden. Wenn Sie Eclipse verwenden, überprüfen Sie TPTP .

Answer 3

Nicht umsonst, aber eine IP-Adresse ist ein 4-Byte-Ganzzahl, wie es in der Regel implementiert wird. Warum kodieren nicht das, und lassen Sie:

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

Ihr Vergleich.

Und für IPv6, könnte man eine lange verwenden verwenden.

Dann wieder, was ich würde wahrscheinlich verwenden java.net.Inet4Address tun ist und speichern sie in einem Set.

Da Sie bereits eine Karte verwenden, warum nicht versuchen, einen vereinfachenden Ansatz aus? Eine halbwegs intelligente Umsetzung von Inet4Address.equals () würde eine ganze Zahl Vergleich zu tun, und nicht einen String-Vergleich.

Natürlich ist diese Methode bricht, wenn Sie die Stellvertreterzeichen tun wollen ...: - /