コレクションフレームワークについてまとめた。

#はじめに
こんにちは。某学校でプログラミング等の勉強中のサーバーサイドのプログラマーのワタタクです。:relaxed:

今回はJavaの中でもコレクションフレームワークについてまとめてみました。
個人的にややこしい分野だったので勉強も兼ねてまとめていますので、間違っている等のご指摘があればコメントお願いします。

では、いってみます。
#コレクションとは？
そもそもコレクションとは、大きさが決まっていないが配列のように多数の値をまとめて操作できるものと考えるとよいでしょう。

大きさが決まっていませんので、必要な分の数だけデータを格納することができます。
#コレクションフレームワークとは？
コレクションには下記のように用途に応じて主に3種類が用意されています。

- **リスト(List)**　順序通りに並べて格納
- **セット(Set)**　順序があるとは限らず格納
- **マップ(Map)**　ペアで対応づけて格納

このように種類が用意され柔軟に扱うことを考えられているのが**コレクション・フレームワーク**です。
#コレクションクラスとは
*「List」「Set」「Map」はインターフェースとして用意されています。*
実際に使用する際には、これらのインターフェースを実装したクラスを使用します。
コレクション・フレームワークのインターフェースを実装したクラスのことを**コレクションクラス**といいます。
#List
- Listは、持っている特長が配列に非常によく似ている。
- 重複した要素を含むことができる順序の付けられたコレクション。
- インデックスによって要素を挿入したり要素にアクセスしたりする位置を自由に変更することができる。

#ArrayListとは
*ArrayListとはListインタフェースを実装したコレクションクラスです。*

Arrayという名にあるように配列のような感覚で扱えます。

ちなみにListを実装したクラスには他にも**LinkedList**や**Stack**といったクラスが存在していますがここでは紹介しません。また別の機会があれば書きたいと思います。
##宣言・初期化

```
ArrayList<型> 変数名 = new ArrayList<型>();
```
クラスの後ろに**"<"**と**">"**に囲まれて型を指定する部分があります。見慣れない記述の仕方ですけどJ2SE5.0から新しく導入された**Generics機能**と呼ばれるもので、このArrayListにどのような型の値を格納するのかを指定します。
###Generics
この型の部分にはクラス名を指定します。そして要素として格納できる値は、ここで指定したクラスのオブジェクトになります。注意して頂きたいのはStringは大丈夫ですがintやfloatは指定できません。これはStringはStringクラスなのですけどintやfloatはクラスでは無く基本型と呼ばれるものだからです。

そこでint型やfloat型などの基本型を扱いたい場合には、各基本型に対応したクラス**(ラッパークラス)**が用意されていますので、それを利用します。

|  対応するクラス     |       基本型         | 
|:-----------------|--------------------:|
| Boolean          |          boolean    | 
| Character        |            char     |
|  Byte            |           byte      |
| Short            |             short   |
| Integer          |              int    |
| Long             |            long     |
| Float            |            float    |
| Doubule          |             double  |

例えば整数を格納するArrayListや、Stringを格納するArrayListを作成する場合は下記のようになります。

```java
ArrayList<Integer> array = new ArrayList<Integer>();
ArrayList<String> array = new ArrayList<String>();
```
##メソッド
- データの挿入

```
add(値)
```
**add(インデックス, 値)**とすると指定インデックスに値を挿入できる。
- データの取り出し

```
get(インデックス)
```
- 要素数（長さ）の取得

```
size()
```
- 空かどうか

```
isEmpty()
```
- 値が含まれているかどうか

```
contains(値)
```
- 値がどのインデックスにあるか

```
indexOf(値)
```
- 指定インデックスの削除

```
remove(インデックス)
```
#Set

- 重複が排除された状態でデータを管理する。
- インデックスで値を管理していないので**get()**できない→ループしてデータを見る
- setの中身をソートしてくれるのがインターフェース**SortedSet**。その実装クラスが**TreeSet**

##List、Setのループ
**Itarator**インターフェースを使うのがいい。

