strs.removeAll(Arrays.asList(copyOfRange(strs.toArray(), 0, 3)));

strs.subList(0, 3).clear();

package main

import . "regexp"
import . "fmt"

func main() {
	array := []string{"John", "James", "Jakob", "Peter", "Janette", "Tom", "Vasya", "Jean", "Juilia", "Heather"}
	filtered := make(chan string)
	go func() {
		for _, s := range array {
			matched, _ := MatchString("^J[a-z]+", s)
			if matched { filtered <- s }
		}
		close(filtered)
	}()
	first := true
	for x := range filtered {
		y := <-filtered
		z := <-filtered
		if first { first = false } else { Println() }
		Printf("%s and %s follow %s", x, y, z)
	}
}

array.select{|v|v[/^J[a-z]+/]}.
each_slice(3).
map{|v| "#{v[0]}#{v[1]&&' and '+v[1]}#{v[2]&&' follow '+v[2]}"}.
join("\n")

var array = ["John", "James", "Jakob", "Peter", "Janette", "Tom", "Vasya", "Jean", "Juilia", "Heather"]
array.reduce(function(p, c,i){return i%3===0?p +' follow '+c:i%3===2?p +' and '+c:i>1?p+"\n"+c:c;})

(require racket/match)
(time (for ([x (in-range 1000000)]) (let* ([names '("John" "James" "Jakob" "Peter" "Janette" "Tom" "Vasya" "Jean" "Juilia" "Heather")]
       [jn (filter (lambda (w) (eq? (string-ref w 0) #\J)) names)])
  (for/fold ([res ""]) ([w jn] [i (in-range (length jn))]) 
    (match (remainder i 3)
      [0 (string-append res w " ")]
      [1 (string-append res "and " w " ")]
      [2 (string-append res "follow " w "\n")])))))

cpu time: 2584 real time: 2586 gc time: 272

(require unstable/sequence)
(time (for ([x (in-range 1000000)])(string-join (for/list ([x (in-slice 3 (filter (curry regexp-match? #rx"J.*") lst))]) 
	       (apply format "~a and ~a follow ~a" x)) 
	     "\n")))

cpu time: 22344 real time: 22347 gc time: 229

(require unstable/sequence)
(time (for ([x (in-range 1000000)]) (string-join (for/list ([x (in-slice 3 (filter (lambda (w) (eq? (string-ref w 0) #\J)) lst))]) 
	       (apply format "~a and ~a follow ~a" x)) 
	     "\n")

cpu time: 11952 real time: 11947 gc time: 201

var array = ["John", "James", "Jakob", "Peter", "Janette", "Tom", "Vasya", "Jean", "Juilia", "Heather"];
array.filter(function(e){return e.match(/^J[a-z]+/)!==null;}).reduce(function(p, c,i){
return i===1?p+' and '+c:i%3===2?p +' follow '+c:i%3===1?p +' and '+c:i>1?p+"\n"+c:c;
})

{-# LANGUAGE OverloadedStrings #-}

import Control.Category
import Data.ByteString.Char8 ( ByteString )
import qualified Data.ByteString.Char8 as BS
import Data.List.Split
import Text.Regex.Posix
import Debug.Trace

foo :: [ByteString] -> ByteString
foo =
  filter (=~ ("^J[a-z]+" :: ByteString)) >>>
  chunksOf 3 >>>
  map (
    \xs -> case xs of
      [a, b, c] -> BS.unwords [a, "and", b, "follow", c]
      _ -> ""
    ) >>>
  trace "..." >>>
  BS.unlines

main :: IO ()
main = BS.putStr $ foo ["John", "J123", "James", "Jakob", "Peter", "Janette", "Tom", "Vasya", "Jean", "Juilia", "Heather", "Jodd"]

using System;
using System.Collections.Generic;
using System.Linq;

namespace ConsoleApplication6
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            var passengers = new List<string> { "John", "James", "Jakob", "Peter", "Janette", "Tom", "Vasya", "Jean", "Juilia", "Heather" };
            Console.WriteLine(string.Join("\n", (from p in passengers
                                                     .Where(p => p.StartsWith("J"))
                                                     .Select((p, i) => new {Passenger = p, Index = i})
                                                     .GroupBy(x => (x.Index/3))
                                                 select string.Format("{0} and {1} folow {2}",
                                                      p.Select(p1 => p1.Passenger).ToArray())).ToArray()));
            Console.ReadLine();
        }
    }
}

СтрокаИмениНуралиеваБорисаГеоргиевича = "John,James,Jakob,Peter,Janette,Tom,Vasya,Jean,Juilia,Heather";
Массив = _сф.м_СоздатьИзСтроки(СтрокаИмениНуралиеваБорисаГеоргиевича,",");
Имена = Новый Массив;
Для каждого Имя Из Массив Цикл
    Если Лев(Имя,1)="J" Тогда
	Имена.Добавить(Имя);
    КонецЕсли; 
КонецЦикла; 
Результат = "";
Для сч=0 По Цел(Имена.Количество()/3-1) Цикл
    Результат = Результат + Имена[сч*3]+" and "+Имена[сч*3+1]+" follow "+Имена[сч*3+2]+Символы.ПС;
КонецЦикла;
Сообщить(Результат);

val persons = Array("John", "James", "Jakob", "Peter", "Janette", "Tom", "Vasya", "Jean", "Juilia", "Heather");
Console.println(persons filter(item => item.contains("J")));
persons.filter(p => p.contains("J")).grouped(3).foreach(person => Console.printf("%s%s%s%s%s\n", person(0), " follow ", person(1), " and ", person(2)));

import std.algorithm, std.range, std.regex, std.array, std.string, std.stdio : writeln;

void main() {
    auto names = ["John", "James", "Jakob", "Peter", "Janette", "Tom", "Vasya", "Jean", "Juilia", "Heather"];
    writeln(names.filter!(s => !s.match(r"^J[a-z]+").empty).array
                 .chunks(3)
                 .map!(b => format("%s and %s follow %s", b[0], b[1], b[2]))
                 .join("\n"));
}

<?php

require_once('../config.php');

echo blib_array::factory(["John", "James", "Jakob", "Peter", "Janette", "Tom", "Vasya", "Jean", "Juilia", "Heather"])
    ->pgrep('/^J[a-z]+/')
    ->nslice(3)
    ->map(function($x) { return "{$x[0]} and {$x[1]} follow {$x[2]}"; })
    ->join("\n");

echo blib_array::factory()
    ->range(11,99)
    ->map(function($x) { $a = floor($x/10); $b = $x%10; return $a*$b; })
    ->filter()
    ->nslice(9)
    ->map(function($row) { return $row->join("\t"); })
    ->join("\n");

$ php multab.php 
1	2	3	4	5	6	7	8	9
2	4	6	8	10	12	14	16	18
3	6	9	12	15	18	21	24	27
4	8	12	16	20	24	28	32	36
5	10	15	20	25	30	35	40	45
6	12	18	24	30	36	42	48	54
7	14	21	28	35	42	49	56	63
8	16	24	32	40	48	56	64	72
9	18	27	36	45	54	63	72	81

'%s and %s follow %s'&printf " 1 (($~ ((, & 3) @: (% & 3) @: $)) 'J[a-z]*' rxall 'John James Jakob Peter Janette Tom Vasya Jean Juilia Heather')

val persons = Array("John", "James", "Jakob", "Peter", "Janette", "Tom", "Vasya", "Jean", "Juilia", "Heather");
persons.foreach(p => if(p.startsWith("J")) Console.printf("%s%c" , p, ' '));
println;
persons.filter(p => p.startsWith("J")).grouped(3).
foreach(person => Console.printf("%s%s%s%s%s\n", person(0), " follow ", person(1), " and ", person(2)));

echo John James Jakob Peter Janette Tom Vasya Jean Juilia Heather | tr \  \\\n | grep -i \^j | pr -at3 | awk '{print $1, "and", $2, "follow", $3}'