完了

.project

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <projectDescription>
-	<name>development-taskmanager</name>
+	<name>Taskmanager</name>
 	<comment></comment>
 	<projects>
 	</projects>
@@ -10,14 +10,8 @@
 			<arguments>
 			</arguments>
 		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.wst.common.project.facet.core.builder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
 	</buildSpec>
 	<natures>
-		<nature>org.eclipse.wst.common.project.facet.core.nature</nature>
 		<nature>org.eclipse.jdt.core.javanature</nature>
 	</natures>
 </projectDescription>

file/tasks.csv

@@ -1,7 +0,0 @@
-1,研修内容振り返り,False,2026-09-24,2
-2,旅行の買いだし,True,2027-08-08,3
-3,試験勉強,True,2026-09-24,2
-4,テスト勉強,False,2026-10-30,1
-5,test,True,2026-10-22,1
-6,test1week,False,2026-10-25,3
-7,sort,False,2026-10-23,2

src/App.java

@@ -1,60 +0,0 @@
-import java.util.List;
-import java.util.Scanner;
-
-public class App {
-	
-	static List<Task> allData;
-	
-	// csvファイルを読み込んでタスク情報を保持する
-	public static void init() {
-		View.clearConsole();   // ANSI not work on Eclipse console
-		allData = TaskManager.readCSV();
-		View.print(allData);
-	}
-	// 管理機能を選択する
-	public static String select() {
-		View.standby();
-		Scanner sc = new Scanner(System.in);
-		String mode = sc.nextLine();
-		return mode;
-	}
-	// 管理機能を実行する
-	public static void execute(String mode) throws invalidInputException,PastDateException  {
-		switch (mode) {
-			case "1":
-				allData = TaskManager.register(allData);   // 登録
-				break;
-			case "2":
-				allData = TaskManager.changeStatus(allData);   // 更新
-				break;
-			case "3":
-				allData = TaskManager.remove(allData);   // 削除
-				break;
-			case "4":
-				allData = TaskManager.sort(allData);   // ソート
-				break;
-			case "5":
-				System.exit(0);   // 終了
-			default :
-				throw new invalidInputException();
-		}
-		System.out.println();
-	}
-	// 不正入力時
-	public static void invalid() {
-		System.out.println("正しい番号を入力してください。Enterキーを押してください。");
-		Scanner sc = new Scanner(System.in);
-		sc.nextLine();
-	}
-	// 過去日付指定時
-	public static void past() {
-		System.out.println("過去の日付を登録できません。Enterキーを押してください。");
-		Scanner sc = new Scanner(System.in);
-		sc.nextLine();
-	}
-	// 後処理(ファイル書き込み＋コンソール画面クリア)
-	public static void fin() {
-		TaskManager.writeCSV(allData);
-	}
-	
-}

src/Color.java

@@ -1,70 +0,0 @@
-import java.text.ParseException;
-import java.text.SimpleDateFormat;
-import java.util.Calendar;
-import java.util.Date;
-
-public class Color {
-	
-	// ANSIエスケープ：色指定
-	final static String RED = "\033[00;31m";
-	final static String GREEN = "\033[00;32m";
-	final static String YELLOW = "\033[00;33m";
-	final static String BACK_RED = "\033[00;41m";
-    final static String GRAY = "\033[00;90m";
-    final static String DEFAULT = "\033[00m";
-	
-    // デフォルトに戻す
-    public static String reset() {
-    	return DEFAULT;
-    }
-    // 完了時グレーアウト
-	public static String[] setColorCompleted() {
-		String[] colorList = new String[5];
-		colorList[0] = GRAY;	
-		colorList[1] = GRAY;	
-		colorList[2] = GRAY;	
-		colorList[3] = GRAY;	
-		colorList[4] = GRAY;	
-		return colorList;
-	}
-	// 優先度
-	public static String setColorPrior(int prior) {
-		String color;
-		switch (prior) {
-			case 1:
-				color = GREEN;
-				break;
-			case 2:
-				color = YELLOW;
-				break;
-			case 3:
-				color = RED;
-				break;
-			default:
-				color = YELLOW;
-				break;
-		}
-		return color;
-	}
-	// 期限
-	public static String setColorDeadline(String input) {
-		String color = "";
-		try {
-			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
-			Date date = sdf.parse(input);   // 指定年月日（０時０分０秒）を取得する
-			Date now = new Date();
-			Date today = sdf.parse(sdf.format(now));   // 現在年月日（０時０分０秒）を取得する
-			Calendar calendar = Calendar.getInstance();
-			calendar.setTime(today);
-			calendar.add(Calendar.DAY_OF_MONTH,7);
-			Date nextweek = calendar.getTime();   // １週間後の日付（０時０分０秒）を取得する 
-			if (date.compareTo(today)<0) {
-				color = BACK_RED;   // 期限超過＝背景赤
-			} else if (date.compareTo(nextweek)<0) {
-				color = YELLOW;   // 期限１週間以内＝黄
-			}
-		} catch (ParseException err) {}
-		return color;
-	}
-	
-}

src/Main.java

