Изучение Java

import java.io.*;
import java.util.Random;

public class GreedyNumberSorter {

    private static final int INT_MAX_DIGITS = 4, FRACT_MAX_DIGITS = 6, INT_NODE_BITS = 14, FRACT_NODE_BITS = 3;
    private int intMaxDigits, fractMaxDigits;
    private int intMaxBits, fractMaxBits;
    private int intNodeBits, fractNodeBits;
    private int intPartsQty, fractPartsQty;
    private int intNodeMask, fractNodeMask;
    private NumberNode root;

    GreedyNumberSorter(int intMaxDigits, int fractMaxDigits, int intNodeBits, int fractNodeBits) {
        this.intMaxDigits = intMaxDigits;
        this.fractMaxDigits = fractMaxDigits;
        this.intMaxBits = getBitsQty(intMaxDigits);
        this.fractMaxBits = getBitsQty(fractMaxDigits);
        this.intNodeBits = intNodeBits;
        this.fractNodeBits = fractNodeBits;
        this.intPartsQty = intMaxBits / intNodeBits + (intMaxBits % intNodeBits == 0 ? 0 : 1);
        this.fractPartsQty = fractMaxBits / fractNodeBits + (fractMaxBits % fractNodeBits == 0 ? 0 : 1);
        this.intNodeMask = (1 << INT_NODE_BITS) - 1;
        this.fractNodeMask = (1 << FRACT_NODE_BITS) - 1;
        this.root = new NumberNode();
    }

    GreedyNumberSorter(int intMaxDigits, int fractMaxDigits) {
        this(intMaxDigits, fractMaxDigits, INT_NODE_BITS, FRACT_NODE_BITS);
    }

    GreedyNumberSorter() {
        this(INT_MAX_DIGITS, FRACT_MAX_DIGITS);
    }

    public static final int getBitsQty(int digits) {
        long maxNumber = 10;
        for (int num = 1; num < digits; num++) maxNumber *= 10;
        maxNumber--;
        int bits = 0;
        for (long remain = maxNumber; remain > 0; remain /= 2) bits++;
        return bits;
    }

    private static class NumberNode {
        private NumberNode[] nodes;
    }

    private static final int[] getNumberParts(long number, int partDigits, int partsQty, int partMask) {
        int[] parts = new int[partsQty];
        long numberRemain = number;
        for (int level = 0; level < partsQty && numberRemain != 0; level++) {
            parts[level] = (int) numberRemain & partMask;
            numberRemain >>= partDigits;
        }
        return parts;
    }

    private final void addNumber(long intPart, long fractPart) {

        NumberNode numberNode = root;

        int[] parts = getNumberParts(intPart, intNodeBits, intPartsQty, intNodeMask);
        for (int level = intPartsQty - 1; level >= 0; level--) {
            if (numberNode.nodes == null) numberNode.nodes = new NumberNode[1 << intNodeBits];
            if (numberNode.nodes[parts[level]] == null) {
                numberNode.nodes[parts[level]] = new NumberNode();
            }
            numberNode = numberNode.nodes[parts[level]];
        }
        parts = getNumberParts(fractPart, fractNodeBits, fractPartsQty, fractNodeMask);
        for (int level = fractPartsQty - 1; level >= 0; level--) {
            if (numberNode.nodes == null) numberNode.nodes = new NumberNode[1 << fractNodeBits];
            if (numberNode.nodes[parts[level]] == null) {
                numberNode.nodes[parts[level]] = new NumberNode();
            }
            numberNode = numberNode.nodes[parts[level]];
        }
    }

    public void generateRandomNumbersFile(String filename, int numberCount) throws IOException {

        BufferedWriter writer = new BufferedWriter(new FileWriter(filename));
        Random random = new Random();
        for (int i = 0; i < numberCount; i++) {
            writer.write(""
                    + Math.abs(random.nextLong()) % (long) Math.pow(10, intMaxDigits) + ","
                    + Math.abs(random.nextLong()) % (long) Math.pow(10, fractMaxDigits) + "\r\n");
        }
        writer.close();
    }

    public void readNumbersFile(String filename) throws IOException {
        BufferedReader reader = new BufferedReader(new FileReader(filename));
        long intPart = 0, fractPart = 0;
        boolean itsIntPart = true;
        for(String strNumber; (strNumber = reader.readLine()) != null;) {
            int fractDigits = 0;
            for(char ch : strNumber.toCharArray()) {
                if (ch > 47 && ch < 59)
                    if (itsIntPart) intPart = intPart*10 + ch - 48;
                    else {fractPart = fractPart*10 + ch - 48; fractDigits++;}
                else if (ch == 44) itsIntPart = false;
            }
            for (int digits = fractDigits; digits < fractMaxDigits; digits++) fractPart *= 10;
            addNumber(intPart, fractPart);
            intPart = fractPart = 0; itsIntPart = true;
        }
        reader.close();
    }

    public void out(BufferedWriter bw, NumberNode numberNode, int level, long intPart, long fractPart) throws IOException {
        int intBitsOfShift = (intPartsQty - level - 1) * intNodeBits;
        int fractBitsOfShift = (fractPartsQty + intPartsQty - level - 1) * fractNodeBits;
        for(int i = 0; i < numberNode.nodes.length; i++) {
            if (numberNode.nodes[i] != null) {
                if (level < intPartsQty) intPart = ((intPart >> intBitsOfShift & ~intNodeMask) + i) << intBitsOfShift;
                else fractPart = ((fractPart >> fractBitsOfShift & ~fractNodeMask) + i) << fractBitsOfShift;
                if (numberNode.nodes[i].nodes == null) bw.write("" + intPart + "." + fractPart + "\r\n");
                else out(bw, numberNode.nodes[i], level + 1, intPart, fractPart);
            }
        }
    }

    public void print(BufferedWriter bw) throws IOException {
        if (root.nodes == null) return;
        out(bw, root, 0, 0, 0);
    }

    public static void main(String[] args) throws IOException {
        GreedyNumberSorter greedyNumberSorter = new GreedyNumberSorter();
//        greedyNumberSorter.generateRandomNumbersFile("D:\\test.txt", 20000000);
        greedyNumberSorter.readNumbersFile("D:\\test.txt");
        BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\testout.txt"));
        greedyNumberSorter.print(bw);
        bw.close();
    }
}