ファイルから特定の文字列部分を列挙するコード

この記事で何がしたいか?

指定したフォルダから、特定ファイル※の中にある必要な情報のみを取得する。

取得した情報を、テキストファイルでまとめて書き出すプログラムの紹介。

※xxx.logやxxx.txtなどのテキストベースのファイル

実装の目的

同じような作業や反復可能な事はできるだけ自動化したい。

一意の文字列を含んだ実行ログを収集する目的。

実装説明

特定のディレクトリを指定すると、そこから再帰的に情報を引っ張ってきて

テキストベースの文字列にしてくれる。

入力データ条件

テキストファイルであること

拡張子txt/log以外は動作未確認

エンコードはSJISとUTF-8のみ動作確認

データ取得条件

・特定のサフィックスを含む事
条件は実装修正することにより、変更可能
(本コードでは文字列として「★★★」と「userId」を含むこととしている)

実行イメージ

[実行前ファイル]入力サンプルテキスト

[実行結果のエクセル貼り付け]結果の貼り付け状態

ソースコード

実行クラス

package main.executor;

import java.io.File;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;

import main.Clasify;
import main.Prepare;
import main.ReadText;
import main.Registor;
import main.WriterData;
import main.data.ExecTime;

/**
 * 処理実行クラス
 *
 * @author Naoto Wada
 *
 */
public class Executor {

	private static final Logger logger_ = Logger.getLogger("Executor.class");

	// 入力ディレクトリ
	private static final String inputPath = "C:\\Users\\life\\Desktop\\新しいフォルダー";
	// 出力ファイルパス
	private static final String outFilePath = "C:\\Users\\life\\Desktop\\新しいフォルダー (2)\\result.txt";

	/**
	 * mainメソッド
	 *
	 * @param args
	 */
	public static void main(String[] args) {

		logger_.log(Level.INFO, "メイン処理 開始");

		doExec();

		logger_.log(Level.INFO, "メイン処理 終了");
	}

	/**
	 * メイン実行関数.
	 * 各処理を呼び出す
	 */
	private static void doExec() {

		// 読み込み前コンバート処理
		Prepare.readDirectory(inputPath);

		// 読み込み処理
		Map<String, List<String>> textMap = ReadText.readDirectory(new File(inputPath));

		// データ登録処理
		Map<String, ExecTime> execMap = Registor.regist(textMap);

		// データ分類処理
		List<String> resultList = Clasify.clasify(execMap);

		// 取得データの書き出し
		WriterData.writeToText(resultList, outFilePath);
	}
}

前処理クラス

package main;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

import main.constants.SuffixConst;

/**
 * ファイルの読み込み前に事前にエンコードするクラス.
 *
 * @author Naoto Wada
 *
 */
public class Prepare {

    private static final Logger logger_ = Logger.getLogger("Prepare.class");

    /**
     * 入力パスから全てのディレクトリを読み込みする.
     *
     * @param inputPath
     *            入力パス
     */
    public static void readDirectory(String inputPath) {
        logger_.log(Level.INFO, " コンバート処理 開始");
        readDirectory(new File(inputPath));
        logger_.log(Level.INFO, " コンバート処理 終了");
    }

    /**
     * 再帰的に入力ディレクトリの全ファイルをエンコードする.
     * 可能エンコード:UTF-8
     * 対象エンコードファイル:S-JIS
     *
     * @param inputFile
     */
    public static void readDirectory(File inputFile) {

        File[] allInputFiles = inputFile.listFiles();
        if (allInputFiles == null) {
        }

        for (File iterateFile : allInputFiles) {
            if (!iterateFile.exists()) {
                continue;
            }
            if (iterateFile.isDirectory()) {
                readDirectory(iterateFile);
            }

            // UTF-8にコンバートする
            if (iterateFile.isFile()) {
                convertFileUTF8(iterateFile);
            }
        }
    }

    /**
     * 入力ファイルをUTF-8にして変換する.
     * 読み込みが可能である場合は、変換を行わずに処理を終了する.
     *
     * @param inputFile
     *            入力ファイル
     */
    private static void convertFileUTF8(File inputFile) {

        logger_.log(Level.INFO, "  コンバート処理 対象ファイル[" + inputFile.getName() + "] 変換開始");

        boolean hasEncorded = Checker.checkAlreadyEncord(inputFile);
        if (hasEncorded) {
            logger_.log(Level.INFO, "  コンバート処理 対象ファイル[" + inputFile.getName() + "] 変換不要");
            return;
        }
        try {
            convert(inputFile.getAbsolutePath());
        } catch (IOException e) {
            e.printStackTrace();
        }
        logger_.log(Level.INFO, "  コンバート処理 対象ファイル[" + inputFile.getName() + "] 変換終了");

    }