```
＜主なメソッド＞
・next():次の値を取得
・hasNext():次の値があるかどうか
```

```java
for(Iterator ite = stock.itarator; ite.hasNext;) {
     //ite.nextをいじる
}
```
##サンプルコード
①List

```java


import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class UseList {

	public static void main(String[] args) {
		// TODO 自動生成されたメソッド・スタブ
		List<Integer> store = new ArrayList<>();

		System.out.println("登録前：要素数は全部で" + store.size() + "こです。");
		System.out.println("リストは現在空ですか？" + store.isEmpty());

		store.add(54);
		store.add(24);
		store.add(47);
		store.add(0);
		store.add(6);
		store.add(24);
		store.add(85);
		store.add(1);
		store.add(5);
		store.add(6);
		store.add(98);
		store.add(47);
		store.add(54);
		store.add(96);
		store.add(9);

		System.out.println("登録前：要素数は全部で" + store.size() + "こです。");
		System.out.println("リストは現在空ですか？" + store.isEmpty());

		System.out.println("インデックス８の値は" + store.get(8) + "です。");
		System.out.println("値１は含まれていますか？" + store.contains(1));
		System.out.println("値１のインデックスは？" + store.indexOf(1));

		System.out.println("-------------中身を見てみましょう--------------");
		for(Iterator<Integer> ite = store.iterator(); ite.hasNext();) {
			Integer element = ite.next();
			System.out.println(element);
		}
		System.out.println("いくつか値が重複しているところに注目");

		store.remove(8);

		System.out.println("削除後：要素は全部で" + store.size() + "こです。");
		System.out.println("-------------もう１度中身を見てみましょう--------------");
		for(Integer element : store) {
			System.out.println(element);
		}

		store.add(12, 346);
		System.out.println("登録後：要素は全部で" + store.size() + "こです。");
		System.out.println("-------------もう１度中身を見てみましょう--------------");
		for(Integer element : store) {
			System.out.println(element);
		}
	}

}
```
結果

```
登録前：要素数は全部で0こです。
リストは現在空ですか？true
登録前：要素数は全部で15こです。
リストは現在空ですか？false
インデックス８の値は5です。
値１は含まれていますか？true
値１のインデックスは？7
-------------中身を見てみましょう--------------
54
24
47
0
6
24
85
1
5
6
98
47
54
96
9
いくつか値が重複しているところに注目
削除後：要素は全部で14こです。
-------------もう１度中身を見てみましょう--------------
54
24
47
0
6
24
85
1
6
98
47
54
96
9
登録後：要素は全部で15こです。
-------------もう１度中身を見てみましょう--------------
54
24
47
0
6
24
85
1
6
98
47
54
346
96
9
```
②Set

```java

import java.util.HashSet;
import java.util.Set;
public class UseSet {

	public static void main(String[] args) {
		// TODO 自動生成されたメソッド・スタブ
		Set<Integer> store = new HashSet<>();
		
		store.add(54);
		store.add(24);
		store.add(47);
		store.add(0);
		store.add(6);
		store.add(24);
		store.add(85);
		store.add(1);
		store.add(5);
		store.add(6);
		store.add(98);
		store.add(47);
		store.add(54);
		store.add(96);
		store.add(9);
		
		System.out.println("要素数は" + store.size() + "こです。");
		System.out.println("-------------中身を見てみましょう--------------");
		for(Integer element : store) {
			System.out.println(element);
		}
	}

}
```
結果

```
要素数は11こです。
-------------中身を見てみましょう--------------
0
96
1
98
85
5
54
6
24
9
47
```
#Map
- 連想配列
- newの時にキーと値の両方を型として指定（ジェネリクス）


```java

Map<string, Integer> maps new HashMap<>();
```
##Map独特のメソッド
- データの登録

```
put(キー, 値)
```
- キーに含まれているか

```
containsKey(キー)
```
- 値に含まれているか

```
containsValue(値)
```
- 指定キーの削除

