Blokovska struktura

import java.util.*;

public class BlockContainerTest {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int size = scanner.nextInt();
        BlockContainer<Integer> integerBC = new BlockContainer<Integer>(size);
        scanner.nextLine();
        Integer lastInteger = null;
        for(int i = 0; i < n; ++i) {
            int element = scanner.nextInt();
            lastInteger = element;
            integerBC.add(element);
        }
        System.out.println("+++++ Integer Block Container +++++");
        System.out.println(integerBC);
        System.out.println("+++++ Removing element +++++");
        integerBC.remove(lastInteger);
        System.out.println("+++++ Sorting container +++++");
        integerBC.sort();
        System.out.println(integerBC);
        BlockContainer<String> stringBC = new BlockContainer<String>(size);
        String lastString = null;
        for(int i = 0; i < n; ++i) {
            String element = scanner.next();
            lastString = element;
            stringBC.add(element);
        }
        System.out.println("+++++ String Block Container +++++");
        System.out.println(stringBC);
        System.out.println("+++++ Removing element +++++");
        stringBC.remove(lastString);
        System.out.println("+++++ Sorting container +++++");
        stringBC.sort();
        System.out.println(stringBC);
    }
}

class BlockContainer<T extends Comparable>  {
    int n;
    List<TreeSet<T>> elementi;

    public BlockContainer(int n) {
        this.n = n;
        elementi = new ArrayList<>();
    }
    public void add(T a){
        if(elementi.size() == 0){
            TreeSet<T> list = new TreeSet<>();
            list.add(a);
            elementi.add(list);
        }
        else if(elementi.get(elementi.size()-1).size() < n){
            elementi.get(elementi.size() - 1).add(a);
        }
        else {
            TreeSet<T> list = new TreeSet<>();
            list.add(a);
            elementi.add(list);
        }
    }
    public boolean remove(T a) {
        boolean izbirshan = elementi.get(elementi.size()-1).remove(a);
        if(elementi.get(elementi.size()-1).size() == 0)
            elementi.remove(elementi.size()-1);
        return izbirshan;
    }
    public void sort(){
        List<T> elements = new ArrayList<>();
        for (TreeSet<T> t : elementi) {
            elements.addAll(t);
        }

        Collections.sort(elements,(o1, o2) -> o1.compareTo(o2));
        elementi.clear();
        for(T x : elements){
            this.add(x);
        }
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < elementi.size(); i++) {
            sb.append("[");
            for (T x : elementi.get(i)) {
                if (elementi.get(i).last().equals(x)) {
                    sb.append(x);
                }
                else
                    sb.append(x + ", ");
            }
            if (i == elementi.size() - 1)
                sb.append("]");
            else
                sb.append("],");
        }
        return sb.toString();
    }
}