Filtering Frequency Bands Out of a Signal
What would be the most simple approach to do this ?

I'm a GNU Radio person. So the simplest approach was this GNU Radio companion-designed flowgraph:

Generating this flowgraph file generates a python program that uses GNU Radio to do the signal processing, on as many CPU cores as there are.
You can then run it as
$ ./bandpass_filters.py -f {input file containing float32 samples, one after the other}

To decrease the complexity of all these bandpasses, I first used a low pass to reduce the sampling rate of the signal by half – that's Ok, since you are only interested in frequencies below half of half of your input sampling rate.
I tried this with a 200MB &quot;dummy&quot; file, creating eight 100MB output files – this, to and from a temp directory, took a whole 13 seconds.
I'm pretty hopeful it's fast enough! I benchmarked this a bit, and it seems the source is able to push through about 20 million samples per second; the slow part is the writing to the 8 files.
Note that this is a quick and easy solution – a proper, speed-optimized solution would probably use

decimation, because you're output sampling rate is still 110 Hz, which contains a maximum of 9 Hz (that's a waste of processing power, and hence, speed)
another pre-decimation by 2 through low-pass filtering to 27.5 Hz for the four filters below that rate

However, really, at your modest amount of samples (16GB = 4 Billion 32bit floats?) this isn't really necessary, if you wanted to grab a coffee, anyways.
That flowgraph was really nice and easy to design. Here I am, shamelessly plugging GNU Radio's Guided tutorials if you want to learn to design such signal processing flow graphs yourself; in fact, it's even more fun to use GNU Radio in live flowgraphs, i.e. in systems where the in- or output (or both) are physical devices (microphones, ecg sensors, sonars, radio frontends). Exactly the same flow graph can work with a sound card, if you replace the &quot;file source&quot; by an &quot;audio source&quot; (both come with GNU Radio) and specify a sound card-compatible sampling rate via the -r flag.
Now, since you probably know better than me how to work with Mathematica, here's what I'd recommend you implement:

(first, one time) You use the GNU Radio companion to generate a python program that does the signal processing for you.
You use Mathematica's BinaryWrite() to write your raw samples to a file as 32 bit floating point numbers, e.g. BinaryWrite(&quot;/tmp/samples.dat.f32&quot;, your_sample_vector, &quot;Real32&quot;).
You use Mathematica's abilities to call executables on your machine to execute that python script. Now, I'm no Mathematica expert, so this is all Google-based-guessing: RunProcess({&quot;/path/of/python/executable&quot;, &quot;/path/of/generated/python/program&quot;, &quot;-f&quot;, &quot;/tmp/samples.dat.f32&quot;})
You read (BinaryRead) the resulting /tmp/samples.dat.f32_1_3.dat (and …_4_7.dat etc) in Mathematica.

Optionally, you really consider doing less workflow in Mathematica and use the sheer mass of signal processing things that come with GNU Radio or its module ecosystem.