Arrays / MultiDimensional Arrays - example.length

[Mike Philips]

OK I'm a bit confused with arrays at the moment, so say I have a for loop that's along the lines of :

for (int i = 0; i < example.length; i++) 

and the "example" part is referring to an array

String[][] synthName = new String[2][3];

Does the .length return the value of Row's by default? And how does one get the amount of columns instead?

I was trying to work out how a for loop was working in some code that I'd pinched and got confused.

Here's the full code if any context is wanted :

import java.util.Scanner;

public class testets {

	public static void main(String[] args) {

		Scanner input = new Scanner(System.in);

		// create arrays for the sythPrice and the synthName. set them both to 2
		// rows and 3 columns

		String[][] synthName = new String[2][3];
		int[][] synthPrice = new int[2][3];

		// create a for loop that will add "Row 1" and "Row 2" to the system output. 
		for (int i = 0; i < synthName.length; i++) {
			System.out.println("Row " + (i + 1));

			for (int k = 0; k < 3; k++) {
				System.out.println("Enter a synth name : ");
				String name = input.next();
				synthName[i][k] = name;

				System.out.println("Price : ");
				int price = input.nextInt();
				synthPrice[i][k] = price;

			}
		}
		System.out.println("\n\nDone\n");

		for (int i = 0; i < synthName.length; i++) {

			for (int k = 0; k < 3; k++) {

				String name = synthName[i][k];
				int price = synthPrice[i][k];
				System.out.println(name + " Cost £" + price);

			}
		}

		input.close();
	}
}

the section I was looking at specifically was :

		for (int i = 0; i < synthName.length; i++) {
			System.out.println("Row " + (i + 1));

			for (int k = 0; k < 3; k++) {
				System.out.println("Enter a synth name : ");
				String name = input.next();
				synthName[i][k] = name;

				System.out.println("Price : ");
				int price = input.nextInt();
				synthPrice[i][k] = price;

			}
		}

I didn't (don't) really understand how the outer for loop runs twice, where as the inner for loop runs six times (3 times on each of the outer for)

cheers

[Campbell Ritchie]

Which is Row?
Let's have a look at an array of arrays. There ain't no such thing as a multidimensional array in Java, but arrays of arrays are better.

int[][] numbers = {{1, 2, 3}, {}, {4}, {5, 6}};
System.out.println(Arrays.deepToString(numbers));
/* [[1, 2, 3], [], [4], [5, 6]] or similar */
System.out.println(numbers.length) //4
for (int[] arr : numbers)
{
   System.out.printf("%d ", arr.length}; // 3 0 1 2
}
System.out.println();

Since the 5 arrays in question have different lengths, it should be obvious to you which is being printed. Note one of the arrays is empty with length 0.
For the Arrays class, import java.util.Arrays

[Jeanne Boyarsky]