@@ -1,26 +1,126 @@
+import java.util.Scanner;
+
+//アプリ起動クラス
+//画面制御用
+//実際の処理はTaskManagerへ委譲する
 public class Main {
 
-	public static void main(String[] args) {
+    public static void main(String[] args) {
-		// TODO 自動生成されたメソッド・スタブ
-		
-		while (true) {
-			App.init();
-			try {
-				App.execute(App.select());
-			} catch (invalidInputException err) {
-				App.invalid();
-				continue;
-			} catch (PastDateException err) {
-				App.past();
-				continue;
-			} catch (Exception err) {
-				System.out.println("不明なエラーが検出されました");
-				err.printStackTrace();
-				System.exit(-1);
-			}
-			App.fin();
-		}
-		
-	}
 
-}
+        //キーボード入力用
+        Scanner sc = new Scanner(System.in);
+        //タスク管理クラス生成
+        TaskManager manager = new TaskManager();
+        //起動時にCSV読込
+        manager.loadTasks();
+        //メニュー処理開始
+        showMenu(sc, manager);
+
+        sc.close();
+
+    }
+
+    // メニュー処理
+    // 4が入力されるまでループ
+    public static void showMenu(Scanner sc, TaskManager manager) {
+
+        //メニュー番号
+        int menu = 0;
+
+        while (menu != 5) {
+
+            //タスク一覧表示
+            manager.displayTasks();
+            //メニュー表示
+            displayMenu();
+
+            try {
+
+                //入力値を数値へ変換
+                //数字以外の場合は再入力指示
+                menu =Integer.parseInt(sc.nextLine());
+                //メニュー実行
+                executeMenu(menu, sc, manager);
+
+            } catch (NumberFormatException e) {
+
+                //1~4が入力された場合
+                inputError(sc);
+
+            }
+        }
+    }
+
+    //メニュー表示
+    public static void displayMenu() {
+
+        //行間調整
+        System.out.println();
+        System.out.print("[1] タスク追加　");
+        System.out.print("[2] 完了/未完了の切り替え　");
+        System.out.print("[3] 削除　");
+        System.out.print("[4] ソート　");
+        System.out.println("[5] 終了");
+
+        System.out.print("番号を入力してください > ");
+
+    }
+
+    //メニュー実行
+    //入力された番号に応じて処理を呼び出す
+    public static void executeMenu(int menu, Scanner sc, TaskManager manager) {
+
+        switch (menu) {
+
+        case 1:
+            //タスク追加
+            manager.addTask(sc);
+
+            break;
+
+        case 2:
+            //状態切替
+            manager.changeStatus(sc);
+
+            break;
+
+        case 3:
+            //タスク削除
+            manager.deleteTask(sc);
+
+            break;
+
+        case 4:
+
+            manager.sortTasks(sc);
+
+            break;
+
+        case 5:
+
+            break;
+
+        default:
+
+            // 1～5以外の数値入力
+            inputError(sc);
+
+            break;
+
+        }
+
+    }
+
+    // 入力エラー
+    // Enter入力後にメニューへ戻る
+    public static void inputError(Scanner sc) {
+
+        System.out.println();
+        System.out.println(
+                "正しい番号を入力してください。Enterキーを押してください。");
+
+        sc.nextLine();
+
+    }
+
+}

src/Sort.java

