Find matches between JAVA Strings

I think this can help you:

package cm;

/**
 *
 * @author Paolo Rios Garaundo
 */
public class Temp {

    public static void main(String[] args) {
        final String cadena1 = "cadenaxyuiop";
        final String cadena2 = "qwertcadenaxqwert";
        final String cadena3 = "asdfghcadenax";
        final String cadena4 = "cadenaxPorPaolo";

        final String[] cadenas = {cadena1, cadena2, cadena3, cadena4};
        String coincidencia = "";
        String coincidenciaFinal = "";

        for (int i = 1; i < cadenas.length; i++) { // no es necesario comprobar la primera cadena

            if (!(coincidencia.length() > 0)) {
                final String cadena = cadenas[i];
                final String cadenaAnterior = cadenas[i - 1];

                for (int z = 0; z < cadenaAnterior.length(); z++) { // se recorre la cadena anterior
                    final String caracterEvaluar = String.valueOf(cadenaAnterior.charAt(z));

                    // se hace la comprobacion de coincidencias
                    if (coincidencia.equals(cadena)) { 
                        if (cadena.contains(coincidencia)) {
                            coincidencia += caracterEvaluar;
                        }
                    } else {
                        if (cadena.contains(caracterEvaluar)) {
                            coincidenciaFinal += caracterEvaluar;
                            coincidencia = caracterEvaluar;
                        }
                    }
                }
            }
        }

        System.out.println("Coincidencia: " + coincidenciaFinal);
    }
}

Basically what this code does is to separate the first string in parts from 4 characters forward making use of a regular expression (?<=\G.{" + numerodecaracteres+ "}) having those parts using the method contains of the String class. yes that part is in the other two chains is printed.

String One, Two, Three;
System.out.print("Ingrese cadena de aminoacidos numero 1: ");
One= leer.nextLine();

System.out.print("Ingrese cadena de aminoacidos numero 2: ");
Two= leer.nextLine();

System.out.print("Ingrese cadena de aminoacidos numero 3: ");
Three= leer.nextLine();
List<String> repeats= new ArrayList<>();
for (int i = 0; i < One.length(); i++) { 
    for (int j = 4; j < One.length(); j++) {
        String[] parts = One.substring(i,One.length()).split("(?<=\G.{" + j + "})");
        String part= parts[0];
        if(part.length()<4) break;
        if(Two.contains(part) && Three.contains(part)){
            if(!repeats.contains(part)) repeats.add(part);
        }
   }
}

An alternative assuring maximum size matches for n Strings

import java.util.ArrayList;
import java.util.Iterator;


public class StringFind {

    private String[] strings;

    public StringFind(String... strings){
        this.strings=strings;
    }

    private String match(String string){
        // buscar string en strings[1]-strings[length-1];
        int found = 1;
        for (int i = 1; i<strings.length; i++){
            if (strings[i].contains(string)) found++;
        }
        return (found == strings.length) ? string : null;
    }

    public ArrayList<String> getMatches(){
        ArrayList<String> list = new ArrayList<String>();
        String lastMatch="";
        // recorrer substrings desde 0
        for (int i = 0; i<strings[0].length()-4; i++){
            String resto = strings[0].substring(i);
            // buscar substring hasta minimo tamaño 4
            for (int j = resto.length(); j>3; j--){
                // buscar en otras cadenas
                String match = match(resto.substring(0, j));
                // ignorar si es parte del ultimo resultado agregado
                if (match!=null && !lastMatch.contains(match) ){
                    // recordar y agregar
                    lastMatch=match;
                    list.add(match);
                }
            }
        }
        return list;
    }

    public static void main(String[] args) {
        StringFind sf = new StringFind("holaxxxxxxamigo", "amigottttttttthola", "ggggggggholagamigo");
        ArrayList<String> list = sf.getMatches();
        Iterator i = list.iterator();
        while(i.hasNext()){
            System.out.println(i.next());
        }

    }

}

Exit:

hola
amigo

The problem you want to solve is called Longest common substring (LCS) (do not confuse with Longest Common Subsequence . An algorithm to do this looks like the following:

(I modified some parts to show all matches)

public class Main {

    public static void main(String[] args) {
        String s1 = "holaxperrxquetlssaxxxxamigos";
        String s2 = "amigottttquetlssatttttperrholas";

        System.out.println(allLongestCommonSubstring(s1, s2));
    }

    private static ArrayList allLongestCommonSubstring(String s1, String s2) {
        ArrayList<String> palabras = new ArrayList<>();

        ciclo:
        // recorrer caracter por caracter el string "s1"
        for (int i = 0, ilargo = s1.length(); i < ilargo; i++) {
            // para cada caracter de "s1" recorrer todos los de "s2"
            for (int j = 0, jlargo = s2.length(); j < jlargo; j++) {

                // contador de maximo
                int max = 0;

                // comparar "s1" frente a "s2" para encontrar la palabra
                while (s1.charAt(i + max) == s2.charAt(j + max)) {

                    // por cada coincidencia aumentar el maximo
                    max++;

                    // pero si el maximo excede el largo de algunos de los strings, romper el ciclo
                    if ((i + max >= ilargo) || (j + max >= jlargo)) {
                        break;
                    }
                }

                // si la cantidad de coincidencias es mayor que 3
                if (max > 3) {
                    // obtener la cadenas desde i hasta donde terminan de coincidir (i+max)
                    palabras.add(s1.substring(i, (i + max)));

                    if (i + max >= ilargo) {
                        // si está al final, saltar los caracteres que quedan y romper el ciclo
                        break ciclo;
                    } else {
                        // si no, saltar la palabra encontrada
                        i += (i + max < ilargo) ? max : 0;
                    }
                }
            }
        }

        return palabras;
    }
}

You can see more implementations on the Wiki .