Cuando estoy iterando sobre dos matrices a la vez, ¿cuál uso como límite?

Question

Siempre estoy luchando con algo como el siguiente ejemplo de Java:

String breads[] = {"Brown", "White", "Sandwich"}; 
int count[] = new int[breads.length]; 
for (int i = 0; i < ****; i++) 
{ 
    // Prompt the number of breads 
} 

****: Array.length la que debe elegir?
Puedo elegir entre breads.length y count.length
Sé que sería el mismo resultado, pero no sé cuál elegir.

Hay muchos otros ejemplos en los que me sale el mismo problema.
Estoy seguro de que ha encontrado este problema también en el pasado.

¿Qué elegir? ¿Hay acuerdos generales?

Gracias

Answer 1

Creo que entiendo su pregunta.

La respuesta es que no use matrices.

En este caso, utilice un mapa de:

Map<String, Integer> breadCount = new TreeMap<String, Integer>(); 

breadCount.put("Brown", 0); 
breadCount.put("White", 0); 
breadCount.put("Sandwich", 0); 

Entonces sólo hay una "longitud", que es breadCount.size()

Ejemplo es en Java

Answer 2

utilizar listas, conjuntos y mapas y foreach.

Si realmente tiene que usar matrices y no puede usar bucles foreach, no importa.

Answer 3

Usando breads.length es más precisa desde count tamaño depende de la longitud breads, pero aparte de que los diferentes resultados será el mismo .. y esto debe ser cierto siempre que se opere de una manera similar a la que usted escribió.

Si realmente no quiere ser annoyied por estas preguntas metafísicas puede utilizar una clase simple:

class Bread 
{ 
    String name; 
    int count 
} 

o puede utilizar una matriz multidimensional, o también un HashMap:

HashMap<String, Integer> counts 

por lo que puede iterar sobre la colección real, mientras que la recolección de los valores del mapa:

for (String b : breads) 
    System.out.println(b + " count: "+counts.get(b)); 

Answer 4

depende lo que está haciendo, pero en última instancia esto rara vez va a ser una decisión importante (ya que el valor es el mismo). Quizás te preocupes por problemas "más grandes". Para los intereses, en el JIT de .NET (no el compilador) puede detectar este patrón y eliminar el fuera de límites cheques, pero sólo si es algo obvio, como:

for(int i = 0 ; i < arr.Length ; i++) { 
    Console.WriteLine(arr[i]); // no bounds check if the JIT can prove it will 
           // never fail 
} 

Answer 5

En este escenario, yo iría con breads porque así es como se explicaría el código.

Lógicamente, está iterando sobre cada tipo de pan, no sobre el número de panes (aunque es el mismo).

Imagine que está explicando su código a otra persona, y use lo que sea lógico desde esa perspectiva. A veces ambos tienen sentido, en cuyo caso solo tienes que elegir arbitrariamente.

Answer 6

diría que elegir el "principal "array y usa su longitud en todos lados. De esta forma, su código es más claro y fácil de leer. Aparte de eso, creo que realmente no importa, porque count.length será el mismo y podrías mezclar estos dos a tu gusto.

Answer 7

Este problema parece bastante académico, pero en su caso, preferiría la matriz que intenta cambiar (contar), ya que cuando en algún caso (más bien académico), la duración del pan y el recuento deberían diferir , siempre es mejor no incurrir en problemas de límites de matriz ...

Aún podría haber una solución diferente: Tener solo una matriz que contenga estructuras con nombre ("panes" también podría denominarse "nombres de panes") y cuenta ...

Answer 8

En tal situación, declaro una variable local. De esta manera:

int n = breads.length; 
int[] count = new int[n]; 
for (int i = 0; i < n; i ++) { 
    // ... 
} 

Conceptualmente, esto significa que hago del "conteo de bucles" un valor en sí mismo. Un efecto secundario es que su problema está resuelto.

Answer 9

Intentaré evitar tener las diferentes matrices por completo. La mayoría de las veces, si tiene dos arrays que tienen el mismo tamaño en todo momento, en realidad está fingiendo un tipo compuesto o una relación.

// C++: inventory map: 
std::map< std::string, int > bread_inventory; 
bread_inventory["White"] = 0; 
bread_inventory["Brown"] = 0; 
bread_inventory["Sandwich"] = 0; 

// C++: complex type: 
struct bread_type 
{ 
    bread_type(std::string const & name, int calories) 
     : name(name), calories(calories) {} 
    std::string name; 
    int calories; 
}; 
std::vector<bread_type> v; 
v.push_back(bread_type("White", 100)); 
v.push_back(bread_type("Brown", 90)); 

Mediante el uso de tipos o contenedores de hormigón (en comparación con los elementos no relacionados en diferentes contenedores) se obtiene la coherencia de forma gratuita (menos se debe tener cuidado para verificar que ambos recipientes se actualizan de la misma manera) y algunas operaciones se vuelven mucho más simple (ordenar el vector por calorías puede implementarse trivialmente con una función de ordenamiento, mientras que si mantiene dos vectores separados para los nombres y los valores asociados, tendría que luchar para garantizar que las mismas operaciones se realicen en ambos contenedores).

El código también es más fácil de seguir y mantener ya que los tipos le dicen al programador lo que el escritor quería. Parte del conocimiento de la domai n que tiene al escribir la clase se pierde en su implementación. Su implementación se ocupa de una variedad de tipos de pan y una matriz de conteos, pero el código no le dice que, de hecho, son una sola entidad.

Answer 10

Está utilizando for(int i=0; i<array.length; i++) para repetir los valores de la matriz. Entonces realmente quiere usar array[i] y no otra cosa. En su caso, quiere iterar sobre los nombres que ha definido. Sin embargo, la matriz de conteos está llena de ceros y la pregunta es por qué desea iterar sobre ellos. Por lo tanto, si escribe

String breads[] = {"Brown", "White", "Sandwich"}; 
int count[] = new int[breads.length]; 
for (int i = 0; i < breads.length; i++) { 
} 

, verá claramente que el ciclo es para repetir los nombres. Y lidias con estos nombres (como mostrarlos). Pero si se escribe

String breads[] = {"Brown", "White", "Sandwich"}; 
int count[] = new int[breads.length]; 
for (int i = 0; i < count.length; i++) { 
} 

La pregunta se elevan ¿Por qué quiere iterar sobre los valores de cuenta? todos son 0. El flujo de datos en realidad es algo así como count_value = f(bread_value), los nombres de los pan son independent variable. Se puede escribir (en Java)

String breads[] = {"Brown", "White", "Sandwich"}; 
int count[] = new int[breads.length]; 
for (String bread: breads) { 
} 

y ve claramente que se preocupa por los nombres de pan y quiere hacer algo con ellos. Que desee establecer los recuentos son solo un efecto secundario del ciclo, pero no controla los tiempos de las iteraciones.