@@ -1,143 +0,0 @@
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
-
-public class Sort {
-	
-	//====================TaskItem sort====================
-	// taskID
-	public static List<Task> sortID(List<Task> allData, String input) {
-		if (isReverse(input)) {
-			Collections.sort(allData,new Sort.revIDComparator());   // 降順
-		} else {
-			Collections.sort(allData,new Sort.IDComparator());   // 昇順
-		}
-		return allData;
-	}
-	// isComplete
-	public static List<Task> sortStatus(List<Task> allData, String input) {
-		if (isReverse(input)) {
-			Collections.sort(allData,new Sort.revStatusComparator());   // 降順
-		} else {
-			Collections.sort(allData,new Sort.StatusComparator());   // 昇順
-		}
-		return allData;
-	}
-	// priority
-	public static List<Task> sortPriority(List<Task> allData, String input) {
-		if (isReverse(input)) {
-			Collections.sort(allData,new Sort.revPriorityComparator());   // 降順
-		} else {
-			Collections.sort(allData,new Sort.PriorityComparator());   // 昇順
-		}
-		return allData;
-	}
-	// deadline
-	public static List<Task> sortDeadline(List<Task> allData, String input) {
-		if (isReverse(input)) {
-			Collections.sort(allData,new Sort.revDeadlineComparator());   // 降順
-		} else {
-			Collections.sort(allData,new Sort.DeadlineComparator());   // 昇順
-		}
-		return allData;
-	}
-	// taskName
-	public static List<Task> sortName(List<Task> allData, String input) {
-		if (isReverse(input)) {
-			Collections.sort(allData,new Sort.revNameComparator());   // 降順
-		} else {
-			Collections.sort(allData,new Sort.NameComparator());   // 昇順
-		}
-		return allData;
-	}
-	// ソート順指定フラグを生成する
-	public static boolean isReverse(String input) {
-		boolean isReverse = false;
-		try {
-			int order = Integer.parseInt(input);
-			switch (order) {
-				case 1:
-					break;
-				case 2:
-					isReverse = true;   // 2:降順
-					break;
-				default:
-					break;
-			}
-		} catch (NumberFormatException err) {}
-		return isReverse;
-	}
-	
-	//====================TaskItemフィールド比較条件定義====================
-	// ID比較（昇順）
-	public static class IDComparator implements Comparator<Task> {
-		@Override
-		public int compare(Task t1,Task t2) {
-			return Integer.compare(((TaskItem)t1).getTaskID(),((TaskItem)t2).getTaskID());
-		}
-	}
-	// ID比較（降順）
-	public static class revIDComparator implements Comparator<Task> {
-		@Override
-		public int compare(Task t1,Task t2) {
-			return Integer.compare(((TaskItem)t2).getTaskID(),((TaskItem)t1).getTaskID());
-		}
-	}
-	// isComplete比較（昇順）
-	public static class StatusComparator implements Comparator<Task> {
-		@Override
-		public int compare(Task t1,Task t2) {
-			return Boolean.compare(((TaskItem)t1).getIsComplete(),((TaskItem)t2).getIsComplete());
-		}
-	}
-	// isComplete比較（降順）
-	public static class revStatusComparator implements Comparator<Task> {
-		@Override
-		public int compare(Task t1,Task t2) {
-			return Boolean.compare(((TaskItem)t2).getIsComplete(),((TaskItem)t1).getIsComplete());
-		}
-	}
-	// priority比較（昇順）＝優先度"高"→"低"
-	public static class PriorityComparator implements Comparator<Task> {
-		@Override
-		public int compare(Task t1,Task t2) {
-			return Integer.compare(((TaskItem)t2).getPriority(),((TaskItem)t1).getPriority());
-		}
-	}
-	// priority比較（降順）＝＝優先度"低"→"高"
-	public static class revPriorityComparator implements Comparator<Task> {
-		@Override
-		public int compare(Task t1,Task t2) {
-			return Integer.compare(((TaskItem)t1).getPriority(),((TaskItem)t2).getPriority());
-		}
-	}
-	// deadline比較（昇順）
-	public static class DeadlineComparator implements Comparator<Task> {
-		@Override
-		public int compare(Task t1,Task t2) {
-			return ((TaskItem)t1).getDeadline().compareTo(((TaskItem)t2).getDeadline());
-		}
-	}
-	// deadline比較（降順）
-	public static class revDeadlineComparator implements Comparator<Task> {
-		@Override
-		public int compare(Task t1,Task t2) {
-			return ((TaskItem)t2).getDeadline().compareTo(((TaskItem)t1).getDeadline());
-		}
-	}
-	// taskName比較（辞書昇順）
-	public static class NameComparator implements Comparator<Task> {
-		@Override
-		public int compare(Task t1,Task t2) {
-			return ((TaskItem)t1).getTaskName().compareTo(((TaskItem)t2).getTaskName());
-		}
-	}
-	// taskName比較（辞書降順）
-	public static class revNameComparator implements Comparator<Task> {
-		@Override
-		public int compare(Task t1,Task t2) {
-			return ((TaskItem)t2).getTaskName().compareTo(((TaskItem)t1).getTaskName());
-		}
-	}
-	
-}

src/Task.java