    /**
     * 入力された絶対パスをUTF-8にエンコードする.
     * 変換可能であるファイルはS-JISでエンコードされたファイル.
     *
     * @param absolutePath
     *            入力の絶対パス
     * @throws UnsupportedEncodingException
     *             エンコード不可である場合スローする.
     * @throws FileNotFoundException
     *             対象ファイルが存在しない場合スローする.
     * @throws IOException
     *             入力が異常である場合はスローする.
     */
    private static void convert(String absolutePath)
            throws UnsupportedEncodingException, FileNotFoundException, IOException {

        // UTF-8以外のファイルを読み込み、読み込んだ全行を一時リストへ格納しておく
        // FIXME : SJISのみreadAllLinesで失敗する確認済の為、その他エンコードファイルは上手く書き換え不可
        List<String> beforeList = new ArrayList<>();

        // S-JISのみ対応
        BufferedReader sjisFile = new BufferedReader(
                new InputStreamReader(new FileInputStream(absolutePath), SuffixConst.encordSJIS));
        while (true) {
            String line = sjisFile.readLine();
            if (line == null) {
                break;
            }
            beforeList.add(line);
        }
        // 書き込みするために一度閉じる
        sjisFile.close();

        // UTF-8にして書き込み
        BufferedWriter utf8File = new BufferedWriter(
                new OutputStreamWriter(new FileOutputStream(absolutePath), StandardCharsets.UTF_8));

        for (String before : beforeList) {
            utf8File.write(before);
            utf8File.newLine();
        }
        utf8File.close();
    }
}

ファイル読み込みクラス

package main;

import java.io.File;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * ファイルを読み込みするクラス.
 * 読み込み可能なファイルはUTF-8とする.
 *
 * @author Naoto Wada
 *
 */
public class ReadText {

    private static final Logger logger_ = Logger.getLogger("ReadText.class");

    private static Map<String, List<String>> textMap = new HashMap<>();

    /**
     * 入力ファイルを再帰的に読み込みする.
     *
     * @param inputFile
     *            入力ファイル
     * @return Map<入力ファイル名、ファイルの全テキスト行>
     */
    public static Map<String, List<String>> readDirectory(File inputFile) {

        logger_.log(Level.INFO, " 読み込み処理 開始");
        File[] allInputFiles = inputFile.listFiles();
        if (allInputFiles == null) {
            return textMap;
        }

        for (File iterateFile : allInputFiles) {

            if (!iterateFile.exists()) {
                continue;
            }
            if (iterateFile.isDirectory()) {
                readDirectory(iterateFile);
            }
            if (iterateFile.isFile()) {
                putTextMap(iterateFile);
            }
        }

        logger_.log(Level.INFO, " 読み込み処理 終了");
        return textMap;
    }

    /**
     * 入力ファイル名と全行をフィールドのMapへ格納する.
     * テキストが空の場合は格納せずに処理終了する.
     *
     * @param iterateFile
     *            入力ファイル
     */
    private static void putTextMap(File iterateFile) {

        // 入力ファイルの中身がが空の場合は何も返却されない
        List<String> lineData = FetchData.fetchData(iterateFile);
        if (lineData.isEmpty()) {
            return;
        }

        textMap.put(iterateFile.getAbsolutePath(), lineData);
        logger_.log(Level.INFO, " 読み込み処理 格納完了 対象ファイル[" + iterateFile.getName() + "]");
    }
}

データ取得クラス

package main;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.logging.Level;
import java.util.logging.Logger;

import main.constants.SuffixConst;

/**
 * 入力したファイルや文字列から、条件に従ったデータを取得するクラス.
 *
 * @author Naoto Wada
 *
 */
public class FetchData {

    private static final Logger logger_ = Logger.getLogger("FetchData.class");

