HashMapを使って次のようなプログラムを書きます。

package TestPackage;

import java.util.HashMap;
import java.util.Map;

public class LinkedListTest6 {

    /**
     * @param args
     */
    public static void main(String[] args) {

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

        //要素の追加
        map.put("test2", 100);
        map.put("qqq", 67);
        map.put("www", 34);
        map.put("eee", 81);

        System.out.println("map -> " + map);
        
        //ここに、コレクションの操作を記述する
        
    }

}

実行結果は次のようなります。

map -> {qqq=67, www=34, test2=100, eee=81}

「キー項目と値」のセットになっていることがわかります。
Hashmapはこのように、２つセットのものを、要素分、格納するコレクションと言えます。

次に、このコレクションを操作してみます。
「ここに、コレクションの操作を記述する」という箇所に次のようなプログラムを書いて見ます。

■キーと値を同時に取得する

    for (Map.Entry<String, Integer> entry : map.entrySet()){
        System.out.println(entry.getKey() + "=>" + entry.getValue());
    }

実行結果は次のようになります。

qqq=>67
www=>34
test2=>100
eee=>81

■キーを取得する

    for (String name : map.keySet()){
        System.out.println(name);
    }

実行結果は次のようになります。

qqq
www
test2
eee

■値を取得する

    for (Integer name : map.values()) {
        System.out.println(name);
    }

実行結果は次のようになります。

67
34
100
81

■キーと値を取得する

    for (String name : map.keySet()) {
        System.out.println(name + "->" + map.get(name));
    }

実行結果は次のようになります。

qqq->67
www->34
test2->100
eee->81

■あるキーをもとに値を取得する

    System.out.println(map.get("qqq"));

実行結果は 「67」 になります。

これは２つ目の要素の値を取得してきていることがわかります。

コレクションの使い方は上記のほかにもまだまだ使い方があるので、別途追求しようと思います。

HashSetを使ってみます。

HashSetは要素の集合に、目的の要素が含まれているかを調べるときに使います。

含まれているかどうかを調べる時に、要素の順番は関係ありません。

また、nullを追加することも可能です。

package TestPackage;

import java.util.HashSet;
import java.util.Set;

public class LinkedListTest5 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		Set<String> set = new HashSet<String>();

		//要素の追加
		set.add("test2");
		set.add("qqq");
		set.add("www");
		set.add("eee");

		System.out.println("set -> " + set);

		if (set.contains("www")){
			System.out.println("要素に含まれている");
		} else {
			System.out.println("要素に含まれていない");
		}

	}

}

実行結果は次のようになります。

set -> [qqq, www, test2, eee]
要素に含まれている

LinkedListをキューとして使ってみます。
プログラムは次のように記述します。

package TestPackage;

import java.util.LinkedList;
import java.util.Queue;

public class LinkedListTest2 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		Queue<String> queue = new LinkedList<String>();

		//要素の追加
		queue.offer("test2");
		queue.offer("ttt");
		queue.offer("mmm");
		queue.offer("ppp");

		//要素の中身を出力する
		System.out.println(queue);

		//先頭要素を取り出す
		queue.poll();

		//要素の中身を出力する
		System.out.println(queue);

		//要素の先頭を「参照」して変数へ代入する
		String peekStr = queue.peek();

		System.out.println(peekStr);

		//要素の中身を出力する
		System.out.println(queue);
}

}

実行結果は次のようになります。

[test2, ttt, mmm, ppp]
[ttt, mmm, ppp]
ttt
[ttt, mmm, ppp]

注意する点は、データ構造がキューを意味している点と、pollメソッドを使って要素を取り出す時には先に挿入したものから取り出されることです。(末尾から操作するメソッドも用意されています)

また、「参照」を行っている箇所は値そのものを取り出さず、値を見ているだけの動きになっています。(一旦、変数に代入してprint文をわかりやすくしているだけです)

LinkedListを使用したコレクションを書いて見ます。
LinkedListは要素の挿入と削除を高速に行います。

一見、ArrayListに似た記述になりますが、先頭に「rrr」を挿入する際のメソッドや宣言の仕方などが微妙に違います(詳しい使い方は別途調べて書いていくことにします)。

package TestPackage;

import java.util.LinkedList;

public class LinkedListTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		LinkedList<String> list = new LinkedList<String>();

		//要素の追加
		list.add("test2");
		list.add("ttt");
		list.add("mmm");
		list.add("ppp");

		//要素の中身を出力する
		System.out.println(list);

		//先頭に「rrr」を挿入
		list.addFirst("rrr");

		//要素の中身を出力する
		System.out.println(list);

	}

}

