Optimiser le code Java

Question

Comment puis-je optimiser ce code? J'ai créé IPFilter et j'ai besoin de l'optimiser.

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

Présentez-le à travers certains cas d'utilisation typiques et utilisez ces données pour déterminer les goulots d'étranglement des performances. THEN , optimisez ce code.

Sans savoir réellement où est le problème de performances, vous pourriez consacrer beaucoup de temps et d'effort à économiser des microsecondes.

Answer 2

Je ne sais pas exactement ce que vous essayez d'optimiser. Cependant, vous avez deux includesKey suivis par get . Une optimisation possible consiste à utiliser get et à comparer à null . Par exemple, au lieu de:

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

Procédez comme suit:

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

Mais je pense que le meilleur conseil que je puisse vous donner est: utilisez un profileur. Si vous utilisez Eclipse, consultez TPTP .

Answer 3

Pas pour rien, mais une adresse IP est un entier de 4 octets comme elle est habituellement implémentée. Pourquoi ne pas encoder à cela, et laisser:

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

soyez votre comparaison.

Et pour IPv6, vous pouvez utiliser un long.

Encore une fois, ce que je ferais probablement, c’est d’utiliser java.net.Inet4Address et de les stocker dans un ensemble.

Puisque vous utilisez déjà une carte, pourquoi ne pas essayer une approche simpliste? Une implémentation intelligente à mi-parcours de Inet4Address.equals () ferait une comparaison d'entier, et non une comparaison de chaîne.

Bien sûr, cette méthode échoue si vous souhaitez utiliser des caractères génériques ...: - /