//////////////////////////////////////////////////////////////////////////////////
public static Osoba fromString(String string) {
		String[] podaci = string.split("\\|");
		if (podaci.length % 8 != 0) {
			throw new IllegalArgumentException();
		}
		Osoba osoba = fromString(podaci[0], podaci[1], podaci[2], podaci[3], podaci[4], podaci[5], podaci[6]);
		try {
			int brDece = Integer.parseInt(podaci[7]);
			Osoba[] deca = new Osoba[brDece];
			for (int i = 0; i < brDece; i++) {
				deca[i] = fromString(podaci[8 * i + 0], podaci[8 * i + 1], podaci[8 * i + 2], podaci[8 * i + 3], podaci[8 * i + 4], podaci[8 * i + 5], podaci[8 * i + 6]);
			}
			return new Osoba(osoba.ime, osoba.prezime, osoba.pol, osoba.datumRodjenja, osoba.mestoRodjenja, osoba.mestoStanovanja, osoba.primanja, deca);
		} catch (NumberFormatException e) {
			throw new IllegalArgumentException(e);
		}
	}

	private static Osoba fromString(String... podaci) {
		try {
			return new Osoba(podaci[0], podaci[1], Pol.valueOf(podaci[2]), LocalDate.parse(podaci[3]), podaci[4], podaci[5], Integer.parseInt(podaci[6]));
		} catch (NullPointerException | DateTimeParseException | NumberFormatException | IndexOutOfBoundsException e) {
			throw new IllegalArgumentException(e);
		}
	}






public static Patuljak fromString(String string) {
		String[] podaci = string.split(";");
		return new Patuljak(podaci[0], Integer.parseInt(podaci[1]), Integer.parseInt(podaci[2]), Double.parseDouble(podaci[3]));
	}



/////////////////////////////////////////////////////////////////////////////////////////////////


private static void naslov(String naslov) {
		System.out.println();
		System.out.println(naslov);
		System.out.println(naslov.replaceAll(".", "="));
	}

	private static void svi() {
		Osobe.osobeStream(5000)
			.forEach(System.out::println);
	}

	private static void punoDece() {
		Osobe.osobeStream(5000)
			.filter(o -> o.getDeca().size() > 2)
			.map(o -> o.getIme() + " " + o.getPrezime())
			.forEach(System.out::println);
	}

	private static void istoMesto() {
		Osobe.osobeStream(5000)
			.filter(o -> o.getMestoStanovanja().equals(o.getMestoRodjenja()))
			.sorted(Comparator.comparing(Osoba::getMestoStanovanja))
			.map(o -> o.getIme() + " " + o.getPrezime() + " (" + o.getMestoStanovanja() + ")")
			.forEach(System.out::println);
	}

	private static void bogateBezDece() {
		Osobe.osobeStream(5000)
			.filter(o -> o.getPol() == Pol.ZENSKI)
			.filter(o -> o.getPrimanja() > 75_000)
			.filter(o -> o.getDeca().isEmpty())
			.sorted(Comparator.comparing(Osoba::getPrimanja).reversed())
			.map(o -> String.format("%s %s (%d)", o.getIme(), o.getPrezime(), o.getPrimanja()))
			.forEach(System.out::println);
	}

	private static void rodjendani() {
		LocalDate sad = LocalDate.now();
		DateTimeFormatter format = DateTimeFormatter.ofPattern("dd.MM.");
		Comparator<Osoba> poDanu = Comparator.comparing(o -> o.getDatumRodjenja().getDayOfMonth());
		Comparator<Osoba> poGodini = Comparator.comparing(o -> o.getDatumRodjenja().getYear());
		Comparator<Osoba> poPrezimenu = Comparator.comparing(Osoba::getPrezime);
		Comparator<Osoba> poImenu = Comparator.comparing(Osoba::getIme);
		Comparator<Osoba> poredak = poDanu
			.thenComparing(poGodini.reversed())
			.thenComparing(poPrezimenu)
			.thenComparing(poImenu);
		Osobe.osobeStream(5000)
			.filter(o -> o.getDatumRodjenja().getMonth() == sad.getMonth())
			.sorted(poredak) // Ovo se nije trazilo u zadatku
			.map(o -> String.format("%s %s %s (%d)",
					format.format(o.getDatumRodjenja()),
					o.getIme(),
					o.getPrezime(),
					sad.getYear() - o.getDatumRodjenja().getYear()))
			.forEach(System.out::println);
	}

	private static void odrasli(String prezime) {
		long br = Osobe.osobeStream(5000)
			.filter(o -> o.getPrezime().equals(prezime))
			.count();
		System.out.println(br);
	}

	private static void ukupnoDece() {
		long br = Osobe.osobeStream(5000)
			.flatMap(o -> o.getDeca().stream())
			.count();
		System.out.println(br);
	}

	private static void zaPaketice() {
		LocalDate sad = LocalDate.now();
		Osobe.osobeStream(5000)
			.flatMap(o -> o.getDeca().stream())
			.filter(o -> o.getDatumRodjenja().getYear() >= 2000)
			.filter(o -> o.getDatumRodjenja().getYear() <= 2010)
			.map(o -> String.format("%s %s (%d)",
					o.getIme(),
					o.getPrezime(),
					o.getDatumRodjenja().until(sad).getYears()))
			.forEach(System.out::println);
	}

	private static void imenaPenzionera() {
		LocalDate sad = LocalDate.now();
		Osobe.osobeStream(5000)
			.filter(o -> o.getDatumRodjenja().until(sad).getYears() >= 65)
			.map(Osoba::getIme)
			.distinct()
			.sorted()
			.forEach(System.out::println);
	}

	private static void procenat() {
		long brOdraslih = Osobe.osobeStream(5000)
			.count();
		long brOdraslihM = Osobe.osobeStream(5000)
			.filter(o -> o.getPol() == Pol.MUSKI)
			.count();
		long brDece = Osobe.osobeStream(5000)
			.flatMap(o -> o.getDeca().stream())
			.count();
		long brDeceM = Osobe.osobeStream(5000)
			.flatMap(o -> o.getDeca().stream())
			.filter(o -> o.getPol() == Pol.MUSKI)
			.count();
		double procenat = 100.0 * (brOdraslihM + brDeceM) / (brOdraslih + brDece);
		System.out.printf("%8.5f%%%n", procenat);
	}

	private static void procenat2() {
		Osobe.osobeStream(5000)
			.flatMap(o -> Stream.concat(
					Stream.of(o),
					o.getDeca().stream()))
			.mapToDouble(o -> o.getPol() == Pol.MUSKI ? 100.0 : 0.0)
			.average()
			.ifPresent(d -> System.out.printf("%8.5f%%%n", d));
	}

	private static void trecaPoRedu() {
		Osobe.osobeStream(5000)
			.sorted(Comparator.comparing((Osoba o) -> o.getBrDece(Pol.MUSKI)).reversed())
			.skip(2)
			.limit(1)
			.forEach(System.out::println);
	}

	private static void najbogatiji(String grad) {
		Osobe.osobeStream(5000)
			.filter(o -> o.getMestoStanovanja().equals(grad))
			.sorted(Comparator.comparing(Osoba::getPrimanja).reversed())
			.limit(1)
			.map(o -> String.format("%s %s (%s)",
					o.getIme(),
					o.getPrimanja(),
					o.getMestoRodjenja()))
			.forEach(System.out::println);
	}

	private static void josBogatiji(String grad) {
		int granica = Osobe.osobeStream(5000)
			.filter(o -> o.getMestoStanovanja().equals(grad))
			.sorted(Comparator.comparing(Osoba::getPrimanja).reversed())
			.mapToInt(Osoba::getPrimanja)
			.limit(1)
			.sum();
		Osobe.osobeStream(5000)
			.filter(o -> !o.getMestoStanovanja().equals(grad))
			.filter(o -> o.getPrimanja() > granica)
			.sorted(Comparator.comparing(Osoba::getPrimanja))
			.map(o -> String.format("%s (%s) %s",
					o.getIme(),
					o.getPrimanja(),
					o.getMestoStanovanja()))
			.forEach(System.out::println);
	}