```
remove(キー)
```

##Mapのループ

``（注）
Mapはそのままではループできないので「entitySet」を使って切り出したSetオブジェクトをループする。
``

```java
Set entity = maps.entitySet();
for(Iterator ite = entity.itarator; ite.hasNext;) {
     //ite.nextをいじる
}
```
##3種のMapの使い分け

- **HashMap**:とりあえずMapで値を管理したい時
- **TreeMap**:キーでソートさせたい時
- **LinkedHashMap**:putした順序を保持させたい時

##Map + Entity
Javaでもエンティティクラスを作ってMapのキーをDBの主キー。値にエンティティを「new」したものを格納することで*O-Rマッピング*ができる。

##サンプルコード

①

```java


import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class UseMap {
	public static void main(String[] args) {

		HashMap<Integer, String> map = new HashMap<>();

		System.out.println("現在の要素数は" + map.size() + "こです");
		System.out.println("Mapは空ですか？" + map.isEmpty());

		map.put(1, "谷部");
		map.put(3, "黒井");
		map.put(5, "金子");
		map.put(7, "井上");
		map.put(11, "山本");
		map.put(13, "中村");
		map.put(15, "朝付");
		map.put(17, "中島");
		map.put(19, "竹田");
		map.put(21, "木元");
		map.put(25, "斎藤");
		map.put(27, "飛鳥");
		map.put(29, "星野");

		System.out.println("現在の要素数は" + map.size() + "こです");
		System.out.println("Mapは空ですか？" + map.isEmpty());
		System.out.println("--------------------中身を見てみましょう(Iteretor版)------------------------");
		Set<Map.Entry<Integer, String>> entries = map.entrySet();
		for(Iterator<Map.Entry<Integer, String>> ite = entries.iterator(); ite.hasNext();) {
			Map.Entry<Integer, String> element = ite.next();
			Integer key = element.getKey();
			String value = element.getValue();
			System.out.println("key=" +key + ":value=" + value);
		}

		System.out.println("--------------------中身を見てみましょう(便利版)------------------------");
		for(Map.Entry<Integer, String> element : map.entrySet()) {
			Integer key = element.getKey();
			String value = element.getValue();
			System.out.println("key=" +key + ":value=" + value);
		}

		System.out.println("私は" + map.get(25) + "です");
		System.out.println("No22はいますか？" + map.containsKey(22));
		System.out.println("田中さんはいますか？：" + map.containsValue("田中"));

		String name = map.put(9, "中山");
		System.out.println(name + "さんを上書きしました");
		for(Map.Entry<Integer, String> element : map.entrySet()) {
			System.out.println(element);
		}

		name = map.remove(25);
		System.out.println(name + "さんを抹殺しました");
		for(Map.Entry<Integer, String> element : map.entrySet()) {
			System.out.println(element);
		}

		Set<Integer> keySet = map.keySet();
		for(Integer integer : keySet) {
			System.out.println(integer);
		}

		Collection<String> values = map.values();
		for(String eachName : values) {
			System.out.println(eachName);
		}
	}
}
```
結果

```
現在の要素数は0こです
Mapは空ですか？true
現在の要素数は13こです
Mapは空ですか？false
--------------------中身を見てみましょう(Iteretor版)------------------------
key=1:value=谷部
key=3:value=黒井
key=5:value=金子
key=7:value=井上
key=11:value=山本
key=13:value=中村
key=15:value=朝付
key=17:value=中島
key=19:value=竹田
key=21:value=木元
key=25:value=斎藤
key=27:value=飛鳥
key=29:value=星野
--------------------中身を見てみましょう(便利版)------------------------
key=1:value=谷部
key=3:value=黒井
key=5:value=金子
key=7:value=井上
key=11:value=山本
key=13:value=中村
key=15:value=朝付
key=17:value=中島
key=19:value=竹田
key=21:value=木元
key=25:value=斎藤
key=27:value=飛鳥
key=29:value=星野
私は斎藤です
No22はいますか？false
田中さんはいますか？：false
nullさんを上書きしました
1=谷部
3=黒井
5=金子
7=井上
9=中山
11=山本
13=中村
15=朝付
17=中島
19=竹田
21=木元
25=斎藤
27=飛鳥
29=星野
斎藤さんを抹殺しました
1=谷部
3=黒井
5=金子
7=井上
9=中山
11=山本
13=中村
15=朝付
17=中島
19=竹田
21=木元
27=飛鳥
29=星野
1
3
5
7
9
11
13
15
17
19
21
27
29
谷部
黒井
金子
井上
中山
山本
中村
朝付
中島
竹田
木元
飛鳥
星野
```
②

