【Java】配列

#配列
:sunny:  複数のデータをひとまとめにする。変数のセットのようなもの。

```例.java
public class Main {
	public static void main(String[] args) {
	    String fruit1 = "りんご";
	    String fruit2 = "みかん";
	    String fruit3 = "いちご";
	    String fruit4 = "メロン";
	    String fruit5 = "バナナ";
	    
		System.out.println(fruit1);
		System.out.println(fruit2);
		System.out.println(fruit3);
		System.out.println(fruit4);
		System.out.println(fruit5);
	}
}
```

上記は果物の種類を表示していくプログラミングです。
これも間違いではないのですが、フルーツの種類を追加していくたびに
変数 fruit の数字が増えていき、 System.out.println〜 をいったい何個作成していくんだ？:disappointed_relieved: となります。
変数 fruit についている数字も多くなれば多くなるほど間違えてしまいそうです。
なによりも面倒です:sweat_smile: 

このようなときに活躍してくれるのが **配列** です:smile:

書き方とかを説明するまえに配列とはどういったものか？というのを説明しますね:smile:

私の配列のイメージは

![倉庫.jpg](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/532773/e5e19114-7ac9-7d9c-00de-5c54a792d9eb.jpeg)

倉庫です。

画像をみてもらうとわかるように倉庫には棚があり、棚にはダンボールが並んでいます。

このダンボールの１つには、りんごが入っています。
べつのダンボールにはみかんが入っています。
そしてまたべつのダンボールには・・・というふうに種類ごとにダンボールにはフルーツが入っています。

このダンボールを **要素** といいます。
りんごとかみかんなどのフルーツは **値** といいます。

![ダンボール.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/532773/2d0a9e1c-ab8f-b9ca-b0a0-0f395753fe79.png)


そしてこのダンボール（要素）はフルーツという棚にきれいに並べられています。
この棚にダンボール（要素）がきれいに整頓されて並んでいる状態が **配列** です。

![棚.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/532773/99791363-d7c7-439c-7286-fb9f1c1fa704.png)

きれいに整頓されて並んでいるダンボール（要素）ですが、なにも書いていないので、開けてみないかぎり中に何が入っているのかさっぱりわかりません:worried:

そこでダンボール（要素）ひとつひとつに番号をつけて管理することにしました。
この番号を **添え字（またはインデックス）** といいます。
この添え字ですが少し注意があります。
**必ず 0 から始まる決まり** となっています。

[0] りんご
[1] みかん
[2] いちご
・
・
・
となります。
なので、[0] から始まるのを忘れて

りんごのダンボール（要素）がほしいから [1] のダンボール取ってきて！

というと、みかんがやってきます:sweat_smile: 


:sunny: かんたんにまとめ:sunny: 
配列（棚）・・・0 から始まる添え字という番号で管理された要素が格納されている。
要素（ダンボール）・・・値が格納されている。
値・・・要素の中身（ここではりんごやみかんなどのフルーツ）

## 配列の書き方
配列のイメージを説明したので、ここからは実際に配列の書き方を説明していきますね:smile:

```
１．配列変数の宣言
２．要素の作成と代入
```

配列には 2 つの工程が必要です。
まずは １．配列変数の宣言 から:smile:

### １．配列変数の宣言
いままで変数を作成するときに

int number;
String name;

など、

型 変数名

と作成し、これから変数を入れるための新しい箱を用意するための宣言をしていました。
今回はこれの配列バージョンです:smile:
さっきの説明でいうと

( ｣｀Д´)」＜ 新しい棚、用意してーーー！

が配列変数の宣言です。

```講式.
要素の型[] 配列変数名
```

この講式をフルーツのプログラムにあてはめると

```例.java
String[] fruits
```

となり、新しい棚が用意されます:smile:
注意点としては・・・
:sunny: 型名と [ ] のあいだにスペースはいらない。
:sunny: 配列変数名は好きな名前でいいが複数形にする。

### ２．要素の作成と代入
さきほど配列変数の宣言によりフルーツを置くための新しい棚が用意されました。
ここにはまだ何も置かれていません。
棚があるだけです。
そこで新たに命令します。

( ｣｀Д´)」＜ 新しいダンボール 5 個持ってきて棚に並べてー！

その講式が

```講式.
配列変数名 = new 型[要素数]
```

となり、あてはめると

```例.java
fruits = new String[5]
```

となります:smile:
ここで注意すべき点は要素数です。

添え字が 0 〜 4 までなんだから 4 なんじゃないの？:thinking: と思ってしまいます。
違うんです。
要素数なのでダンボールの数なんです。
０から始まる番号をダンボールひとつひとつにつけていくわけだから

０　１　２　３　４

の合計 5 個になるので [ ] に入る数字は 5 というわけです:smile:

```例.java
public class Main {
	public static void main(String[] args) {
	    String[] fruits;
	    fruits = new String[5];
	}
}
```

ここまでをまとめるとこうなりますが、さらにコードを短くできます。

１．配列変数の宣言
２．要素の作成と代入

