Programadores JAVA que não sabem OO vivem fazendo isso...

Veja o código que encontrei em uma aplicação open source famosa:

    static double[] getValues(double[] source, int index) {
        double[] result = new double[obj.size() - 1];
        int index = obj.getIndex();
        if (index == 0) {

           for(int i=1 ; i
               result[i-1] = values[i];
           }

        } else {

            if (index == result.length) {

               for(int i=0 ; i
                  result[i] = values[i];
               }

            } else {

               for(int i=0 ; i

                  result[i] = values[i];
               }

               for(int i=index-1 ; i
                  result[i] = values[i+1];
               }

            }

        }
    }

Esse código é chamado milhares de vezes para um conjunto de registros... sendo que a maior frequência dos casos ocorre para a segunda condição.... me pergunto, qual a dificuldade em optar por duas soluções: 1) duplicar os dados sem o elemento do vetor desejado (no problema o valor do index é constante para cada conjunto de dados), ou 2) usar um pouco dos recursos da OO:

    static interface ConvertArray {
        double[] convert(double[] source, int ignoreIndex);
    }

    static class ClassFirstPos implements ConvertArray {
        public double[] convert(double[] source, int ignoreIndex) {
            return Arrays.copyOfRange(source, 1, source.length);
        }
    }

    static class ClassLastPos implements ConvertArray {
        public double[] convert(double[] source, int ignoreIndex) {
            return Arrays.copyOfRange(source, 0, source.length-1);
        }
    }

    static class ClassOtherPos implements ConvertArray {
        public double[] convert(double[] source, int ignoreIndex) {
            double[] result = new double[source.length - 1];
            System.arraycopy(source, 0, result, 0, ignoreIndex - 1);
            System.arraycopy(source, ignoreIndex, result, ignoreIndex - 1, result.length - ignoreIndex + 1);
            return result;
        }
    }


E para quem quiser testar as pequenas diferenças....

    public static void main(String[] args) {
        double[] values = new double[5000];
        for(int i=0 ; i            values[i] = (double)i+1;
        }
        ConvertArray first = new ClassFirstPos();
        ConvertArray last = new ClassLastPos();
        ConvertArray other = new ClassOtherPos();

        System.out.println("Original");
        long t2 = System.nanoTime();
        print( getValues(values,0) );
        print( getValues(values,values.length) );
        print( getValues(values,3) );
        long t3 = System.nanoTime();
        System.out.println(t3-t2);
     
        System.out.println("Versão OO");
        long t0 = System.nanoTime();
        print( first.convert(values, 0) );
        print( last.convert(values, values.length) );
        print( other.convert(values, 3) );
        long t1 = System.nanoTime();
        System.out.println(t1-t0);


}

Na média, a versão OO que demonstrei aqui tende a consumir 30% do tempo de processamento da versão original. Em vetores muito pequenos, pode ficar mais lento que a original, em função do custo do chamado das funções internas do método. Se for esse o caso, coloque os mesmos fors da versão original na versão OO e evite o uso dos IFs...