    /**
     * 入力ファイルを読み込み、全ての行を1つのリストにして返却
     *
     * @param dir
     * @return
     */
    public static List<String> fetchData(File dir) {

        logger_.log(Level.INFO, "  取得処理 開始");

        List<String> lineData = new ArrayList<>();
        try {
            logger_.log(Level.INFO, "   取得処理 対象ファイル[" + dir.getName() + "]");
            lineData = Files.readAllLines(dir.toPath());

        } catch (IOException e) {
            e.printStackTrace();
        }
        logger_.log(Level.INFO, "  取得処理 終了");
        return lineData;
    }

    /**
     * 入力文字列から、userIDのみを取得する.
     *
     * @param sentence
     *            入力文字列.nullは許容しない
     * @return 入力データのuserId部分
     */
    public static String fetchUserId(String sentence) {

        Objects.requireNonNull(sentence, "fetchUserId sentence:[" + sentence + "]");

        int begin = sentence.indexOf(SuffixConst.userId_) + SuffixConst.userId_.length();
        int end = begin + SuffixConst.userIdLength_;
        return sentence.substring(begin, end);
    }

    /**
     * 入力文字列から、モデル名のみを取得する.
     *
     * @param sentence
     *            入力文字列.nullは許容しない
     * @return 入力データのモデル名部分
     */
    public static String fetchModelName(String sentence) {

        Objects.requireNonNull(sentence, "fetchModelName sentence:[" + sentence + "]");

        int begin = sentence.indexOf(SuffixConst.modelName_) + SuffixConst.modelName_.length();
        int end = sentence.indexOf(SuffixConst.startTime_);
        return sentence.substring(begin, end);
    }

    /**
     * 入力文字列から、経過時間のみを取得する.
     *
     * @param sentence
     *            入力文字列.nullは許容しない
     * @return 入力データの経過時間部分
     */
    public static int fetchDurationTime(String sentence) {

        Objects.requireNonNull(sentence, "fetchDurationTime sentence:[" + sentence + "]");

        int begin = sentence.indexOf(SuffixConst.durationTime_) + SuffixConst.durationTime_.length();
        int end = sentence.indexOf(SuffixConst.milliSeconds_);
        String strDurationTime = sentence.substring(begin, end);
        return Integer.parseInt(strDurationTime);
    }

    /**
     * 入力文字列から時刻取得を行う共通化関数.
     * 入力文字列から、開始条件と終了条件を元にデータを取得する.
     * 条件は呼び出し側で制御する.
     *
     * @param sentence
     *            入力文字列
     * @param beginSuffix
     *            開始条件
     * @param endSuffix
     *            終了条件
     * @return 取得文字列
     */
    public static String fetchTime(String sentence, String beginSuffix, Integer endSuffix) {

        Objects.requireNonNull(sentence, "fetchEndTime sentence:[" + sentence + "]");
        Objects.requireNonNull(sentence, "fetchEndTime sentence:[" + beginSuffix + "]");
        Objects.requireNonNull(sentence, "fetchEndTime sentence:[" + endSuffix + "]");

        int begin = sentence.indexOf(beginSuffix) + beginSuffix.length();
        int end = begin + endSuffix;
        return sentence.substring(begin, end);

    }
}

データ登録クラス

package main;

import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;

import main.constants.SuffixConst;
import main.data.ExecTime;

/**
 * 入力データをユーザーID毎のデータに登録するクラス.
 *
 * @author Naoto Wada
 *
 */
public class Registor {

    private static final Logger logger_ = Logger.getLogger("Registor.class");

    /* Map<userID, ExecTime> . **/
    private static Map<String, ExecTime> execMap_ = new HashMap<>();

    /**
     * 入力データMap<ファイル名、ファイル中テキスト>を、ユーザーID毎のデータに登録する.
     *
     * @param textMap
     *            入力データMap<ファイル名、ファイル中テキスト>
     * @return Map<ユーザーID、各種データ>
     */
    public static Map<String, ExecTime> regist(Map<String, List<String> textMap) {

        logger_.log(Level.INFO, " データ登録処理 開始");
        for (Entry<String, List<String>> linePerFiles : textMap.entrySet()) {

            registExecMap(linePerFiles);
        }
        logger_.log(Level.INFO, " データ登録処理 終了");
        return execMap_;
    }