これを 1 行で記入してしまう方法です。

```講式.
型[] 配列変数名 = new 型[要素数]
```

```例.java
public class Main {
	public static void main(String[] args) {
	    String[] fruits = new String[5];
	}
}
```

さらに見やすくなりました:laughing: 

## 配列の要素に値を代入と値の呼び出し
新しい棚も用意できました。
新しいダンボールも用意できました。
さて次はいよいよダンボールにフルーツを入れていきましょう:smile:

フルーツの入れ方ですが、ダンボールに添え字（インデックス）がつけられているとお話したかと思います。
この添え字を利用してダンボールにフルーツを入れていきます:smile:

```例.java
public class Main {
	public static void main(String[] args) {
	    String[] fruits = new String[5];
	    fruits[0] = "りんご";
	    System.out.println(fruits[0]);
	}
}
```

4 行目の fruits[0] = "りんご"; で
( ｣｀Д´)」＜ フルーツの棚のダンボール [0] 番にりんご入れといてー！
って命令して（配列の要素に値を代入）

5 行目の System.out.println(fruits[0]); で
( ｣｀Д´)」＜ フルーツの棚のダンボール [0] 番の中身確認してー！
って確認したら（値の呼び出し）

```コンソール.
りんご
```

と表示されるわけです:smile:

では要素の入れ方や呼び出しもわかったので改めてコードを書いてみます:smile:

```例.java
public class Main {
	public static void main(String[] args) {
	    String[] fruits = new String[5];
	    fruits[0] = "りんご";
	    fruits[1] = "みかん";
	    fruits[2] = "いちご";
	    fruits[3] = "メロン";
	    fruits[4] = "バナナ";
	    
	    System.out.println(fruits[0]);
	    System.out.println(fruits[1]);
	    System.out.println(fruits[2]);
	    System.out.println(fruits[3]);
	    System.out.println(fruits[4]);
	}
}
```

けっきょくコード長いやん！:scream:
配列の意味ないじゃん！:scream:

書き方が変わっただけで、たいして意味がない状況となってしまいました。
なにか方法は・・・？:thinking: 

```講式.
1. 要素の型[] 配列変数名 = new 要素の型[] {値1,値2,値3,・・・}
2. 要素の型[] 配列変数名 = {値1,値2,値3,・・・}
```

2通りあります！:smile:
この講式だけで、配列変数の宣言と要素の作成と代入と値の代入をいっぺんにできます。
・・・じゃあいままでの説明はなんだったんだ・・・という話になってしまいますが、要素に入れる値が決まっているのであれば、この講式を使ったほうがいいよということです:smile:

例えば・・・
 
int[5] number = new java.util.Random().nextInt(10);

このような場合。
5 つある要素のなかに 0 〜 9 のランダムの数字を入れてください。
というときに上記の講式のような

1. 要素の型[] 配列変数名 = new 要素の型[] {値1,値2,値3,・・・}
2. 要素の型[] 配列変数名 = {値1,値2,値3,・・・}

だと、まだ何の数字が入れたらいいのかわかりません。
その場合は上記のような講式が使えないので

int[] numbers = new int[5]

と今までどおり作成するしかないのです。

話を戻して・・・今回は 2 を使いますね:smile:

```例.java
public class Main {
	public static void main(String[] args) {
	    String[] fruits = {"りんご","みかん","いちご","メロン","バナナ"};
	    
	    System.out.println(fruits[0]);
	    System.out.println(fruits[1]);
	    System.out.println(fruits[2]);
	    System.out.println(fruits[3]);
	    System.out.println(fruits[4]);
	}
}
```

ずいぶんコードが短くなりました:raised_hands:

あとは System.out.println の部分だけです:laughing: 
結果から言うと for 文を使います。
しかし for 文を使うまえに length の説明がいるため、さきに length の説明をしてから for 文の説明をしますね:smile:


## 配列の要素数の確認
えーっと・・・フルーツの棚にダンボール何個あったっけ？？:thinking: 
とダンボールの数を知りたいということがあるかもしれません。

そんなとき実際の倉庫だと管理している人に聞くと思いますが
それと同じく要素数をパソコンさんに聞くことができます。

```講式.
配列変数名.length
```

```例.java
public class Main {
	public static void main(String[] args) {
	    String[] fruits = {"りんご","みかん","いちご","メロン","バナナ"};
	    int number = fruits.length;
	    System.out.println("フルーツの棚にはダンボール" + number + "個あるよ！");
	}
}
```

4 行目の int number = fruits.length; の fruits.length; は要素の数（ダンボールの数）を聞いているので、型は int になります。
要素数を変数 number に代入します。

5 行目で要素数を表示します。

```コンソール.
フルーツの棚にはダンボール5個あるよ！
```

## 配列と for 文
### 繰り返し（ループ）による全要素の利用
length の説明もしたので、 for 文 を使って
System.out.println のコードを短くしましょう:laughing: 
答えは下記となります:laughing: 

