Metodo efficiente che passa in modalità in java

Question

Ho una firma del metodo come questa.

public void calculateFinalInvoice(int a, int b, int c, int d, int e, int f, int g, int h, int i, InvoiceDO invoiceDO) { 
    // TO DO 

} 

Sto passando alcuni parametri. Quindi è meglio passare tutti questi parametri in termini di prestazioni. oppure 1) mantenere una classe per tutti questi parametri 2) mantenere HashMap per tutti questi parametri 3) mantenere un ArrayList per questo.

Potete suggerire per favore qual è il migliore per ottenere prestazioni.

Answer 1

Quale versione di Java stai usando? Che cosa stai facendo con quei parametri. Si potrebbe essere meglio spostare il DAO per la parte anteriore della lista degli argomenti e quindi utilizzando varargs passare tuttavia molte int s che si desidera:

calculateFinalInvoice(InvoiceDO invoiceDO, int args...) { 
} 

Answer 2

si può semplicemente passare array di int

calculateFinalInvoice(int[] values, InvoiceDO invoiceDO) { } 

Answer 3

Do non preoccuparti di gestire l'efficienza della micro su cose come questa. Codice per chiarezza e dopo aver fatto la codifica, preoccupati dell'efficienza se necessario. In questo caso, potresti voler ripensare il tuo design e creare più struttura per il tuo codice. Ad esempio, potresti voler utilizzare gli array:

public void calcualteFinalInvoices(int [] invoices, InvoiceDO action){ 
    //... 
} 

Answer 4

Dimenticatevi delle prestazioni. Questo non è un problema. Il problema è che esattamente come la formula per l'ingegnere non deve superare 1 pollice il metodo non dovrebbe ottenere più di 3 argomenti. Se hai bisogno di più, cambia il tuo design.

Probabilmente dovresti creare una classe parametro speciale e passare la sua istanza al metodo. Oppure metti il ​​metodo in una classe diversa che memorizza alcuni dati come campi di istanza ...

Se vuoi consigliare di fissare il tuo disegno, fai altre domande dove spiegare cosa stai cercando di fare. Credo che la community possa aiutarti a migliorare il tuo design.

Answer 5

Oserei dare un approccio più OOP, più leggibile.

Il codice di esempio è simile a chiamare trim("my string") anziché "my string".trim(). Questa è la programmazione procedurale, in cui il codice funziona su dati passivi (trim che funziona su "my string"). In OOP, invece, inviamo messaggi agli oggetti per soddisfare le richieste, come in "my string".trim()".

Quindi l'alternativa identifica Invoice come un concetto che può essere richiesto per il suo valore o contenuto. Quindi utilizziamo method chaining e encapsulation per ottenere il programma più leggibile e più gestibile. Se le diverse variabili hanno significati speciali, è possibile decorare la classe Invoice con versioni specifiche di add, ad esempio addBalance e così via.

class Invoice { 
    private final List<Integer> values = new ArrayList<Integer>(); 

    public Invoice add(int value) { 
     values.add(value); 
     return this; 
    } 

    public double value() { 
     // Use the values to compute the final invoice. 
     return computedFinalInvoice; 
    } 
} 

Usa come questo:

double finalInvoiceValue = new Invoice() 
    .add(1) 
    .add(2) 
    .add(100) 
    .value();