```java

import java.util.HashMap;
import java.util.Map;
public class UseMapAndEntity {

	public static void main(String[] args) {
		// TODO 自動生成されたメソッド・スタブ
		Map<Integer, PersonalData> stock = new HashMap<>();

		PersonalData taro = new PersonalData(46887, "Taro", 72.8, 167.3, 23, 1);
		PersonalData jiro = new PersonalData(12547, "Jiro", 57.7, 170.4, 28, 1);
		PersonalData hanako = new PersonalData(63544, "Hanako", 53.1, 155.4, 19, 0);
		PersonalData keisuke = new PersonalData(34544, "Keisukr", 98.4, 192.4, 35, 1);

		stock.put(46887, taro);
		stock.put(12457, jiro);
		stock.put(63544,hanako);
		stock.put(34544, keisuke);

		System.out.println("要素は" + stock.size() + "こです");

		System.out.println("--------------中身を見てみましょう---------");
		for(Map.Entry<Integer, PersonalData> element :stock.entrySet()) {
			Integer key = element.getKey();
			PersonalData person = element.getValue();

			StringBuffer  sbCurry = new StringBuffer();
			sbCurry.append("会員番号");
			sbCurry.append(key);
			sbCurry.append("の人:");
			sbCurry.append("名前＝");
			sbCurry.append(person.getName());
			sbCurry.append(";");
			sbCurry.append("身長＝");
			sbCurry.append(person.getHeight());
			sbCurry.append("cm;");
			sbCurry.append("体重＝");
			sbCurry.append(person.getWeight());
			sbCurry.append("kg");
			System.out.println(sbCurry.toString());

		}
	}

}


public class PersonalData {
	private Integer _id;
	private String _name;
	private Double _weight;
	private Double _height;
	private Integer _age;
	private Integer _sex;

	//コンストラクタ
	public PersonalData (Integer id, String name, Double weight, Double height, Integer age, Integer sex) {
		_id = id;
		_name = name;
		_weight = weight;
		_height = height;
		_age = age;
		_sex = sex;
	}

	//アクセサメソッド
	public Integer getId() {
		return _id;
	}
	public void setId(Integer id) {
		_id = id;
	}

	public String getName() {
		return _name;
	}
	public void setName(String name) {
		_name = name;
	}

	public Double getWeight() {
		return _weight;
	}
	public void setWeight(Double weight) {
		_weight = weight;
	}

	public Double getHeight() {
		return _height;
	}
	public void setHeight(Double height) {
		_height = height;
	}

	public Integer getAge() {
		return _age;
	}
	public void setAge(Integer age) {
		_age = age;
	}

	public Integer getSex() {
		return _sex;
	}
	public void setSex(Integer sex) {
		_sex = sex;
	}
}
```
結果

```
要素は4こです
--------------中身を見てみましょう---------
会員番号34544の人:名前＝Keisukr;身長＝192.4cm;体重＝98.4kg
会員番号46887の人:名前＝Taro;身長＝167.3cm;体重＝72.8kg
会員番号63544の人:名前＝Hanako;身長＝155.4cm;体重＝53.1kg
会員番号12457の人:名前＝Jiro;身長＝170.4cm;体重＝57.7kg

```

以上。
もし何か間違っている等のご指摘があればご連絡ください。
最後まで読んで頂きありがとうございました。