Javaでのアナグラム・置き換え処理を改善(早く)したい

Question

前提・実現したいこと

以前に 入力された文を、母音が一緒の文字に入れ替えたい で回答していただいた事や調べた事をまとめて、文字列をアナグラム・同じ段（例 てはえ段）にある文字で置き換えをするコードを書いたのですが、実際に処理をする際は文字列が10文字以上になる事が多く、実行時間がとても長くなります。
他に同じようなコードがあまり無いため、処理の時間が適正なのかそうでないのか分からないのですが、改善点などありましたら回答をお願いしたいです。

発生している問題・エラーメッセージ

処理に時間がかかる原因（無駄な処理など）を減らしたい

該当のソースコード

import java.io.*;
import java.nio.file.*;
import java.util.*;

public class AmRt{
    public static void main(String args[]){
        Sakusei("てらている", "テラテイル");
    }
    
    public static void Sakusei(String Target, String FileName){
        String Ans = "";
        String Indicate = "";
        String FilePath = "/home/lucky/Test/";
        ArrayList<String> List = new ArrayList<String>();
        Pn(Target, Ans, Indicate, FilePath, FileName, List);
        Rt(Target, Ans, Indicate, FilePath, FileName, List);
    }

    
    public static void Pn(String Pq, String PAns, String PIn, String PFP, String PFN, ArrayList PLi){
        PFN = ("アナグラム_ひらがな_" + PFN + ".txt");
        FileDeletionMaking(PFP, PFN);
        Permutation(Pq, PAns, PIn, PFP, PFN, PLi);
    }
    
    public static void Permutation(String Pq, String Pans, String PIn, String PFP, String PFN, ArrayList PLi){
        if(Pq.length()<=1){
            PIn = Pans + Pq;
            PLi.add(PIn);
            if(PLi.size() == 1000000){
                FileWriting(PFP, PFN, PLi);
            }
        }else{
            for(int Pa=0; Pa<Pq.length(); Pa++){
                Permutation(Pq.substring(0, Pa) + Pq.substring(Pa+1), Pans + Pq.charAt(Pa), PIn, PFP, PFN, PLi);
            }
        }
        FileWriting(PFP, PFN, PLi);
    }

    
    public static void Rt(String Rq, String RAns, String RIn, String RFP, String RFN, ArrayList RLi){
        RFN = "置き換え_ひらがな_" + RFN + ".txt";
        FileDeletionMaking(RFP, RFN);
        Replacement(Rq, RAns, RIn, RFP, RFN, RLi);
    }

    public static void Replacement(String Rq, String Rans, String RIn, String RFP, String RFN, ArrayList RLi){
        final String[] RHi = {
            "あかさたなはまやらわ",
            "いきしちにひみりゐ",
            "うくすつぬふむゆる",
            "えけせてねへめれゑ",
            "おこそとのほもよろを",
            "ん",
            "がざだば",
            "ぎじぢび",
            "ぐずづぶ",
            "げぜでべ",
            "ごぞどぼ",
            "ぱ",
            "ぴ",
            "ぷ",
            "ぺ",
            "ぽ",
            "ぁゃゎ",
            "ぃ",
            "ぅゅ",
            "ぇ",
            "ぉょ",
            "っ"
        };
        
        for (int Ri = 0; Ri < Rq.length(); Ri++) {
            int Rj = getDan(Rq.charAt(Ri), RHi);
        }
        char[] Rca = new char[Rq.length()];
        gen(0, Rq, Rans, RHi, Rca, RFP, RFN, RLi);
        FileWriting(RFP, RFN, RLi);
    }

    public static int getDan(char Rc, String[] RHi) {
        for (int Rx = 0; Rx < RHi.length; Rx++){
            if (RHi[Rx].indexOf(Rc) >= 0){
                return Rx;
            }
        }
        return -1;
    }
    
    public static void gen(int R, String Rq, String Rans, String[] RHi, char[] Rca, String RFP, String RFN, ArrayList RLi) {
        int Rj = 0;
        int Rk = 0;
        if (R == Rq.length()){
            Rans = new String(Rca);  
            RLi.add(Rans);
            if(RLi.size() == 1000000){
                FileWriting(RFP, RFN, RLi);
            }
        } else {
            Rj = getDan(Rq.charAt(R), RHi);
            Rk = RHi[Rj].length();
            for (int Ry = 0; Ry < Rk; Ry++) {
                Rca[R] = RHi[Rj].charAt(Ry);
                gen(R+1, Rq, Rans, RHi, Rca, RFP, RFN, RLi);
            }
        }
    }



    public static void FileDeletionMaking(String DMP, String DMN){
        try{
            if(Files.exists(Paths.get(DMP, DMN))){
                Files.delete(Paths.get(DMP, DMN));
            }
            Files.createFile(Paths.get(DMP, DMN));
        }catch(IOException ex){
            ex.printStackTrace();
        }
    }

    public static void FileWriting(String FWP, String FWN, ArrayList FWL){
        try{
            Files.write(Paths.get(FWP, FWN), FWL, StandardOpenOption.APPEND);
        }catch(IOException ey){
            System.out.println("FWP=" + FWP + ", FWN=" + FWN);
        }
        FWL.clear();
    }
}

試したこと

・アナグラムや置き換えを行った結果を1回ずつ書き込むのではなく、リストに格納し あとからまとめて書き込むように変えた
・処理結果の文字列を表示させなくした

補足情報（FW/ツールのバージョンなど）