    /**
     *
     * @param linePerFiles
     */
    private static void registExecMap(Entry<String, List<String>> linePerFiles) {
        logger_.log(Level.INFO, "  データ登録処理 対象ファイル[" + linePerFiles.getKey() + "]");
        // ファイル毎の全行操作
        for (String sentence : linePerFiles.getValue()) {

            // 1行中に対象のサフィックスを含まない場合は次の行を操作する
            boolean canRegist = Checker.checkRegist(sentence);
            if (!canRegist) {
                continue;
            }

            // ユーザーIDが既に存在するかチェック
            String userID = FetchData.fetchUserId(sentence);
            ExecTime execTime = Checker.checkAndThenGenerate(userID, execMap_);

            // ユーザーID登録
            Map<String, Integer> dataMap = setDataMap(execTime, sentence);
            execTime.setModelMap(dataMap);
            execTime.setUserId(userID);

            // 開始時刻、終了時刻登録
            String startTime = FetchData.fetchTime(sentence, SuffixConst.startTime_, SuffixConst.timeLength_);
            String endTime = FetchData.fetchTime(sentence, SuffixConst.endTime_, SuffixConst.timeLength_);
            if (execTime.getStartTime() == null) {
                execTime.setStartTime(startTime);
            }
            execTime.setEndTime(endTime);

            // 重複しないファイル名登録
            Set<String> fileNameList = execTime.getFileNameSet();
            if (fileNameList == null) {
                fileNameList = new HashSet<>();
            }
            fileNameList.add(linePerFiles.getKey());
            execTime.setFileNameSet(fileNameList);

            execMap_.put(userID, execTime);
        }
    }

    /**
     * 入力データのExecTime.DataMap<モデル名, 実行時間>を入力文字列から各データを取り出し登録する.
     * モデル名が重複している場合は上書きする.
     *
     * @param execTime
     *            入力データ
     * @param sentence
     *            入力文字列
     * @return DataMap<モデル名, 実行時間>
     */
    private static Map<String, Integer> setDataMap(ExecTime execTime, String sentence) {
        String modelName = FetchData.fetchModelName(sentence);
        int durationTime = FetchData.fetchDurationTime(sentence);
        Map<String, Integer> dataMap = execTime.getModelMap();
        dataMap.put(modelName, durationTime);
        return dataMap;
    }
}

データ分類クラス

package main;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import main.data.ExecTime;

/**
 * 入力データを条件により分類して返却するクラス.
 *
 * @author Naoto Wada
 *
 */
public class Clasify {

    /**
     * 入力されたデータを、各キー事のデータとして1行にまとめる.
     * エクセルのセルに張り付ける事を目的とする為、各データごとは[Tab]で繋げ、次のキーまで1行データとする
     * 最初の1行は各項目の名称を期待する
     *
     * 出力例)
     * 1行目:[項番\t  ID \t 開始時刻 \t 終了時刻 \t model1 \t model2 \t … \t 対象ファイル \r\n]
     * 2行目:[  1 \t xxx \t 20181010 \t 20181011 \t model1 \t model2 \t … \t c:\\xxx.txt  \r\n]
     * ※ホワイトスペースは混入しない
     *
     * @param execMap
     * 入力データマップ<ID, オブジェクト>
     * @return 出力例を行毎に1つの要素として返却
     */
    public static List<String> clasify(Map<String, ExecTime> execMap) {

        // 最初の1行目を作成
        List<String> resultList = new ArrayList<>();
        resultList.add(LineCreator.createFirstLineCell());

        // 残りの行を全て作成
        List<String> clasifiedList = clasifyExecMap(execMap);
        resultList.addAll(clasifiedList);

        return resultList;
    }

    /**
     * 入力データの各キー事の文字列行を作成する.
     *
     * 出力例)
     * 対象データ[rowCnt \t userId \t startTime \t endTime  \t modelName \t … \t fileName   ]
     * 出力例    [ 1     \t xxxxxx \t 20181010  \t 20181011 \t model1    \t … \t c:\\xxx.txt]
     * ※ホワイトスペースは混入しない
     *
     * @param execMap
     *            入力データ
     * @return 出力例を行毎に1つの要素として返却
     */
    private static List<String> clasifyExecMap(Map<String, ExecTime> execMap) {

        int rowCnt = 0;
        List<String> clasifiedList = new ArrayList<>();
        for (Entry<String, ExecTime> execEntry : execMap.entrySet()) {
            StringBuilder line = new StringBuilder();

            // 項番 部分
            rowCnt++;
            line.append(LineCreator.createRowCell(rowCnt));

            // ユーザーID 部分
            String userId = execEntry.getKey();
            line.append(LineCreator.createIdCell(userId));

            // 開始時刻と終了時刻 部分
            ExecTime execTime = execEntry.getValue();
            line.append(LineCreator.createStartCell(execTime));
            line.append(LineCreator.createEndCell(execTime));

            // カテゴリー 部分
            line.append(LineCreator.createCategoryCell(execTime));

            // 対象ファイル 部分
            line.append(LineCreator.createFileNameCell(execTime));
            clasifiedList.add(line.toString());
        }
        return clasifiedList;
    }
}