上記を実行した結果は次のように出力されます。

[test2, ttt, mmm, ppp]
[rrr, test2, ttt, mmm, ppp]

ArrayListを使用したコレクションを書いて見ます。

package TestPackage;

import java.util.ArrayList;
import java.util.List;

public class ArrayListTestX {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		List<String> list = new ArrayList<String>();

		//要素の追加
		list.add("test1");
		list.add("aaa");
		list.add("bbb");
		list.add("ccc");

		//要素の中身を出力する
		System.out.println("最初->" + list.get(0));
		System.out.println("最後->" + list.get(list.size() - 1));

		//すべての要素を出力する
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}

		//bbbが格納されている要素の添え字を調べる
		//(要素は0から始まるので、出力結果は2と表示される)
		System.out.println(list.indexOf("bbb"));

	}

}

上記を実行した結果は次のように出力されます。

最初->test1
最後->ccc
test1
aaa
bbb
ccc
2

javaの引数パラメータに渡したパス(指定ディレクトリ)の中にあるファイルを一覧表示するプログラムを書きます。

実行した結果は、引数で指定したディレクトリ内のディレクトリとファイルが混在された形でコンソールに表示されます。

package TestPackage;

import java.io.File;

public class DirShow {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		if (args.length != 1) {
			System.out.println("args not");
			System.exit(0);
		}

		String dirname = args[0];

		File dir = new File(dirname);

		String[] dirlist = dir.list();

		for (int i=0; i < dir.length(); i++) {
			System.out.println(dirlist[i]);
		}

	}

}

javaからファイルに書き込みを行うプログラムを書いてみました。

実行する時はeclipseの実行→実行構成で引数を２つ指定する必要があるので注意です。
下記画像は引数を設定した例をキャプチャしたものです(ご参考までに)

package TestPackage;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class WriteFile {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		String inputData = args[0];
		String filename = args[1];

		try{
			BufferedReader reader = new BufferedReader(new FileReader(inputData));

			PrintWriter writer = new PrintWriter(new BufferedWriter(new FileWriter(filename)));

			String line;

			// ファイルの中を開いて1行ずつに出力用変数に代入します
			while ((line = reader.readLine()) != null){
				writer.println(line);
			}

			// reader削除します
			reader.close();
			writer.close();

		} catch(FileNotFoundException e){
			System.out.println("filename -> なし");
		} catch(IOException e){
			System.out.println(e);
		}

	}
}

ファイルの読み込みを書いてみます。

package TestPackage;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class ShowFile {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		if (args.length != 1) {
			System.out.println("len 1 !");
			System.exit(0);
		} else {
			System.out.println("len 2 !");
		}

		String filename = args[0];

		try{
			BufferedReader reader = new BufferedReader(new FileReader(filename));
			String line;
			//ファイルの中を開いて1行ずつコンソールに出力する
			while ((line = reader.readLine()) != null){
				System.out.println(line);
			}
		} catch(FileNotFoundException e){
			System.out.println("filename -> なし");
		} catch(IOException e){
			System.out.println(e);
		}

	}

}

上記のソースを書いてプログラムを実行するのですが、ひとつ気をつけなければならないことは

String filename = args[0];

の部分で、プログラム実行時の引数に値が渡ってくる。という概念があります。

eclipseの場合は、メニューの「実行」→「実行構成」から別ウィンドウを開き、その中でJAVAの目的のソースコード名を選択して、「引数」タブ内に引数情報を入力することでプログラムの動作を確認しました。

下記のようなソースを書きます。

package ThreadPackage;

public class JoinTest extends Thread {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		JoinTest th = new JoinTest();

		System.out.println("main start");

		th.start();

		System.out.println("main wait");

		try{
			th.join();
		} catch(InterruptedException e){
			System.out.println(e);
		}

		System.out.println("main end");
	}

	public void run(){
		System.out.println("run start");

		try {
			Thread.sleep(3000);
		}catch(InterruptedException e){
			System.out.println(e);
		}
		System.out.println("run end");
	}

}

実行すると次のようなメッセージがコンソールに表示されます

main start
main wait
run start
run end
main end

いったい何が起きているのかというと、

JoinTest th = new JoinTest();

でいったんスタートしたthというスレッドのインスタンスが実行している間に、

th.join();

というメソッドが起動したタイミングで