Oracle VirtualBox Ver.6.1.12
CentOS 7.5.1804

Comments

[YT0014]

このアナグラムソフトが動くことだけが重要で、javaの作法などには興味がない、という前提でよろしいでしょうか？
あまりにも、一般的な作法から逸脱しているので、確認をさせてください。

[777_superlucky]

個人で使う物のため、ファイルに実行結果が保存されれば良いのですが、一般的な作法も教えていただければ勉強になり 嬉しいです。

[YT0014]

javaのコーディング規約の一例
https://future-architect.github.io/coding-standards/documents/forJava/Java%E3%82%B3%E3%83%BC%E3%83%87%E3%82%A3%E3%83%B3%E3%82%B0%E8%A6%8F%E7%B4%84.html

Answer 1

支配的な時間がかかるのは、ファイル出力だと思うので、どう頑張っても結果的に似たような速度になると思います。
下のコードはそんなに速くもないし、汚く、保守しにくくなっているのですが、以下の視点で変更しています。

• ループの中でオブジェクトの生成をなるべくせず、なるべくプリミティブな型で済ませる
• 極端なケースや環境によってはスタックが心配になる場合もあるので、再帰呼び出しをループに変える
• 本当に急ぎたいときはメソッドを細かく分けない(分けても速い場合もあります)
• スレッドやプロセスなどを使い、処理を並列化し、処理系の性能を使い切る(要件次第)

ちなみに下記コードは以下の問題もあります。

• 出力を一定数溜め込んでから書き込む処理を消した
• 1文字の単語に対応していない
• 非同期I/Oをやめた
• 例外処理を消した

ただし、出力先を/dev/null(unix系の場合)とかにすればごくごく僅かに速度向上を見る事ができます。

import java.io.*;

public class AmRt {
	public static void main(String args[]) throws IOException {
		permutate("てらている", "permutate.txt");
		replace("てらている", "replace.txt");
	}

	private static String newLine = System.lineSeparator();

	private static void permutate(final String word, final String filename) throws IOException {
		// 入力文字列の長さ
		final int wordLength = word.length();
		// 順列出力時のN文字目が残りの文字の何番目かを保持する
		int[] permutationIndexesOfRest = new int[wordLength];
		// 順列出力時に元文字列のN文字目が出力済みかどうかを保持する
		boolean[] originalStringIsOutputted = new boolean[wordLength];
		
		for (int i = 0; i < wordLength; ++i) {
			permutationIndexesOfRest[i] = 0;
		}
		
		Writer out = new BufferedWriter(new FileWriter(filename));
		while (true) {
			for (int i = 0; i < wordLength; ++i) {
				originalStringIsOutputted[i] = false;
			}
			for (int i = 0; i < wordLength; ++i) {
				for (int j = 0, index = 0; j < wordLength; ++j) {
					if (! originalStringIsOutputted[j]) {
						if (index == permutationIndexesOfRest[i]) {
							originalStringIsOutputted[j] = true;
							out.write(word.charAt(j));
							break;
						} else {
							++index;
						}
					}
				}
			}
			out.write(newLine);
			boolean breakable = true;
			for (int i = wordLength - 1; i >= 0; --i) {
				if (permutationIndexesOfRest[i] < wordLength - i - 1) {
					++permutationIndexesOfRest[i];
					breakable = false;
					break;
				} else {
					permutationIndexesOfRest[i] = 0;
				}
			}
			if (breakable)
				break;
		}
		out.close();
	}
	
	private static void replace(final String word, final String filename) throws IOException {
		// 入力文字列の長さ
		final int wordLength = word.length();
		// 同子音の分類
		final String[] classified = { "あかさたなはまやらわ", "いきしちにひみりゐ", "うくすつぬふむゆる", "えけせてねへめれゑ", "おこそとのほもよろを", "ん", "がざだば", "ぎじぢび",
				"ぐずづぶ", "げぜでべ", "ごぞどぼ", "ぱ", "ぴ", "ぷ", "ぺ", "ぽ", "ぁゃゎ", "ぃ", "ぅゅ", "ぇ", "ぉょ", "っ" };
		// 元の文字列のN文字目が何番目の同子音グループに属するかを保持する
		int[] originalCharToClassified = new int[wordLength];
		// 同子音でずらして出力する際、N文字目の文字がグルーブの何番目の文字を出力するかを保持する
		int[] classifiedIndexes = new int[wordLength];

		for (int i = 0; i < wordLength; ++i) {
			char ch = word.charAt(i);
			for (int j = 0; j < classified.length; ++j) {
				int index = classified[j].indexOf(ch);
				if (index >= 0) {
					originalCharToClassified[i] = j;
					break;
				}
			}
		}

		Writer out = new BufferedWriter(new FileWriter(filename));
		for (int i = 0; i < wordLength; ++i) {
			classifiedIndexes[i] = 0;
		}
		while (true) {
			for (int i = 0; i < wordLength; ++i) {
				out.write(classified[originalCharToClassified[i]].charAt(classifiedIndexes[i]));
			}
			out.write(newLine);
			boolean breakable = true;
			for (int i = wordLength -1; i >= 0; --i) {
				if (classified[originalCharToClassified[i]].length() > ++classifiedIndexes[i]) {
					breakable = false;
					break;
				} else {
					classifiedIndexes[i] = 0;
				}
			}
			if (breakable) break;
		}
		out.close();
	}
}

Comments

[777_superlucky]

回答ありがとうございました。
試してみたところ、動作が早くなりました