Java returning a loop

Make an array, place each value as a separate item in the array, and then return the array. Or append the new value onto msg in the loop:

    msg += FormatS.FormatS(str, value);

Initiate msg outside the loop.

If you want to make the method return a different thing each time you call it, you'll need to store the state of the method - which is particularly unfortunate as it's a static method.

It feels to me like it would be more appropriate to return an Iterable<String> - a single object which you can iterate over, e.g. with an enhanced for loop.

One simple way of doing that is to read the whole file, loading it into a List<String> and then return that. Guava provides a very easy way of doing this:

// Use the appropriate charset, of course - but the default platform encoding
// is rarely a good idea.
List<String> lines = Files.readLines(new File("chat.txt", Charsets.UTF_8));

List<String> formattedLines = Lists.newArrayList();
for (String line : lines) {
    formattedLines.add(FormatS.FormatS(line, value));
}
return formattedLines;

(FormatS.FormatS is a pretty odd method name, by the way...)

There are alternative ways of doing this in Guava, e.g. passing in LineProcessor - but if you're relatively new to Java, this is probably a simpler starting point.

Every call will return the next line, or null if no more lines (if that's what you need):

static BufferedReader mainChat = new BufferedReader(new FileReader("./chat.txt"));
static boolean finished = false;

public static String readChat(String value) throws Exception
{
    FormatS FormatS = new FormatS();

    if(finished) {
        return null;
    }

    String str;
    if ((str = mainChat.readLine()) != null) 
    {
        return FormatS.FormatS(str, value);
    } else {
        finished = true;
        mainChat.close();
        return null;
    }
}

Note that you have to make a separate (re)initialize function if you want to use it more than once.

You have to call this method repeatedly from the calling method. Better way would be to store the contents in a String array and return the array without having to call this method multiple times.

private String[] strBuff;
while ((str = mainChat.readLine()) != null) 
{
    strBuff[i] = FormatS.FormatS(str, value);
}
return strBuff;

There are two clean ways to make a method communicate multiple return values to the caller.

The first and simplest way is to return an object that contains all the return values. It might be a Collection, like a List, or it might be be an object of your own value class.

 List<Person> matches = findMatches(peopleDB,criteria);
 MatchReport report = findMatchesAsReport(peopleDB);

...

 public List<Person> findMatches(PersonSource source,Criteria criteria) {
      List<Person> list = new ArrayList<Person>();
      while(source.hasNext()) {
          Person person = source.next();
          if(person.matches(criteria)) {
              list.add(person);
          }
      }
      return list;
 }

The second, more complex way is to define a handler which your method can hand items to as it encounters them.

    public interface PersonHandler {
          public void onPerson(Person p);
    }

Then you define your method so a handler gets passed to it:

    public void findMatches(PeopleSource source, Criteria criteria, PersonHandler handler) {
          while(source.hasNext()) {
             Person person = source.next();
             if(person.matches(criteria)) {
                handler.onPerson(person);
             }
          }
    }

The caller can then define a PersonHandler than meets their own needs:

   private static class PrintToWriterPersonHandler implements PersonHandler {
       private PrintWriter writer;
       public WriteToStreamPersonHandler(PrintWriter writer) {
           this.writer = writer;
       }
       public void onPerson(Person p) {
           writer.println(person);
       }
   }

...

   findMatches(source,criteria,new PrintToWriterPersonHandler(System.out));

This is quite involved, and complex for a beginner. But it's worth keeping in mind. It means you can deal with methods that produce huge numbers of responses, without having to wait until the method finishes, and without ending up with a huge List in memory. It also means you can deal with output from a method that may run indefinitely!