Duda, mala práctica?

[n-utz]

Buenas,

Vengo con una duda, estoy haciendo un programa para la facultad, nada complicado. No es más que un ABM, por eso lo estoy haciendo bastante 'rapido', es decir, sin mucha dedicación solo para recordar Java.

En un método me encontré con lo siguiente, hice esto para simplificar:

Código [Seleccionar] Expandir


private Producto traerProducto(int idProducto)
{
for(Producto prod: this.lstProducto)
{
if(prod.getIdProducto() == idProducto)
return prod;
}
return null;
}


En una lista de productos, busco un producto por id. Si lo encuentra retorna el producto, si no, null.
Mi duda es si es una buena o mala práctica utilizar múltiples return's en un mismo método. Yo lo hice para ahorrarme la variable flag.

Esta duda me surgió porque recuerdo haber visto en un analizador de código que cuándo tenía múltiples return's debía simplificarlo. Pero acudo a ustedes a ver que me dicen.

PD: Capaz haga una prueba de rendimiento (solo velocidad, aunque sospecho cual ganarà).

[crack81]

Pues en lo personal no hay mucho problema, aun asi puedes usar otra alternativa al famoso foreach y  en su lugar usar streams

Código (java) [Seleccionar] Expandir

import java.util.List;
import java.util.Optional;

public class Main
{

public static void main(String args[])
{

List<Product> products = new ArrayList<>();
products.add(new Product(10));
products.add(new Product(2));
products.add(new Product(4));

long id = 3;
Optional<Product> value = products.stream().filter(p -> p.getId() == id).findFirst();

if (value.isPresent())
{
System.out.println("The number found is " + value.get().getId());
} else
{
System.out.println("The number can't find");
}
}
}

class Product
{
private long id;

public Product(long id)
{
this.id = id;
}

public long getId()
{
return id;
}
}

[rub'n]

Pues en lo personal no hay mucho problema, aun asi puedes usar otra alternativa al famoso foreach y  en su lugar usar streams

Código (java) [Seleccionar] Expandir

import java.util.List;
import java.util.Optional;

public class Main
{

public static void main(String args[])
{

List<Product> products = new ArrayList<>();
products.add(new Product(10));
products.add(new Product(2));
products.add(new Product(4));

long id = 3;
Optional<Product> value = products.stream().filter(p -> p.getId() == id).findFirst();

if (value.isPresent())
{
System.out.println("The number found is " + value.get().getId());
} else
{
System.out.println("The number can't find");
}
}
}

class Product
{
private long id;

public Product(long id)
{
this.id = id;
}

public long getId()
{
return id;
}
}

Es verdad con java8 el performance se incrementa mucho, por lo tanto es mejor...

@crack81 sabes como extraer el index con stream?

saludos



Edito:

Para Array de primitivos, retorna -1 si no esta, de lo contrario el preciado index  

Código (java) [Seleccionar] Expandir


private static final int NUM[] = {3,10,6,1,4,8,2,5,9,7};
public Stream_17_3() {
       init();

       final int n = $$_Gaag_77(NUM,10);
       if(n != -1) {
           JOptionPane.showMessageDialog(null,"Index: "+n);
       }else {
           JOptionPane.showMessageDialog(null," ;( ");
       }
}
private static int $$_Gaag_77(final int[] array, final int $_TghY) {
       return IntStream.range(0, array.length)
               .filter(index -> array[index] ==  $_TghY)
               .findFirst()
               .orElse(-1);
}


[Serapis]

La solución de un problema dado puede aparecer en cualquier punto dentro de una función.
En general si se sale de una función desde "cualquier" parte, el único problema que presenta es que para "ojos ajenos", pueda ser más difícil de leer...

Entonces si programas para tí, haz lo que te venga en gana según tu criterio, y si programas para una empresa, sométete a la regla que allí sigan.

En cualquier caso, la salida se puede diferir siempre al final de la función de modo que allí se resuma la devolución.

Código [Seleccionar] Expandir


entero = funcion X(entero p)
  Si p=5
      devolver p+2
  OSi p<0
      devolver 0
  Osi p>129
      devolver 32
  Osi p=51
      devolver Sumatorio(p/3)
  Sino
      devolver p
  Fin si
Fin funcion

La función previa de ejemplo tiene varias salidas, pero todas pueden cosiderarse finales, por cuanto tras cada devolución, no hay más código que se fuera a ejecutar. Aún así los puristas prefieren siempre 1 o a lo sumo dos devoluciones, en tal caso puede modificarse como sigue:

Código [Seleccionar] Expandir


entero = funcion X(entero p)
  entero y

  Si p=5
      y= p+2
  OSi p<0
      y= 0
  Osi p>129
      y= 32
  Osi p=51
      y = Sumatorio(p/3)
  Sino
      y= p
  Fin si

  devolver y
Fin funcion
Para mi, no gana en claridad, tampoco en velocidad, ni en ahorro de memoria, aunque si que puede ganar en mantenimiento si en un futuro hubiese de sufrir cambios (en general), al final sigue devolviendo, lo que sea que previamente se haya calculado-considerado. Cuando el código tiene a ser complejo es cuando suele resultar de más interés, peor especialmente si otros han de leer tu código (o si a tí mismo resulta complicado leerte pasado el tiempo, que les pasa a muchos).