@@ -1,7 +1,64 @@
+ //タスク情報管理用クラス
+ //カプセル化のためフィールドはprivate
+ //値の取得や変更はgetter/setterを利用する
+
+public class Task {
+    //タスクID
+    private int id;
+    //タスク名
+    private String taskName;
+    //完了状態
+    private boolean completed;
+    //期限
+    private String deadline;
+    //優先度
+    private int priority;
+
+    //コンストラクタ
+    //タスク生成時に初期値を設定
+
+    public Task(int id, String taskName, boolean completed, String deadline, int priority) {
+        this.id = id;
+        this.taskName = taskName;
+        this.completed = completed;
+        this.deadline = deadline;
+        this.priority = priority;
+    }
+
+    //ID取得
+    //ゲッター
+    public int getId() {
+        return id;
+    }
+
+    //タスク名取得
+    //ゲッター
+    public String getTaskName() {
+        return taskName;
+    }
+
+    //完了状態取得
+    //ゲッター
+    public boolean isCompleted() {
+        return completed;
+    }
+
+    //完了状態切り替え時に使用
+    //セッター
+    public void setCompleted(boolean completed) {
+        this.completed = completed;
+    }
+
+    //期限取得
+    //ゲッター
+    public String getDeadline() {
+        return deadline;
+    }
+
+    //優先度取得
+    //ゲッター
+    public int getPriority() {
+        return priority;
+    }
 
-public interface Task {
-	
-	String toString();
-	String toCSV();
-	
 }

src/TaskItem.java

@@ -1,196 +0,0 @@
-import java.text.ParseException;
-import java.text.SimpleDateFormat;
-import java.util.Calendar;
-import java.util.Date;
-
-public class TaskItem implements Task {
-	
-	private int taskID;
-	private String taskName;
-	private boolean isComplete;
-	private String deadline;
-	private int priority;
-	static int MaxTaskID = 0;
-	
-	//====================getter/setter====================
-	public int getTaskID() {
-		return taskID;
-	}
-	public void setTaskID(int taskID) {
-		this.taskID = taskID;
-	}
-	public String getTaskName() {
-		return taskName;
-	}
-	public void setTaskName(String taskName) {
-		this.taskName = taskName;
-	}
-	public boolean getIsComplete() {
-		return isComplete;
-	}
-	public void setIsComplete(boolean isComplete) {
-		this.isComplete = isComplete;
-	}
-	public String getDeadline() {
-		return deadline;
-	}
-	public void setDeadline(String deadline) {
-		this.deadline = deadline;
-	}
-	public int getPriority() {
-		return priority;
-	}
-	public void setPriority(int priority) {
-		this.priority = priority;
-	}
-	
-	//====================コンストラクタ====================
-	// コンストラクタ（登録時）
-	public TaskItem(String taskName, String deadline, String priority) throws PastDateException {   // 文字列入力を受け取る
-		MaxTaskID++;
-		this.setTaskID(MaxTaskID);   // 消去したタスクIDは使い回さない→最大ID+1のタスクとして登録する
-		this.setTaskName(taskName);
-		this.setDeadline(this.getValidDeadline(deadline));
-		this.setPriority(this.getPriorityIndex(priority));
-	}
-	// コンストラクタ（csv読み取り時）
-	public TaskItem(String taskID, String taskName,String isComplete, String deadline, String priority) {   // 文字列入力を受け取る
-		this.setTaskID(Integer.parseInt(taskID));
-		this.setTaskName(taskName);
-		this.setIsComplete(this.getIsCompleteBool(isComplete));
-		this.setDeadline(deadline);   // csv読み取り時に不正入力判定は行わない
-		this.setPriority(this.getPriorityIndex(priority));
-		if (MaxTaskID<Integer.parseInt(taskID)) {
-			MaxTaskID = Integer.parseInt(taskID);   // 最大IDを記録する
-		}
-	}
-	
-	//====================メソッドforコンストラクタ(非公開)====================
-	// 完了フラグ入力文字列を真偽値に変換する
-	private boolean getIsCompleteBool(String input) {
-		boolean isComplete = false;   // デフォルト＝未完了(false)
-		if (input.equals("True")) {
-			isComplete=true;
-		}
-		else if (input.equals("False")) {
-			isComplete=false;
-		}
-		return isComplete;
-	}
-	// 期限の不正入力をチェックする（不正入力→現在年月日）
-	private String getValidDeadline(String input) throws PastDateException {
-		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
-		String now = sdf.format(new Date());
-		String deadline = now;   // デフォルト＝現在年月日
-		try {
-			// フォーマット照合
-			Date today = sdf.parse(now);   // 現在年月日（０時０分０秒）を取得する
-			SimpleDateFormat inputsdf = new SimpleDateFormat("yyyy/MM/dd");
-			Date date = inputsdf.parse(input);   // 指定年月日（０時０分０秒）を取得する(不正入力検出)
-			// 指定年月日が現在年月日より後であるかを確認する
-			if (date.compareTo(today)<0) {
-				throw new PastDateException();
-			}
-			String[] ymd = input.split("/",3);   // 年月日取得
-			// 入力文字列が１月～１２月を指定していることを確認する
-			boolean isUnderDec = Integer.parseInt(ymd[1])<=12;
-			// 入力文字列の指定日が指定月最終日より小さいことを確認する
-			Calendar calendar = Calendar.getInstance();
-			calendar.set(Calendar.YEAR,Integer.parseInt(ymd[0]));
-			calendar.set(Calendar.MONTH,Integer.parseInt(ymd[1])-1);   // Calendar.MONTH：0_index
-			boolean isUnderLastday = Integer.parseInt(ymd[2])<=(calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
-			if (isUnderDec&&isUnderLastday) {
-				deadline = sdf.format(date);   // 正常入力
-			}
-		} catch (ParseException err) {}
-		return deadline;
-	}
-	// 優先度入力文字列を整数に変換する
-	private int getPriorityIndex(String priority) {
-		int priorityIndex = 2;   // デフォルト＝2
-		try {
-			priorityIndex = Integer.parseInt(priority);
-		} catch (Exception e) {}
-		return priorityIndex;
-	}
-	
-	//====================出力====================
-	// 文字列for画面出力
-	@Override
-	public String toString() {
-		// ID桁数を参照した空白文字列を生成する
-		int nMaxSpace = 4;
-		String space = "";
-		for (int i=0;i<nMaxSpace-String.valueOf(this.getTaskID()).length();i++) {
-			space += " ";
-		}
-		// 色付け
-		String[] colorList = setColor();
-		return   colorList[0]+this.getTaskID()    +Color.reset()    +space
-		   +"| "+colorList[1]+this.toStringComp() +Color.reset() +" "
-		 +"| 　"+colorList[2]+this.toStringPrior()+Color.reset()+"　 "
-		   +"| "+colorList[3]+this.getDeadline()  +Color.reset()  +" "
-		   +"| "+colorList[4]+this.getTaskName()  +Color.reset();
-	}
-	// 文字列forExcel出力
-	public String toCSV() {
-		return this.getTaskID()+","
-			  +this.getTaskName()+","
-			  +this.toStringCompCSV()+","
-			  +this.getDeadline()+","
-			  +this.getPriority();
-	}
-	
-	//====================メソッドfor出力(非公開)====================
-	// 完了フラグを文字列に変換する(完了/未完了)
-	private String toStringComp() {
-		String strComp;
-		if (this.getIsComplete()) strComp = "[x] 完了　";
-		else strComp = "[ ] 未完了";
-		return strComp;
-	}
-	// 完了フラグを文字列に変換する(True/False)
-	private String toStringCompCSV() {
-		String strComp;
-		if(this.getIsComplete()) strComp = "True";
-		else strComp = "False";
-		return strComp;
-	}
-	// 優先度フラグを文字列に変換する
-	private String toStringPrior() {
-		String strPrior;
-		switch (this.getPriority()) {
-			case 1:
-				strPrior="低";
-				break;
-			case 2:
-				strPrior="中";
-				break;
-			case 3:
-				strPrior="高";
-				break;
-			default:
-				strPrior="中";
-				break;
-		}
-		return strPrior;
-	}
-	// 色テンプレートを作成する
-	private String[] setColor() {
-		String[] colorList = {"","","","",""};
-		if (this.getIsComplete()) {
-			colorList = Color.setColorCompleted();   // 完了フラグ
-		} else {
-			colorList[2] = Color.setColorPrior(this.getPriority());   // 優先度
-			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
-			colorList[3] = Color.setColorDeadline(this.getDeadline());   // 期限
-		}
-		return colorList;
-	}
-	
-}
-
-// 過去日付指定エラークラス
-class PastDateException extends Exception {
-	
-}

src/TaskManager.java

@@ -1,139 +1,520 @@
 import java.io.BufferedReader;
-import java.io.File;
+import java.io.FileReader;
-import java.io.FileInputStream;
 import java.io.FileWriter;
 import java.io.IOException;
-import java.io.InputStreamReader;
+import java.time.LocalDate;
 import java.util.ArrayList;
-import java.util.List;
+import java.util.Comparator;
 import java.util.Scanner;
 
+//タスク管理クラス
+//タスクの登録・表示・削除・状態変更
+//CSVの読込・保存
 public class TaskManager {
-	
+	// CSVファイル保存先
-	static final String PATH = "./file/tasks.csv";
+	public static String Path =
-	
+			"C:\\Users\\石原　叶大\\Documents\\development-taskmanager\\タスク管理システム実行例_石原\\tasks.csv";
-	//====================配列管理====================
-	// タスク追加
-	public static List<Task> register(List<Task> allData) throws PastDateException {
-		Scanner sc = new Scanner(System.in);
-		System.out.print("タスク名を入力:　");
-		String name = sc.nextLine();
-		System.out.print("期限を入力 (例: 2026/09/20) [未入力:今日]:　");
-		String deadline = sc.nextLine();
-		System.out.print("優先度を入力（1:低, 2:中, 3:高）[デフォルト:2]:　");
-		String priority = sc.nextLine();
-		Task newTask = new TaskItem(name,deadline,priority);
-		allData.add(newTask);
-		return allData;
-	}
-	// 完了/未完了の切り替え
-	public static List<Task> changeStatus(List<Task> allData) throws invalidInputException {
-		Scanner sc = new Scanner(System.in);
-		System.out.print("状態を変更するタスクIDを入力:　");
-		String id = sc.nextLine();
-		boolean currentStatus = ((TaskItem)(allData.get(getIndex(allData,id)))).getIsComplete();
-		((TaskItem)(allData.get(getIndex(allData,id)))).setIsComplete(!currentStatus);   // 状態を反転させる
-		return allData;
-	}
-	// 削除
-	public static List<Task> remove(List<Task> allData) throws invalidInputException {
-		Scanner sc = new Scanner(System.in);
-		System.out.print("削除するタスクIDを入力:　");
-		String id = sc.nextLine();
-		allData.remove(getIndex(allData,id));
-		return allData;
-	}
-	// ID照合→該当タスク配列インデックス取得
-	public static int getIndex(List<Task> allData,String id) throws invalidInputException {
-		boolean isMatched = false;
-		int index = 0;
-		for (Task data : allData) {
-			try {
-				if (((TaskItem)data).getTaskID()==Integer.parseInt(id)) {
-					isMatched = true;
-					break;
-				}
-			} catch (NumberFormatException err) {
-				throw new invalidInputException();   // 不正入力→例外
-			}
-			index++;
-		}
-		if (isMatched==false) {
-			throw new invalidInputException();   // ID照合失敗→例外
-		}
-		return index;	
-	}
-	// ソート
-	public static List<Task> sort (List<Task> allData) {
-		Scanner sc = new Scanner(System.in);
-		System.out.print("並び替え時に参照する項目を入力（1:ID, 2:状態, 3:優先度, 4:期限, 5:タスク名）[デフォルト:1]:");
-		String mode = sc.nextLine();
-		System.out.print("並び替え順を入力（1:昇順, 2:降順）[デフォルト:1]");
-		String order = sc.nextLine();
-		switch (mode) {
-			case "1":
-				allData = Sort.sortID(allData,order);
-				break;
-			// 同一条件はID昇順に並べる
-			case "2":
-				allData = Sort.sortID(allData,"1");
-				allData = Sort.sortStatus(allData,order);
-				break;
-			case "3":
-				allData = Sort.sortID(allData,"1");
-				allData = Sort.sortPriority(allData,order);
-				break;
-			case "4":
-				allData = Sort.sortID(allData,"1");
-				allData = Sort.sortDeadline(allData,order);
-				break;
-			case "5":
-				allData = Sort.sortID(allData,"1");
-				allData = Sort.sortName(allData,order);
-				break;
-			default :
-				allData = Sort.sortID(allData,"1");
-				break;
-		}
-		return allData;
-	}
-	
-	//====================ファイル入出力====================
-	// csvファイルからタスク情報を読み込む
-	public static List<Task> readCSV() {
-		List<Task> allData = new ArrayList<Task>();
-		File f = new File(PATH);
-		try (BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(f),"UTF-8"))) {
-			String line = "";
-			while ((line=br.readLine())!=null) {
-				String[] data = line.split(",",0);
-				Task task = new TaskItem(data[0],data[1],data[2],data[3],data[4]);
-				allData.add(task);
-			}
-		} catch (IOException err) {
-			System.out.println("ファイルの読み込みに失敗しました");
-			err.printStackTrace();
-			System.exit(-1);
-		}
-		return allData;
-	}
-	// csvファイルにタスク情報を書き込む
-	public static void writeCSV(List<Task> allData) {
-		File f = new File(PATH);
-		try (FileWriter fr = new FileWriter(f)) {
-			for (Task data : allData) {
-				fr.append(data.toCSV()+"\n");
-			}
-		} catch (IOException err) {
-			System.out.println("ファイルの書き込みに失敗しました");
-			err.printStackTrace();
-			System.exit(-1);
-		}
-	}
-	
-}
 