判定クラス

package main;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.util.Map;

import main.constants.SuffixConst;
import main.data.ExecTime;

/**
 * 入力データの内容を元に、各種関数内の条件で判定処理を行うクラス.
 *
 * @author Naoto Wada
 *
 */
public class Checker {

    /**
     * 入力した文章が登録可能かどうか判定する.
     * 入力文章がnullである場合はNullpointerExceptionが発生する.
     *
     * [登録条件]
     * 下記サフィックスを含んでいる事.
     * ①"★★★"
     * ②"userId"
     *
     * ex)入力[★★★ userId:xxx]:return true
     * ex)入力[★★ userID:xxx  ]:return false
     *
     * @param sentence
     *            入力文字列.nullである場合はNullpointerExceptionをthrowする.
     * @return true(登録可)/false(登録不可)
     */
    public static boolean checkRegist(String sentence) {

        // 1行に対象文字列を含んでいない場合はfalseを返却
        boolean isContainSuffix = checkRegex(sentence, SuffixConst.star_);
        boolean isContainsId = checkRegex(sentence, SuffixConst.userId_);

        if (isContainSuffix && isContainsId) {
            return true;
        }
        return false;
    }

    /**
     * 入力された文章にサフィックスが含まれているか判定する.
     *
     * @param sentence
     *            入力された文章
     * @param suffix
     *            サフィックス
     * @return true(含んでいる)/false(含んでいない)
     */
    private static boolean checkRegex(String sentence, String suffix) {
        if (sentence.contains(suffix)) {
            return true;
        }
        return false;
    }

    /**
     * 入力キーがMapから取得できる場合はそのバリューを返却する.
     * バリューが取得できなかった場合はそのバリューを生成して返却する
     *
     * @param userID
     * 入力キー
     * @param execMap
     * 取得対象Map
     * @return 新規生成、またはMapから取得したバリュー
     */
    public static ExecTime checkAndThenGenerate(String userID, Map<String, ExecTime> execMap) {
        ExecTime execTime = execMap.get(userID);
        if (execTime == null) {
            execTime = new ExecTime();
        }
        return execTime;
    }

    /**
     * 入力ファイルのエンコードが読み込み可能か検査する.
     * 読み込み不可能な場合、Files.readAllLinesで発生したExceptionをキャッチしてfalseを返却する.
     *
     * @param inputFile
     * 読み取り可能か判定するファイル
     * @return true(読み取り可能)/false(読み取り不可)
     */
    public static boolean checkAlreadyEncord(File inputFile) {
        try {
            Files.readAllLines(inputFile.toPath());
        } catch (IOException e) {
            // スロー等はさせない
            return false;
        }
        return true;
    }
}

行生成クラス

package main;

import java.util.Map;

import main.constants.SuffixConst;
import main.data.ExecTime;
import main.enums.ModelEnum;

/**
 * 入力データを元に文字列を作成するクラス.
 *
 * @author Naoto Wada
 *
 */
public class LineCreator {

    /**
     * カテゴリー名を示す行を生成する.
     *
     * @return 生成文字列
     */
    public static String createFirstLineCell() {
        StringBuilder sb = new StringBuilder();
        appendAndTab(sb, SuffixConst.cate_rowNum_);
        appendAndTab(sb, SuffixConst.cate_userId_);
        appendAndTab(sb, SuffixConst.cate_startTime_);
        appendAndTab(sb, SuffixConst.cate_endTime_);
        sb.append(createModelCells());
        appendAndTab(sb, SuffixConst.cate_fileName_);
        return sb.toString();
    }

    /**
     * カテゴリー部分をenumから取得して全て生成する.
     * カテゴリー部分を追加したい場合、enum定義を追加する
     *
     * @return カテゴリー部分の文字列
     */
    private static Object createModelCells() {
        StringBuilder sb = new StringBuilder();
        for (ModelEnum enumModelName : ModelEnum.values()) {
            appendAndTab(sb, enumModelName.toString());
        }
        return sb.toString();
    }