public void run(){

のメソッドで定義した別スレッドが起動され、その終了をthというスレッドが待っている状態になっています。

他のスレッドの終了を待ってからメインだったスレッドが再開する。という動作ができます。

注意として、joinというメソッドの使い方には3つの方法があります。

//タイムアウトなし、スレッドの終了を待つ
void join() throws InterruptedException

//タイムアウトあり、スレッドの終了を待つ(ミリ秒)
void join(long msec) throws InterruptedException

//タイムアウトあり、スレッドの終了を待つ(ミリ秒+ナノ秒)
void join(long msec, int nsec) throws InterruptedException

スレッド動作を指定秒ストップさせることができます。

次のようなプログラムを作成して実行してみます。

package ThreadPackage;

public class Ts {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		//スレッドの動作がsleep秒ごとにどんどん遅くなっていく
		for(int i=0; i<10; i++){
			int tm = i  * 1000;
			System.out.println("Start tm -> " + tm);
			try {
				Thread.sleep(tm);
			}catch(InterruptedException e){

			}
		}

	}

}

実行結果は以下のようになり、下に行けば行くほど表示する時間間隔が長くなっていきます。

Start tm -> 0
Start tm -> 1000
Start tm -> 2000
Start tm -> 3000
Start tm -> 4000
Start tm -> 5000
Start tm -> 6000
Start tm -> 7000
Start tm -> 8000
Start tm -> 9000

単純にとあるループ処理を10回繰り返すだけですが、ループ中に

Thread.sleep(tm);

と記載し、tm秒ごとに処理を一時停止しています。

既に実行しているスレッドを止める場合には以下のよう書きます。

public void stopRunning() {
    running = false;
}

使い方については上記のメソッドを起動するタイミング(操作)を既存のスレッドを利用しているプログラムに適用するように使います。
(実際の例は別途追記)

ひとつ前の記事と違う方法でスレッドを書いてみます。

package ThreadPackage;

public class ThreadTest2 implements Runnable {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		ThreadTest2 tt2 = new ThreadTest2();
		Thread th = new Thread(tt2);

		th.start();
		for (int i = 0; i < 10; i++) {
			System.out.println("main : i -> " + i);
		}

	}

	public void run() {
		for (int i = 0; i < 10; i++) {
			System.out.println("run : i -> " + i);
		}
	}

}

実行した結果は次のようになります。

run : i -> 0
main : i -> 0
run : i -> 1
main : i -> 1
run : i -> 2
run : i -> 3
main : i -> 2
run : i -> 4
main : i -> 3
run : i -> 5
run : i -> 6
main : i -> 4
run : i -> 7
main : i -> 5
run : i -> 8
main : i -> 6
run : i -> 9
main : i -> 7
main : i -> 8
main : i -> 9

前回の記事と同じ、ログの出力はランダムな順になります。
呼び出し方が違うことに注意する以外は、考え方とログの出方は一緒です。

スレッド処理を書いて動かしてみます

package ThreadPackage;

public class ThreadTest1 extends Thread {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		ThreadTest1 tt = new ThreadTest1();
		tt.start();

		for(int i=0; i<10; i++){
			System.out.println("main:i->" + i);
		}
	}

	public void run() {
		for (int i=0; i<10; i++) {
			System.out.println("sub:i->" + i );
		}
	}

}

実行した結果は次のようになります。
1回目

sub:i->0
sub:i->1
sub:i->2
sub:i->3
sub:i->4
sub:i->5
main:i->0
sub:i->6
sub:i->7
sub:i->8
sub:i->9
main:i->1
main:i->2
main:i->3
main:i->4
main:i->5
main:i->6
main:i->7
main:i->8
main:i->9

2回目

main:i->0
main:i->1
sub:i->0
sub:i->1
sub:i->2
sub:i->3
main:i->2
main:i->3
sub:i->4
main:i->4
main:i->5
sub:i->5
sub:i->6
sub:i->7
sub:i->8
sub:i->9
main:i->6
main:i->7
main:i->8
main:i->9

3回目

main:i->0
main:i->1
sub:i->0
sub:i->1
sub:i->2
main:i->2
main:i->3
sub:i->3
sub:i->4
sub:i->5
sub:i->6
sub:i->7
sub:i->8
sub:i->9
main:i->4
main:i->5
main:i->6
main:i->7
main:i->8
main:i->9

3回実行した結果を載せたのは、スレッドのスタートタイミングが実行時でそれぞれランダムなので掲載した。

1つのスレッドのみのプログラムの場合は、毎回同じタイミングで同じログが出力されるだけだが、スレッドを利用したプログラムでは、1つ目のプログラムが走る裏でもうひとつのプログラムが走るので、処理が同時に平行してタイミングがまちまちにログが出力されていることがわかります。

インターフェイスを拡張することをができます

interface FastRunnable extends Runnable {
	void fastrun();
}