-// ID照合失敗エラークラス
+	//タスク一覧
-class invalidInputException extends Exception {
+	//タスク数が増減するのでArrayListを使用
-	
+	private ArrayList<Task> tasks = new ArrayList<Task>();
-}
+	//CSV読込
+	//CSVデータをArrayListへ格納する
+	public void loadTasks() {
+		try {
+			BufferedReader br =	new BufferedReader(new FileReader(Path));
+
+			String line;
+			//1行ずつ読み込むループ
+			while ((line = br.readLine()) != null) {
+				//カンマ区切りで分割
+				String[] data = line.split(",");
+
+				if (data.length == 5) {
+					int id = Integer.parseInt(data[0]);
+					String taskName = data[1];
+					boolean completed = Boolean.parseBoolean(data[2]);
+					String deadline = data[3];
+					int priority = Integer.parseInt(data[4]);
+
+					Task task = new Task(id, taskName, completed, deadline, priority);
+					tasks.add(task);
+				}
+			}
+			br.close();
+
+		} catch (IOException e) {
+			System.out.println("CSVファイルが存在しないため新規作成します");
+		}
+	}
+
+	//CSV保存
+	//ArrayList内のデータをCSVへ保存
+
+	public void saveTasks() {
+		try {
+			FileWriter fw = new FileWriter(Path);
+
+			//全件保存
+			for (Task task : tasks) {
+				fw.write(
+						task.getId() + ","
+								+ task.getTaskName() + ","
+								+ task.isCompleted() + ","
+								+ task.getDeadline() + ","
+								+ task.getPriority()
+								+ "\n");//改行用
+			}
+			fw.close();
+
+		} catch (IOException e) {
+			System.out.println("保存に失敗しました");
+		}
+	}
+
+	//文字色
+	public static String Red = "\u001B[31m";
+	public static String Yellow = "\u001B[33m";
+	public static String Blue = "\u001B[36m";
+	public static String Gray = "\u001B[90m";
+	public static String Reset = "\u001B[0m";
+
+	//タスク一覧表示
+	public void displayTasks() {
+
+		System.out.println("==========================================================");
+		System.out.println("                     Task Manager");
+		System.out.println("==========================================================");
+		System.out.println("ID | 状態         | 優先度 | 期限       | タスク名");
+		System.out.println("----------------------------------------------------------");
+
+		if (tasks.isEmpty()) {
+			System.out.println("登録されているタスクはありません。");
+			return;
+		}
+
+		//拡張for文
+		//ArrayListからタスクを1件ずつ取得
+		for (Task task : tasks) {
+			String status;
+			// TRUE/FALSEを表示用文字へ変換
+			if (task.isCompleted()) {
+				status = "[x] 完了　";
+			} else {
+				status = "[ ] 未完了";
+			}
+			String priorityText = "";
+
+			//優先度変換
+			switch (task.getPriority()) {
+
+			case 1:
+			    priorityText = "低     ";
+			    break;
+
+			case 2:
+			    priorityText = "中     ";
+			    break;
+
+			case 3:
+			    priorityText = "高     ";
+			    break;
+
+			}
+			
+			if (!task.isCompleted()) {
+
+			    switch (task.getPriority()) {
+
+			    case 1:
+			        priorityText = Blue + priorityText + Reset;
+			        break;
+
+			    case 2:
+			        priorityText = Yellow + priorityText + Reset;
+			        break;
+
+			    case 3:
+			        priorityText = Red + priorityText + Reset;
+			        break;
+			    }
+			}
+
+			String gray =
+			        padRight(String.valueOf(task.getId()), 3)
+			        + "| "
+			        + padRight(status, 10)
+			        + "| "
+			        + priorityText
+			        + "| "
+			        + padRight(task.getDeadline(), 11)
+			        + "| "
+			        + task.getTaskName();
+
+			if (task.isCompleted()) {
+
+			    System.out.println(
+			            Gray + gray + Reset);
+
+			} else {
+
+			    System.out.println(gray);
+
+			}
+		}
+	}
+	//タスク追加
+	//入力内容からタスクを作成
+	public void addTask(Scanner sc) {
+		//行間調整用
+		System.out.println();
+		// タスク名入力
+		System.out.print("タスク名を入力：");
+		String taskName = sc.nextLine();
+
+		//期限入力
+		System.out.print(
+				"期限を入力(例：2026/09/20) [未入力で今日]：");
+
+		String deadline =
+				sc.nextLine();
+
+		//未入力なら今日の日付
+		if (deadline.isEmpty()) {
+			deadline = LocalDate.now().toString().replace("-", "/");
+
+		} else {
+			try {
+				//入力値を日付へ変換
+				LocalDate inputDate = LocalDate.parse(deadline.replace("/", "-"));
+
+				//過去日付なら処理中断
+				if (inputDate.isBefore(LocalDate.now())) {
+					System.out.println("過去の日付は入力できません。");
+
+					pause(sc);
+					return;
+				}
+
+				//保存形式をYYYY/MM/DDに統一
+				deadline =inputDate.toString().replace("-", "/");
+
+			} catch (Exception e) {
+				System.out.println("正しい日付を入力してください。(YYYY/MM/DD) 例:2026/01/01");
+
+				pause(sc);
+				return;
+			}
+		}
+
+		//優先度入力
+		System.out.print( "優先度(1:低 2:中 3:高) [デフォルト:2]：");
+
+		String input = sc.nextLine();
+
+		//未入力なら中
+		int priority = 2;
+		if (!input.isEmpty()) {
+
+			priority = Integer.parseInt(input);
+
+			//1～3以外なら中断
+			if (priority < 1 || priority > 3) {
+				return;
+			}
+		}
+
+		//新規ID
+		int id = 1;
+		if (!tasks.isEmpty()) {
+			id = tasks.get(tasks.size() - 1).getId() + 1;
+		}
+
+		//タスク生成
+		Task task = new Task(id, taskName, false, deadline, priority);
+
+		//一覧へ追加
+		tasks.add(task);
+
+		//CSV保存
+		saveTasks();
+
+	}
+
+	//完了・未完了切替
+	public void changeStatus(Scanner sc) {
+		//行間調整
+		System.out.println();
+		System.out.print("状態を変更するタスクIDを入力：");
+
+		int targetId = Integer.parseInt(sc.nextLine());
+
+		boolean found = false;
+		for (Task task : tasks) {
+			if (task.getId() == targetId) {
+
+				//true・false変換
+
+				task.setCompleted(!task.isCompleted());
+				found = true;
+
+				break;
+
+			}
+
+		}
+
+		if (found) {
+			saveTasks();
+			System.out.println("状態を切り替えました。");
+
+		} else {
+			System.out.println(
+					"そのIDのタスクはみつかりませんでした。");
+
+		}
+
+		pause(sc);
+
+	}
+
+	//タスク削除
+	//指定IDのタスクを削除する
+	public void deleteTask(Scanner sc) {
+		//行間調整
+		System.out.println();
+		System.out.print("削除するタスクIDを入力：");
+
+		int targetId = Integer.parseInt(sc.nextLine());
+
+		boolean found = false;
+
+		for (int i = 0; i < tasks.size(); i++) {
+			if (tasks.get(i).getId() == targetId) {
+				tasks.remove(i);
+				found = true;
+
+				break;
+			}
+		}
+
+		if (found) {
+			saveTasks();
+			System.out.println("タスクを削除しました。");
+
+		} else {
+			System.out.println("そのIDのタスクは見つかりませんでした。");
+
+		}
+
+		pause(sc);
+
+	}
+	//タスク名種別判定
+	//タスク名の先頭文字からソート用に番号を返す
+	//英語→1、ひらがな→2、カタカナ→3、数字→4
+	private int getTaskNameCategory(String taskName) {
+
+	    if (taskName.isEmpty()) {
+	        return 5;
+	    }
+
+	    char c = taskName.charAt(0);
+
+	    //英字
+	    if ((c >= 'A' && c <= 'Z')
+	            || (c >= 'a' && c <= 'z')) {
+	        return 1;
+	    }
+
+	    //ひらがな
+	    if (c >= 'あ' && c <= 'ん') {
+	        return 2;
+	    }
+	    
+	    //カタカナ
+	    if (c >= 'ア' && c <= 'ン') {
+	        return 3;
+	    }
+
+	    //数字
+	    if (c >= '0' && c <= '9') {
+	        return 4;
+
+	    }
+
+	    return 5;
+
+	}
+
+	//ソート
+	//指定項目を昇順または降順で並び替える
+	public void sortTasks(Scanner sc) {
+
+	    System.out.println("[1] ID");
+	    System.out.println("[2] 状態");
+	    System.out.println("[3] 優先度");
+	    System.out.println("[4] 期限");
+	    System.out.println("[5] タスク名");
+
+	    System.out.print("どの項目をソートしますか > ");
+
+	    int type;
+	    try {
+	        type = Integer.parseInt(sc.nextLine());
+
+	    } catch (NumberFormatException e) {
+	        Main.inputError(sc);
+
+	        return;
+	    }
+
+	    //入力チェック
+	    //1～5以外の場合はメニューへ戻る
+	    if (type < 1 || type > 5) {
+	        Main.inputError(sc);
+
+	        return;
+	    }
+	    //行間調整
+	    System.out.println();
+	    System.out.println("[1] 昇順");
+	    System.out.println("[2] 降順");
+
+	    System.out.print("並び順を選択してください > ");
+
+	    int order;
+	    try {
+	        order = Integer.parseInt(sc.nextLine());
+
+	    } catch (NumberFormatException e) {
+	        Main.inputError(sc);
+
+	        return;
+	    }
+
+	    //入力チェック
+	    //1または2以外の場合はメニューへ戻る
+	    if (order < 1 || order > 2) {
+	        Main.inputError(sc);
+
+	        return;
+	    }
+
+	    //true=昇順 false=降順
+	    boolean ascending = order == 1;
+
+	    switch (type) {
+
+	    //IDソート
+	    case 1:
+	        if (ascending) {
+	            tasks.sort(Comparator.comparingInt(Task::getId));
+
+	        } else {
+	            tasks.sort(Comparator.comparingInt(Task::getId).reversed());
+	        }
+
+	        break;
+
+	    //状態ソート
+	    case 2:
+	        if (ascending) {
+	            tasks.sort(Comparator.comparing(Task::isCompleted));
+
+	        } else {
+	            tasks.sort(Comparator.comparing(Task::isCompleted).reversed());
+	        }
+
+	        break;
+
+	    //優先度ソート
+	    case 3:
+	        if (ascending) {
+	            tasks.sort(Comparator.comparingInt(Task::getPriority));
+	            
+	        } else {
+	            tasks.sort(Comparator.comparingInt(Task::getPriority).reversed());
+
+	        }
+
+	        break;
+
+	    //期限ソート
+	    case 4:
+	        if (ascending) {
+	            tasks.sort(Comparator.comparing(Task::getDeadline));
+
+	        } else {
+	            tasks.sort(Comparator.comparing(Task::getDeadline).reversed());
+
+	        }
+
+	        break;
+
+	    //タスク名ソート
+	    case 5:
+	        if (ascending) {
+	            tasks.sort((task1, task2) -> {
+	                int category1 =getTaskNameCategory(task1.getTaskName());
+	                int category2 =getTaskNameCategory(task2.getTaskName());
+	                
+	                //文字種別比較
+	                if (category1 != category2) {
+
+	                    return category1 - category2;
+
+	                }
+
+	                //同じ文字種別なら名前比較
+	                return task1.getTaskName().compareTo(task2.getTaskName());
+
+	            });
+
+	        } else {
+	            tasks.sort((task1, task2) -> {
+
+	                int category1 = getTaskNameCategory(task1.getTaskName());
+
+	                int category2 = getTaskNameCategory(task2.getTaskName());
+
+	                //文字種別比較
+	                if (category1 != category2) {
+
+	                    return category2 - category1;
+
+	                }
+
+	                //同じ文字種別なら逆順比較
+	                return task2.getTaskName().compareTo(task1.getTaskName());
+
+	            });
+	        }
+	        break;
+	    }
+
+	    pause(sc);
+
+	}
+	//指定文字数まで空白を追加
+	//一覧表示の列を揃えるために利用
+	public String padRight(
+			String text,
+			int length) {
+
+		while (text.length() < length) {
+			text += " ";
+		}
+		return text;
+
+	}
+
+	//Enter待機
+	public void pause(Scanner sc) {
+		System.out.println("Enterキーを押してください。");
+
+		sc.nextLine();
+
+	}
+
+}