    /**
     * 入力項番から項番部分を生成する.
     *
     * @param rowCnt
     *            入力項番
     * @return 項番部分の文字列
     */
    public static String createRowCell(int rowCnt) {
        return makeSuffixAndTab(rowCnt);
    }

    /**
     * 入力項番からユーザーID部分を生成する.
     *
     * @param userId
     *            入力ユーザーID
     * @return ユーザーID部分の文字列
     */
    public static String createIdCell(String userId) {
        return makeSuffixAndTab(userId);
    }

    /**
     * 入力データからカテゴリー部分を生成する.
     * 各カテゴリーが存在する場合のセルに値を挿入し、存在しない場合は空セルとする.
     *
     * @param exec
     *            入力データ
     * @return カテゴリー部分の文字列
     */
    public static String createCategoryCell(ExecTime exec) {

        StringBuilder sb = new StringBuilder();
        for (ModelEnum enumModelName : ModelEnum.values()) {
            Map<String, Integer> modelMap = exec.getModelMap();
            Integer execTime = modelMap.get(enumModelName.toString());

            if (execTime == null) {
                sb.append(SuffixConst.tab_);
                continue;
            }
            appendAndTab(sb, execTime);
        }
        return sb.toString();
    }

    /**
     * 入力データからファイル名部分を生成する.
     * 1つのユーザーIDに紐づく複数のファイルがある場合は、1つのセルに複数行記載する.
     *
     * @param exec
     *            入力データ
     * @return ファイル名部分の文字列
     */
    public static String createFileNameCell(ExecTime exec) {

        StringBuilder sb = new StringBuilder();
        sb.append(SuffixConst.doubleQuotation_);
        int loopCnt = 0;
        for (String fileName : exec.getFileNameSet()) {
            loopCnt++;
            if (exec.getFileNameSet().size() == loopCnt) {
                sb.append(fileName);
                break;
            }
            sb.append(fileName);
            sb.append(SuffixConst.enter_);
        }
        sb.append(SuffixConst.doubleQuotation_);
        return sb.toString();
    }

    /**
     * 入力データから開始時刻部分を生成する.
     *
     * @param execTime
     *            入力データ
     * @return 開始時刻の文字列
     */
    public static String createStartCell(ExecTime execTime) {
        return makeSuffixAndTab(execTime.getStartTime());
    }

    /**
     * 入力データから終了時刻部分を生成する.
     *
     * @param execTime
     *            入力データ
     * @return 終了時刻の文字列
     */
    public static String createEndCell(ExecTime execTime) {
        return makeSuffixAndTab(execTime.getEndTime());
    }

    /**
     * 入力の文字列に、サフィックスと[\t]を追加する.
     *
     * @param sb
     *            入力文字列
     * @param suffix
     *            追加するサフィックス
     */
    private static void appendAndTab(StringBuilder sb, Object suffix) {
        sb.append(suffix);
        sb.append(SuffixConst.tab_);
    }

    /**
     * 文字列を新規生成し、サフィックスと[\t]を追加して返却する.
     *
     * @param suffix
     *            追加するサフィックス
     * @return 生成した文字列
     */
    private static String makeSuffixAndTab(Object suffix) {
        StringBuilder sb = new StringBuilder();
        sb.append(suffix);
        sb.append(SuffixConst.tab_);
        return sb.toString();
    }
}

ファイル書き込みクラス

package main;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * 入力データを受け取り、入力されたファイルへ書き込みを行うクラス.
 *
 * @author Naoto Wada
 *
 */
public class WriterData {

    private static final Logger logger_ = Logger.getLogger("WriterData.class");

    /**
     * 入力された文字列リストを、入力ファイルに書き出しを行う.
     * 書き込む対象ファイルに常に新規書き込みする.
     * また、書き込み対象ファイルが実行時に開いてる場合は書き込みに失敗する.
     *
     * @param resultList
     *            入力文字列
     * @param outFilePath
     *            書き込み対象ファイル
     */
    public static void writeToText(List<String> resultList, String outFilePath) {

        logger_.log(Level.INFO, " データ書き出し処理 開始");

        write(resultList, outFilePath);

        logger_.log(Level.INFO, " データ書き出し処理 終了");
    }

