Come sommare gli array in Java

Question

Sto scrivendo una funzione per sommare due array (di dimensioni non necessariamente uguali) in Java e restituire il risultato.

Ecco il mio tentativo:

public static <T> T[] sumArrays(T[] lhs, T[] rhs) 
    { 
     T[] out = new T[Math.max(lhs.length, rhs.length)]; 

     for (int i = 0; i < Math.max(lhs.length, rhs.length); ++i){    
      if (i < Math.min(lhs.length, rhs.length)){ 
       out[i] = lhs[i] + rhs[i];     
      } else if (i < lhs.length){ 
       out[i] = lhs[i]; 
      } else /* if (i < rhs.length)*/{ 
       out[i] = rhs[i]; 
      }    
     } 
     return out;   
    } 

Ma ho alcune osservazioni nonostante gli errori di compilazione.

1. Perché questa funzione non è presente nella libreria Java, che è estremamente gigantesca?

2. Ero motivato a usare i generici, come usereste i modelli in C++.

3. Sono preoccupato di ottenere copie profonde dei dati di input; lhs e `` rhs. Qualcuno può rassicurarmi su questo? Il C++ mi consente di passare un riferimento costante; e lo saprò per certo.

4. L'istanziazione di T[] out sembra essere illegale con un tipo generico. Cosa mi manca?

5. Il compilatore ottimizzerà il mio ripetuto Math.max(lhs.length, rhs.length)?

6. Compilatore non conforme allo lhs[i] + rhs[i]. Presumibilmente perché non conosce il tipo di T, ma il C++ ti permette di fare ciò poiché non tenterà di compilare un modello finché non conosce il tipo.

6) stanno andando a prendere una copia profonda di quando ritorno? Ancora una volta, i compilatori C++ non prenderebbero una copia extra.

Forse sono troppo vecchio per abituarsi a Java ;-)

Answer 1

0) Perché non è questa funzione nella libreria estremamente gigantesca Java?

Chiedere parere, fuori tema qui.

2) Sono preoccupato di ottenere copie profonde dei dati di input; lhs e rhs. Qualcuno può rassicurarmi su questo? Il C++ mi consente di passare un riferimento costante; e lo saprò per certo.

6) Sta per effettuare una copia approfondita di quando si torna? Ancora una volta, i compilatori C++ non prenderebbero una copia extra.

Nessuna copia profonda viene eseguita automaticamente in Java. Inoltre, la copia profonda è un problema mal definito in generale.

3) L'istanziazione di T[] out sembra essere illegale con un tipo generico. Cosa mi manca?

A parte l'impossibilità di creare un'istanza di un array di tipo generico, i tipi generici coprono solo i tipi di riferimento. Probabilmente sei interessato solo ai tipi primitivi qui, quindi non servono a niente.

4) Il compilatore ottimizzerà il mio ripetuto Math.max(lhs.length, rhs.length)?

Alcune JIT potrebbero, ma non si può avere alcun tipo di garanzia. Estrai su una variabile locale.

5) Compilatore non conforme allo lhs[i] + rhs[i]. Presumibilmente perché non conosce il tipo di T, ma il C++ consente di fare ciò poiché non tenterà di compilare un modello finché non ne conoscerà il tipo.

Sfortunatamente, ci sono molti problemi qui. Non c'è modo di generare algoritmi per tutti i tipi di Java primitivi.

Answer 2

5) compilatore non piacciono ss [i] + sd [i]. Presumibilmente perché lo non conosce il tipo di T, ma il C++ consente di fare ciò poiché non tenterà di compilare un modello fino a quando non conoscerà il tipo.

Si può sempre scrivere un'interfaccia con una funzione .add (...) e lasciare che T estenda questa interfaccia. Quindi potresti scrivere lhs [i] .add (rhs [i])