src/View.java

@@ -1,32 +0,0 @@
-import java.util.List;
-
-public class View {
-	
-	// コンソール画面クリア
-	public static void clearConsole() {
-//		System.out.print("\033[0;0J"+"\033[2J");   // not work on Eclipse conasole
-		// 空行を出力して前回の表示を隠す
-		for (int i=0;i<100;i++) { System.out.println(); }
-	}
-	
-	// タスク一覧を画面出力する
-	public static void print(List<Task> allData) {
-		System.out.println(
-				"============================================================\n"
-			  + "                        Task Manager\n"
-			  + "============================================================\n"
-			  + "ID  | 状態　　　 | 優先度 | 期限       | タスク名\n"
-			  + "------------------------------------------------------------\n");
-		for (Task data : allData) {
-			System.out.println(data);
-		}
-		System.out.println();
-	}
-	
-	// 入力待機表示を画面出力する
-	public static void standby() {
-		System.out.println("[1] タスク追加  [2] 完了/未完了の切り替え  [3] 削除  [4] ソート  [5] 終了");
-		System.out.print("番号を入力してください >　");
-	}
-	
-}

src/testcolor.java

@@ -1,17 +0,0 @@
-
-public class testcolor {
-
-	public static void main(String[] args) {
-		// TODO 自動生成されたメソッド・スタブ
-		
-		for (int i = 0; i < 11; i++) {
-			for (int j = 0; j < 10; j++) {
-				int v = i*10+j;
-				System.out.printf("\033[%dm"+"%03d"+"\033[0m ",v,v);
-			}
-			System.out.printf("\n");
-	    }
-		
-	}
-
-}

タスク管理システム実行例/tasks.csv

@@ -2,4 +2,3 @@
 2,旅行の買いだし,False,2027-08-08,3
 3,試験勉強,True,2026-09-24,2
 4,テスト勉強,False,2026-10-30,1
-5,test,False,2026-10-23,2

タスク管理システム実行例_石原/tasks.csv

@@ -0,0 +1,13 @@
+6,test,false,2026/10/23,2
+7,test,true,2026/10/23,2
+8,test2,false,2026/12/12,1
+9,test3,false,2026/10/23,2
+10,test,false,2026-12-12,2
+11,1,false,2026/12/12,1
+12,test,false,2026/12/12,2
+13,test,false,2026/10/23,3
+14,1,false,2026/10/23,2
+14,test,false,2026/10/23,2
+15,2,false,2026/10/23,2
+16,ぱぴこ,false,2026/10/23,2
+17,パピコ,false,2026/10/23,2