Une manière de faire : à chaque fois que tu trouves "l" (le premier caractère de "le"), tu fais une boucle qui va tester si les caractères qui suivent sont bien ceux de la chaîne que tu cherches.

Dasn ton exemple : il trouve le premier l, et vérifie qu'après c'est bien un "e", et c'est le cas -> on ajoute 1 au nombre de "le" trouvés. Ensuite il trouve un autre "l" (celui de nul), il vérifie le caractère après, mais ce n'est pas "e", donc il ne fait rien. Et ensuite il n'y a plus de "l" et la boucle principale s'arrete. -> le résultat final est 1.

Merci pour ta réponse.

Oui c'est bien ça l'idée. Je fais ça mais il y a un souci quelques part. Je vais y arriver.

Une bonne manière est de poser l'algorithme en "mots" sur papier, ça peut aider.

Salut,

L'utilisation de regex (import java.util.regex.*;) répond au 2 questions

Exemple:

   import java.util.regex.*;
   
    public class LaClasse
   {
      private static Pattern pattern;
      private static Matcher matcher;
      private static int nbreDeFois;
      private static String info = "";

  
       public static void regEx(String chaine, String motif) // trouver motif dans chaine
      {
         nbreDeFois = 0;
      
         info = "\nRECHERCHE DU MOTIF \""  + motif + "\""  + " dans la cha\u00eene:\n"
            + "\"" + chaine + "\"\n";
         pattern = Pattern.compile(motif);
         matcher = pattern.matcher(chaine);

         while(matcher.find())
         {
            nbreDeFois++;
            //System.out.println("nbreDeFois: " + nbreDeFois);
         }
         info+= "\n\"" + motif + "\"" + " existe " + nbreDeFois + " fois dans \"" + chaine + "\"\n";
      	
         javax.swing.JOptionPane.showMessageDialog(null,info);
         
      }

       public static void main(String args[])
      {
       
         String chaine = "le nul en Java";
         String motif = "le"; // ce motif est le plus simple d'utilisation
                                // puisqu'il s'agit d'une chaîne littérale
 // appel de la méthode:
         regEx(chaine, motif); //résultat 1

 chaine = "le nul en Java et les nuls";
         motif = "le";
         regEx(chaine, motif); // résultat 2
         
      	// si on ne veut pas le de les nuls:
         chaine = "le nul en Java et les nuls";
         motif = "le ";
         regEx(chaine, motif); //résultat 1
         
         chaine = "Le nul en Java et les nuls";
         motif = "le";
         regEx(chaine, motif); //résultat 1
         
         chaine = "le nul en Java et les nuls";
         motif = ".e"; // ici, le point est un caractère spécial (Méta caractère)
                            // qui signifie que l'on veut recercher "e" précédé
                            // d'UN caractère quelconque (UN puisqu'il n'y a qu'UN point
         regEx(chaine, motif);
         // dans ce cas on trouvera 4 .e
      	// .e de le
      	// .e de en précédé d'un espace
      	// .e de et précédé d'un espace
      	// .e de les précédé d'un espace

//concernant la 1ère question

         chaine = "le nul en Java";
         motif = "a"; 
         regEx(chaine, motif);  Résultat 2
      	.........
      	..........
      	}

String chaine "le nul en java";
String motif = "a";
LaClasse.regEx(chaine, motif);