Yes example.length returns the size of the first array. example[0].length returns the size of the inner array. (Make sure your array isn't empty before calling this.)

As for the nested loop, the outer loop runs twice. The inner loop runs three times for each run of the outer loop. 2x3 = 6 so the inner loop runs 6 times.

[Campbell Ritchie]

You should not use parallel arrays. It is very easy to get the elements of the two out of step. You should have a Synth object with name and price fields, and create a Synth[] array.

[Mike Philips]

Jeanne Boyarsky wrote:Yes example.length returns the size of the first array. example[0].length returns the size of the inner array. (Make sure your array isn't empty before calling this.)

I'm trying to picture this in my head...

String[][] testArray = new String[2][3];

so in this example there are two arrays - which I have been referring to as Row's (because I've been visualising a table)

each of these arrays / rows is three sections / elements / columns in length? (I'm not sure what the nomenclature is for this...)

I'm not really following you what you mean by the inner array, as far as I can picture they are parallel - what would an inner array be?

As for the nested loop, the outer loop runs twice. The inner loop runs three times for each run of the outer loop. 2x3 = 6 so the inner loop runs 6 times.

How does that happen? Does the outer loop run, then the nested for loop - and outer loop doesn't re trigger until the nested loop has reached the specified value of < 3 ?


Thank you, just trying to bend my head round these thing's a bit...

[Mike Philips]

Campbell Ritchie wrote:You should not use parallel arrays. It is very easy to get the elements of the two out of step. You should have a Synth object with name and price fields, and create a Synth[] array.

I just got to getters and setters last night ;)

So In this case it would be better to create a SynthProperties class at the top of the page - and then include some data for it :

class SynthProperties {
	
	String synthName;
	int synthPrice;
}

like this?

[Campbell Ritchie]

Mike Philips wrote: . . . so in this example there are two arrays - . . .
each of these arrays / rows is three sections / elements / columns in length? (I'm not sure what the nomenclature is for this...)

Yes. Two arrays with three elements each.

I'm not really following you what you mean by the inner array, as far as I can picture they are parallel - what would an inner array be?

That would mean one of the two arrays inside the larger array.

As for the nested loop, the outer loop runs twice. The inner loop runs three times for each run of the outer loop. 2x3 = 6 so the inner loop runs 6 times.

How does that happen? Does the outer loop run, then the nested for loop - and outer loop doesn't re trigger until the nested loop has reached the specified value of < 3 ? . . . Yes, but don't write 3. Always use length. That allows for arrays any length.

for (int i = 0; i < numbers.length; i++)
{
   for (int j = 0; j < numbers[i].length; j++)
   {
      something(numbers[i][j]);
   }
}

You can use nested for‑each loops if you want the arrays to be “read only”.

[Campbell Ritchie]

Mike Philips wrote:. . . it would be better to create a SynthProperties class . . . include some data for it :

class SynthProperties {
	String synthName;
	int synthPrice;
}

like this?

It is just about always better to create a class. Yes, but the fields should be private, initialised via a constructor, and access can be made via getters and maybe also setters. Also a toString method.

[Mike Philips]

Campbell Ritchie wrote:

Mike Philips wrote:. . . it would be better to create a SynthProperties class . . . include some data for it :

class SynthProperties {
	String synthName;
	int synthPrice;
}

like this?

It is just about always better to create a class. Yes, but the fields should be private, initialised via a constructor, and access can be made via getters and maybe also setters. Also a toString method.

OK I've had a little go at this and here's what I've made :

class SynthProps {
	
	String synthName;
	int synthPrice;
	
	String getsynthName() {
		return synthName;
	}
	
	int getsynthPrice() {
		return synthPrice;
	}
	
	String getSynthInfo() {
		String information = "Synth name : " + synthName + " Synth Cost : " + synthPrice;
		return information;
	}	
}

public class gjfyjky7 {

	public static void main(String[] args) {
		
		SynthProps mySynth1 = new SynthProps();
		
		mySynth1.synthName = "Roland.";
		mySynth1.synthPrice = 400;
		
		System.out.println(mySynth1.getSynthInfo());
	}  
		
	}

So it returns the name / price of the synth, but it doesn't allow the user to enter in that information... I have to enter it all in the console.

I'm not familiar with (anything...) the constructor or the tostring method.


Cheers though.

[Campbell Ritchie]

Not come across constructors? Good grief!
Give all your fileds private access.
A constructor has exactly the same name as the class and you must miss out the return type. You set up all the fields into a consistent state in the constructor, or you establish the class' invariants in the constructor. In your case that the synth has a name and a price.

public class Synth
{
   private int price;
   private String name;

   public Synth(int price, String name)
   {
      this.price = price;
      this.name = name;
   }
   . . . 
}

If the parameters have the same names as the fields, that is called shadowing, and it must be resolved by using this‑dot
In some cases it is necessary to take “defensive copies” of constructor parameters (also for other methods). It is never necessary for immutable reference types, e.g. String, nor for primitives, e.g. int.
You can perform validation. For example you can throw an Exception if offered a negative price.

You need a toString() method. It can do exactly the same as the get synth info method. Then you can write

Synth s = new Synth("cytosyl pentosidase", 1000);
 . . .
System.out.println(s);

[Mike Philips]

Ace cheers Campbell - I get to them soon apparently!

[Campbell Ritchie]

You're welcome