```例.java
public class Main {
	public static void main(String[] args) {
	    String[] fruits = {"りんご","みかん","いちご","メロン","バナナ"};
	    for (int count = 0; count < fruits.length; count++) {
	        System.out.println(fruits[count]);
	    }
	}
}
```

4行目の for 文の count < fruits.length; の部分ですが
fruits.length; は要素数をあらわすので、今回でいえば 5 になります。
変数 count には初期値として 0 が代入されているので
0 < 5 となり、その条件が満たされるまで繰り返します。

5行目の fruits[count] の部分は
変数 count には初期値として 0 が代入されているので
fruits[0] が呼び出され、 りんご が出力されます。
0 < 5 まで繰り返し処理が設定されているため
添え字 [0] 〜 [4] が呼び出され、その値が出力されます。

```コンソール.
りんご
みかん
いちご
メロン
バナナ
```

ちなみに 4 行目の int count = 0 の部分を int count = 3 に変更してみると
fruits[count] が fruits[3] となり、添え字の [3] 〜 [4] が呼び出され出力されるので下記のような表示となります:smile:

```コンソール.
メロン
バナナ
```

このようなコードにしておくと、 追加項目があっても 3 行目に追加するだけになるので、とっても楽ちん仕様になります:smile:

```例.java
public class Main {
	public static void main(String[] args) {
	    String[] fruits = {"りんご","みかん","いちご","メロン","バナナ","キウイ"};
	    for (int count = 0; count < fruits.length; count++) {
	        System.out.println(fruits[count]);
	    }
	}
}
```

３行目に キウイ を追加

```コンソール.
りんご
みかん
いちご
メロン
バナナ
キウイ
```

ちゃんの表示されました:laughing: 

このように繰り返し処理（ループ）で要素を順に使っていくことを **配列を回す** といいます:smile:
講式は下記です:smile:

```講式.
for (int 変数名 = 0; 変数名 < 配列変数名.length; 変数名++)
```

配列の中身すべてを出力したいだけなら、**拡張 for 文**を使う方法もあります:smile:

```講式.
for (要素の型 変数 : 配列変数名)
```

```例.java
public class Main {
	public static void main(String[] args) {
	    String[] fruits = {"りんご","みかん","いちご","メロン","バナナ","キウイ"};
	    for (String count : fruits) {
	        System.out.println(count);
	    }
	}
}
```

### 繰り返し（ループ）による集計
この繰り返し処理を利用して要素を合計するということもできます:smile:

```例.java
public class Main {
	public static void main(String[] args) {
	    int[] numbers = {10,20,30,40,50};
	    int sum = 0;
	    for (int count = 0; count < numbers.length; count++) {
	        sum += numbers[count];
	    }
	    System.out.println(sum);
	}
}
```

4 行目の int sum = 0; ですが、変数の値を取り出すまえに必ず値を代入して初期化しなければいけないので int sum = 0; として、変数 sum に 0 を代入しています。

6 行目の sum += numbers[count]; を数値化すると
0 += 10
つまり 0 + 10 の計算をして、その答えが変数 sum に代入される。
それが繰り返され、10 + 20・・・20 + 30・・・と繰り返され、全ての要素を合計した結果が

```コンソール.
150
```

となります:smile:

ちなみに if 文を使って 30 以上の数は何個か？ ということもできます:smile:

```例.java
public class Main {
	public static void main(String[] args) {
	    int[] numbers = {10,20,30,40,50};
	    int conditions = 0;
	    for (int count = 0; count < numbers.length; count++) {
	        if (numbers[count] >= 30) {
	            conditions++;
	        }
	    }
	    System.out.println(conditions);
	}
}
```

```コンソール.
3
```

### 添字に対応した情報の利用
int 変数 = new java.util.Random().nextInt(3);
上記は 0 〜 2 のランダムな数を変数に代入するという式です。
整数はランダムに表示できますが、文字をランダム表示させたいときはどうするのでしょうか？:thinking: 

```例.java
public class Main {
	public static void main(String[] args) {
	    
	    int[] word = new int[5];
	    
	    for (int number = 0; number < word.length; number++) {
	        word[number] = new java.util.Random().nextInt(3);
	    }
	    
	    for (int number = 0; number < word.length; number++) {
	        switch (word[number]) {
	            case 0:
	                System.out.println("あひる");
	                break;
	            case 1:
	                System.out.println("さくら");
	                break;
                case 2:
                    System.out.println("どんぐり");
	                break;
	        }
	    }
	}
}
```

このように switch 文を使うという方法があります:smile:

3 行目の int[] word = new int[5]; で 新しい棚と新しいダンボールを 5 個用意。

4 〜 6 行目の for 文の意味は 0 〜 2 のランダムに取り出された数字を word[number] にそれぞれ代入していきます。

7 〜 18 行目の for 文の意味は word[number] に格納された数字を switch 文から探し出し、同じ数字のものと一致したら、そこに記入されている文字を出力する。（word[0]なら case 0 の あひる が出力される）

```コンソール.
どんぐり
あひる
さくら
さくら
どんぐり
```

＊コンソールに表示される文字は毎回変わります。