FastRunnableはRunnableのサブインターフェイス
Runnable はFastRunnable のスーパーインターフェイス
といいいます。

サブインターフェイスはスーパーインターフェイスのメソッドを継承します。

実際にインターフェイスを書いてみます

//Lockableインターフェイスの宣言
interface Lockable {
	//↓これは抽象メソッド
	//abstractキーワードがない場合、自動的に抽象メソッドになります
	boolean lock();
	boolean unlock();
}

インターフェイスの宣言は↑のように行います。

上記のインターフェイスを実装するには、implementsキーワードを使って以下のように書きます。

/*
インターフェイスが持つフィールドは必ず定数
インターフェイスが持つメソッドは必ず抽象メソッド
インターフェイスはインスタンスを作ることはできない
*/

//インターフェイスの実装
class Kinko implements Lockable {

	public boolean lock() {
		return true;
	}

	public boolean unlock() {
		return false;

	}

}

インターフェイスはインスタンスを作ることはできません。

//これはできない
Lockable obj = new Lockable();

インターフェイス型の変数を使うことはできます。

Lockable obj = new Kinko();

obj.lock();
という形で呼び出すことができます。

インターフェイスは、公開すべき必要な操作をまとめたクラスの仕様(取り決め)です。
実際に行う処理の内容は、インターフェイスには記述しないです。
インターフェイスは抽象クラスと同様にインスタンス化はできません。
宣言方法は次のようにします。

interface xxxxx {}

インターフェイスは次の特徴があります。
・インターフェイスで宣言できるメソッドは抽象メソッドのみ
・インターフェイスではpublic staticな定数を宣言できる。定数なので初期化しておく。
・インスタンス化はできず、利用する場合は実装クラスを作成し、実装クラス側では抽象メソッドをオーバーライドして使用する
・実装クラスを定義するにはimplementsキーワードを使用する
・インターフェイスを元にサブインターフェイスを作成する場合はextendsキーワードを使用する

下記のように、catch文を連続して書く方法もあります。

try {

} catch (例外クラス名1 変数名) {

} catch (例外クラス名2 変数名) {

} catch (例外クラス名3 変数名) {

}

ただし、注意しないといけないのは、クラスに継承関係がある場合は、必ずサブクラス側から順に書かないとコンパイルエラーになることです。

ダメな例

try {

} catch (例外クラス名1(親クラス) 変数名) {

} catch (例外クラス名2(子クラス) 変数名) {

} catch (例外クラス名3(子クラス) 変数名) {

}

良い例

try {

} catch (例外クラス名1(子クラス) 変数名) {

} catch (例外クラス名2(子クラス) 変数名) {

} catch (例外クラス名3(親クラス) 変数名) {

}

プログラム内のエラーを受け、例外処理を行った後、最後に必ず実行したい処理を書く領域(ブロック)

構文は以下のように書きます

try {

} catch (例外クラス名 変数名) {

} finally {
    //ここに必ず実行したい処理を書きます
}

■注意点
finallyの中にreturn文を書くことはできないです。

例外処理を行っている「e」の変数に対し、printStackTraceを使うと、コールスタックが表示されます。
e.printStackTrace()と書くと、どのメソッドから例外が投げられたのかを表示することができます。

package TestPackage;

public class ExecptionTest1 {

	public static void main(String[] args) {

		int[] TestArray = new int[3];

		System.out.println("Void Main start !");

		try {
			System.out.println("Try start !");
			TestFunc(TestArray, 100, 0);
			System.out.println("Try end !");
			//TestArray[50] = 0;
		} catch (Exception e) {
			//スタックトレースを使うと、コールスタックが表示され、
			//どのメソッドの中から例外が投げられているのかがわかります
			e.printStackTrace();
			System.out.println("例外 -> " + e);
		}

		System.out.println("Void Main end !");
	}

	static void TestFunc(int[] arr, int index, int value) {
		System.out.println("TestFunc start !");
		arr[index] = value;
		System.out.println("TestFunc end !");
	}

}

出力結果は以下のようになります

Void Main start !
Try start !
java.lang.ArrayIndexOutOfBoundsException: 100
	at TestPackage.ExecptionTest1.TestFunc(ExecptionTest1.java:28)
	at TestPackage.ExecptionTest1.main(ExecptionTest1.java:13)
TestFunc start !
例外 -> java.lang.ArrayIndexOutOfBoundsException: 100
Void Main end !

こうすることで、(ExecptionTest1.java:28)と(ExecptionTest1.java:13)という情報がわかるので、そのソースファイルのエラー原因(上記の場合は配列のインデックスを超えて代入しようとした際のエラー)を注意深く追うことができます。