private final List<Patuljak> patuljci = new ArrayList<>();

	public void dodaj(Patuljak p) {
		patuljci.add(p);
	}

	public int brPatuljaka() {
		return (int) patuljci.stream()
				.count();
	}

	public double prosecnoIskopaliZlata() {
		return patuljci.stream()
				.mapToDouble(Patuljak::getIskopaoZlata)
				.average()
				.orElse(Double.NaN);
	}

	public double ukupnoIskopaliZlataOniNaSlovo(char slovo) {
		return patuljci.stream()
				.filter(p -> p.getIme().startsWith(String.valueOf(slovo)))
				.mapToDouble(Patuljak::getIskopaoZlata)
				.sum();
	}

	public Patuljak najbogatiji() {
		return patuljci.stream()
				.max(Comparator.comparing(Patuljak::getIskopaoZlata))
				.orElse(null);
	}

	public Patuljak drugiNajbogatiji() {
		return patuljci.stream()
				.sorted(Comparator.comparing(Patuljak::getIskopaoZlata).reversed())
				.skip(1)
				.findFirst()
				.orElse(null);
	}

	public int ukupnoUbiliGoblina(Predicate<Patuljak> p) {
		return patuljci.stream()
				.filter(p)
				.mapToInt(Patuljak::getUbioGoblina)
				.sum();
	}

	public List<Patuljak> opadajuceSortiraniPoBrojuUbijenihGoblina() {
		return patuljci.stream()
				.sorted(Comparator.comparing(Patuljak::getUbioGoblina).reversed())
				.collect(Collectors.toList());
	}

	public Set<Patuljak> patuljciStarijiOd(int godina) {
		int ovaGodina = LocalDate.now().getYear();
		return patuljci.stream()
				.filter(p -> ovaGodina - p.getGodinaRodjenja() > godina)
				.collect(Collectors.toSet());
	}

	public List<String> imenaPatuljakaRastuceSortiranaPoPrezimenu() {
		return patuljci.stream()
				.map(Patuljak::getIme)
				.sorted(Comparator.comparing(s -> s.split(" |$", 2)[1]))
				.map(s -> s.split(" ")[0])
				.collect(Collectors.toList());
	}

	public Map<Integer, Set<Patuljak>> patuljciRazvrstaniPoGodiniRodjenja() {
		return patuljci.stream()
				.collect(Collectors.groupingBy(Patuljak::getGodinaRodjenja, Collectors.toSet()));
	}

	public Map<Integer, Set<Patuljak>> patuljciRazvrstaniPoVekuRodjenja() {
		return patuljci.stream()
				.collect(Collectors.groupingBy(p -> p.getGodinaRodjenja() / 100 + 1, Collectors.toSet()));
	}

	public boolean postojiPatuljakSaViseZlataOd(double granica) {
		return patuljci.stream()
				.anyMatch(p -> p.getIskopaoZlata() > granica);
	}