Wyrażenia regularne

for(String s : tablica_stringow) {
    ...
}

{  "abcde" , "bdace" , "ecdba" , "thg" , "htg" ,  "abc"  }  -->  {  "3abcde" , "2ght"  ,  "abc"  }

import java.util.HashMap;
import java.util.ArrayList;
import java.util.Arrays;

class Counter 
{
    public static String sort(String s) 
    { 
        char temp_array[] = s.toCharArray(); 
        Arrays.sort(temp_array); 
        return new String(temp_array); 
    } 
    
	static boolean isPermutation(String s1, String s2) 
	{	
		return sort(s1).equals(sort(s2));
	}
	
    public static HashMap<String, Integer> count (ArrayList<String> entry, ArrayList<String> targ) 
    {	
		HashMap<String, Integer> counter = new HashMap<>();
        for (String s : entry) 
        {
			for (String t : targ)
			{
				
				if (isPermutation(s, t))
				{
					if (counter.containsKey(s))
					{
						int val = counter.get(s);
						counter.put(s, val + 1);
					}
					else
					{
						counter.put(s, 1);
					}
				}
			}
		}
        return counter;
    }
    public static void main (String [] args) 
    {
		ArrayList<String> initial_list = new ArrayList<>(Arrays.asList("abcde", "ght", "abc"));
		ArrayList<String> target_list = new ArrayList<>(Arrays.asList( "abcde" , "bdace" , "ecdba" , "thg" , "htg" ,  "abc" ));
		
		System.out.println(count(initial_list, target_list)); // -> {ght=2, abc=1, abcde=3}
	}
}

Function<String, String> sort = s -> s.chars().sorted().collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append).toString();
Function<Map.Entry<String, List<String>>, String> format = kv -> kv.getValue().size() + kv.getKey();
Stream.of(tablica_stringow).collect(Collectors.groupingBy(sort)).entrySet().stream().map(format).forEach(System.out::println);

public class Fraction {

    public List<FractionPair> numerator;
    public List<FractionPair> denominator;
    private static ListList<FractionPair> tmp_list = new ArrayList<FractionPair>();

    public Fraction() {
        numerator = new ArrayList<FractionPair>();
        denominator = new ArrayList<FractionPair>();
    }
    private static void loop(List<FractionPair> L1, List<FractionPair> L2) {
        tmp_list.clear();
		
        for(FractionPair i : L1) {
            for(FractionPair j : L2) {
                tmp_list.add(i.mul(j));
            }
        }
    }
    public Fraction add(Fraction val) {
        Fraction result = new Fraction();
		
        loop(this.numerator, scnd.denominator);
        result.numerator = new ArrayList<FractionPair>(tmp_list);
		
        loop(scnd.numerator, this.denominator);
        result.numerator.addAll(tmp_list);
		
        loop(this.denominator, scnd.denominator);
        result.denominator = new ArrayList<FractionPair>(tmp_list);
        tmp_list.clear();
		
        result.simplify();
        return result;
    }
    private void simplify() {
    	TUTAJ POJAWIA SIĘ PROBLEM
    }
}

class FractionPair {
	
	public BigInteger  number_num;
	public String      number_str;
	
	public FractionPair() {
		
	}
	public FractionPair mul(FractionPair scnd) {
		FractionPair result = new FractionPair();
		
		result.number_num = this.number_num.multiply(scnd.number_num);
		result.number_str = this.number_str.concat("*" + scnd.number_str);
		
		return result;
	}
}

F1:
	numerator: { (12, "z_1") , (5, "b") }
	denominator: { (1, "c") , (-4, "d") }

F2:
	numerator: { (10, "ZM_2") , (7, "G") }
	denominator: { (1, "t") , (99, "A_2") }

F3 = F1.add(F2):
	numerator: { (12,"z_1*t"),(1188,"z_1*A_2"),(5,"b*t"),(495,"b*A_2"),(10,"ZM_2*c"),(-40,"ZM_2*d"),(7,"G*c"),(-28,"G*d") }
	denominator: { (1, "c*t") , (99, "c*A_2") , (-4, "d*t") , (-396, "d*A_2") } 

Taki wynik otrzymuję obecnie, gdzie nawias oznacza element listy: (number_num, number_str)

{ (10,"ZM_C*a*b") , (-8,"b*ZM_C*a") } --> { (2,"a*b*ZM_C") } lub { (2,"b*a*ZM_C") } lub { (2,"ZM_C*b*a") } itd. - kolejność wyrazów "zwiniętych" nie ma znaczenia