Wyszukiwanie jednego stringa w drugim

Mama problem z pewnym programem chodzi o sprawdzenie na jakim miejscu w pierwszym stringu znajduje sie drugi(może być kilka razy).Wszystko działa ale wyświetla mi za duzo.
przykładowe wejścia, prawidłowe wyjścia i moje wyjścia.

kod:

import java.util.Scanner;

class jvstr11

{
	public static void main(String[] args) {
    Scanner wejscie = new Scanner(System.in);
    while (wejscie.hasNext()) 
   {
      String a = wejscie.next();
      String b = wejscie.next();
      if(a.indexOf(b)!=-1)
      {
        for(int i=0;i<a.length();i++)
        {
          int poz=a.indexOf(b, i);
          if (poz!=-1)
          {
          System.out.print(poz + " ");      
          }             
        }
        System.out.println();
      }
      else
      System.out.println("NIE"); 
    }
  }
}

Nie wiem czy dobrze zrozumiałem ale chodzi ci o znajdywanie jednego stringu w innym...

Do zabawy ze stringami bardzo przydają się wyrażenia regularne a także klasy Pattern oraz Matcher...

Wrzucę ci przykład :)

    public static void main(String[] args) {

        Scanner wejscie = new Scanner(System.in);

        String a = wejscie.next();
        String b = wejscie.next();
        Matcher m = Pattern.compile(b).matcher(a);
        int i = 0;
        while (m.find()) {

            i++;
            System.out.println("Start at: " + m.start());
        }
        System.out.println("Number of repetitions: " + i);

    }
 

Pozdr.

znaleŹć jeden w drugim i pokazać na jakiej pozycji sie znajduje

matcher pattern nic nie dało (wyświetla za mało indexów).
to jest treść zadania:

Napisz program, który będzie wyszukiwać wszystkie wystąpienia jednego ciągu w drugim.

Wskazówka: wykorzystaj inną formę metody find, w której możesz podać od której pozycji zaczynasz poszukiwanie:
public int indexOf(String str, int fromIndex);
Wejście

Kolejne wiersze z parami wyrazów.
Wyjście

Dla każdej pary wyrazów s, x z wejścia wypisz jedną linię zawierającą wszystkie pozycje na których podciąg x znajduje się w s, albo słowo "NIE" jeśli nie występuje ani razu.
Przykład
Wejście
Ala la
hello l
lalalalala lala
Wyjście
1
2 3
0 2 4 6

Przechodzisz kolejne indeksy w poszukiwaniu podciągów, ale zapomniałeś "przeskoczyć" indeksy pod którymi nic nie można znaleźć. W ten sposób masz tyle przeszukiwań zakończonych sukcesem, ile jest znaków między początkiem ostatnio znalezionego podciągu (lub początkiem łańcucha), a następnym podciągiem do znalezienia.
Żeby naprawić najprościej Twój algorytm trzeba za wierszem 19. dodać instrukcję:
i = ++poz;
Wtedy nie będziesz zbędnie przeszukiwał tego samego obszaru dopóki nie dojdziesz do początku już znalezionego podłańcucha.

To kolejny przykład pokazujący, żeby nigdy nie używać jako zmiennych niezrozumiałych pojedynczych literek, lecz nazywać je nazwą właściwą temu co mają reprezentować. Na przykład o wiele łatwiej znalazłbyś błąd gdyby Twój kod wyglądał jakoś tak:

import java.util.Scanner;

public class Jvstrll
{
	public static void main(String[] args)
	{
		Scanner input = new Scanner(System.in);
		while(input.hasNext())
		{
			String str = input.next();
			String toFind = input.next();
			if(str.indexOf(toFind) != -1)
			{
				for(int startSearch = 0; startSearch < str.length(); ++startSearch)
				{
					int foundIndex = str.indexOf(toFind, startSearch);
					if(foundIndex != -1)
					{
						System.out.print(foundIndex + " ");
						startSearch = foundIndex; //dodana poprawka
					}
				}
				System.out.println();
			}
			else
				System.out.println("NIE");
		}
	}
}

To też nie zadziała. Np. dla wejścia "lalala" i dopasowania "lala" znajdzie tylko indeks 0, przeskoczy o 4 i się zakończy - a jest jeszcze indeks 2.

bardzo dzieki za podpowiedz. a z tymi nazwami to masz racje. dopiero zaczynam z java. teraz jest wszystko pieknie ale przy wejsciu xxxxxxx xx też daje za mało odpowiedzi. pokombinuje jeszcze

import java.util.*;

public class JwStr
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner(System.in);

        while(input.hasNext())
        {
            String str = input.next();
            ArrayList<Integer> result=new ArrayList<Integer>();
            String toFind = input.next();
            if(str.indexOf(toFind) != -1)
            {
                for(int startSearch = 0; startSearch < str.length(); ++startSearch)
                {
                    int foundIndex = str.indexOf(toFind, startSearch);
                    if(foundIndex != -1)
                    {
                        if(!result.contains(foundIndex))
                        {
                            result.add(foundIndex);
                        }

                    }
                }
                for(int i=0;i<result.size();i++)
                {
                    System.out.print(result.get(i) + " ");
                }
                System.out.println();
             }
             else
             System.out.println("NIE");
         }
    }
}

Rozwiązanie jest jeszcze prostsze. Po prostu była jedna niepotrzebna inkrementacja.
Zamiast startSearch = ++foundIndex wystarczy zwykłe startSearch = foundIndex. startSearch jest przecież inkrementowany z pętli for po dojściu do końca bloku. Ostatecznie wersja w której nie ma ani jednego zbędnego sprawdzenia wygląda tak:

import java.util.Scanner;

public class JvStr
{
	public static void main(String[] args)
	{
		Scanner input = new Scanner(System.in);
		while(input.hasNext())
		{
			String str = input.next();
			String toFind = input.next();
			int foundIndex = -1;
			for(int startSearch = 0; startSearch < str.length(); ++startSearch)
			{
				foundIndex = str.indexOf(toFind, startSearch);
				if(foundIndex >= 0)
				{
					System.out.print(foundIndex + " ");
					startSearch = foundIndex;
				}
				else
				{
					if(startSearch == 0)
						System.out.println("NIE");
					break;
				}
			}
			System.out.println();
		}
	}
}

Jak na razie przeszła mi wszystkie możliwe testy, ale może znajdziesz jeszcze jakieś wady.

przypuszczłem ze coś za dużo inkrementuje. dzieki wielkie.