    /**
     * 入力された文字列リストを、入力ファイルに書き出しを行う.
     *
     * @param resultList
     *            入力文字列
     * @param outFilePath
     *            書き込み対象ファイル
     */
    private static void write(List<String> resultList, String outFilePath) {

        File file = new File(outFilePath);
        Path path = file.toPath();
        try {
            Files.write(path, resultList);
            logger_.log(Level.INFO, "  データ書き出し対象 対象ファイル[" + file.getAbsolutePath() + "]");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

定数クラス

package main.constants;

/**
 * 定数クラス.
 *
 * @author Naoto Wada
 *
 */
public class SuffixConst {

    /**
     * エンコード用
     */
    /* S-JISエンコード. **/
    public static final String encordSJIS = "Shift-JIS";
    /* UTF-8エンコード. **/
    public static final String encordUTF8 = "utf8";

    /**
     * サフィックス群
     */
    /* 処理の実行条件. **/
    public static final String star_ = "★★★";
    /* 処理の実行条件. **/
    public static final String userId_ = "userId:";
    /* フェッチする際のユーザーIDの長さ. **/
    public static final int userIdLength_ = 17;
    /* 実行時間をフェッチする際の条件. **/
    public static final String durationTime_ = "durationTime:";
    /* 実行時間をフェッチする際の条件. **/
    public static final String milliSeconds_ = " ms";
    /* モデル名をフェッチする際の条件とカテゴリー名. **/
    public static final String modelName_ = "DataModel:";
    /* 開始時間をフェッチする際の開始条件. **/
    public static final String startTime_ = " startTime:";
    /* 終了時間をフェッチする際の開始条件. **/
    public static final String endTime_ = " endTime:";
    /* 開始・終了時間をフェッチする際の終了条件. **/
    public static final int timeLength_ = 25;

    /**
     * 汎用サフィックス群
     */
    public static final String tab_ = "\t";
    public static final String enter_ = "\r\n";
    public static final String doubleQuotation_ = "\"";

    /**
     * カテゴリー専用サフィックス群
     */
    /* カテゴリー区分の項番部分. **/
    public static final String cate_rowNum_ = "項番";
    /* カテゴリー区分のID部分. **/
    public static final String cate_userId_ = "ユーザーID";
    /* カテゴリー区分の開始時刻部分. **/
    public static final String cate_startTime_ = "ID毎 開始時刻";
    /* カテゴリー区分の終了時刻部分. **/
    public static final String cate_endTime_ = "ID毎 終了時刻";
    /* カテゴリー区分の該当ファイル部分. **/
    public static final String cate_fileName_ = "該当ファイル";

}

データオブジェクトクラス

package main.data;

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

/**
 * データ取り扱い用クラス
 * フィールド:String 				userId 
 * フィールド:Map<String, Integer>     	modelMap 
 * フィールド:Set<String>			fileNameSet 
 * フィールド:String				startTime
 * フィールド:String				endTime
 *
 * @author Naoto Wada
 *
 */
public class ExecTime {

    /**
     * フィールド部分
     */
    /* ユーザーID . **/
    private String userId = "";

    /* Map<カテゴリ名、数値>. **/
    private Map<String, Integer> modelMap = new HashMap<>();

    /* 対象ファイル名リスト. **/
    private Set<String> fileNameSet;

    /* 開始時刻. **/
    private String startTime;

    /* 終了時刻. **/
    private String endTime;

    /**
     * 以下ゲッターセッター
     */
    public String getStartTime() {
        return startTime;
    }

    public void setStartTime(String startTime) {
        this.startTime = startTime;
    }

    public String getEndTime() {
        return endTime;
    }

    public void setEndTime(String endTime) {
        this.endTime = endTime;
    }

    public Map<String, Integer> getModelMap() {
        return modelMap;
    }

    public void setModelMap(Map<String, Integer> modelMap) {
        this.modelMap = modelMap;
    }

    public void setFileNameSet(Set<String> fileNameSet) {
        this.fileNameSet = fileNameSet;
    }

    public Set<String> getFileNameSet() {
        return fileNameSet;
    }

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

}

データオブジェクト列挙型クラス

package main.enums;

/**
 * データモデル列挙型
 *
 * @author Naoto Wada
 *
 */
public enum ModelEnum {

    model1, model2, model3, model4, model5, model6, model7,;
}

改善点や解説等は今後行おうと思う。
基本的にはテキストファイルの再帰読み込みと、文字列の単純操作のみで構成されている。

シェアする

  • このエントリーをはてなブックマークに追加

フォローする