You can understand how this saves space using this example: Suppose I work for Google on the Chrome team and want to add a function to the browser that notifies the user if the URL he entered is a malicious URL. So I have a dataset of about 1 million malicious URLs that is about 25 MB in size. Since the size is quite large (large compared to the size of the browser itself), I store this data on a remote server.
Case 1: I use a hash function with a hash table. I solve an efficient hash function and run all 1 million URLs through a hash function to get the hash keys. Then I create a hash table (array) where the hash key will give me an index to place this url. So, now that I have hashed and populated the hash table, I check its size. I saved all 1 million URLs in a hash table along with the keys. Therefore, the size is at least 25 MB. Due to its size, this hash table will be stored on the remote server. When the user comes in and enters the URL in the address bar, I need to check if he is malicious. Thus, I run the URL through a hash function (the browser itself can do this), and I get the hash key for that URL. Now I have to make a request to my remote server using this hash key to check if the specific URL in my hash table with this particular key is the same as the one entered by the user. If so, then it is malicious, and if not, then it is not malicious. Thus, each time a user enters a URL, a request must be sent to the remote server to check if it is a malicious URL. This will take a lot of time and thus make my browser slow.
Case 2: I use a flowering filter. The entire list of 1 million URLs is launched through a flowering filter using several hash functions, and the corresponding positions are marked as 1 in a huge array of 0. Suppose we want a false positive rate of 1% using a flowering filter calculator ( http://hur.st/bloomfilter?n=1000000&p=0.01 ), we get the size of the flowering filter requires only 1.13 MB. Such a small size is expected, although the size of the array is huge, we only save 1 or 0, not the URL, as in the case of a hash table. This array can be considered as a bit array. That is, since we have only two values, 1 and 0, we can set individual bits instead of bytes. This would reduce the space spent 8 times. This 1.13 MB color filter, due to its small size, can be stored in the web browser itself! Thus, when the user arrives and enters the URL, we simply apply the required hash functions (in the browser itself) and check all the positions in the color filter (which is stored in the browser). A value of 0 in any of the positions tells us that this URL is NOT SPECIFIED in the list of malicious URLs, and the user can act freely. Thus, we did not call the server and, therefore, saved time. A value of 1 tells us that the URL MAY be included in the list of malicious URLs. In these cases, we make a call to the remote server, and there we can use some other hash function with some hash table, as in the first case, to get and check if the URL is valid. Since in most cases the URL is unlikely to be malicious, the small bloom filter in the browser displays this and therefore saves time by avoiding calls to the remote server. Only in some cases, if the flower filter tells us that the URL can be malicious, only in those cases we make a call to the server. This "MIGHT" is eligible 99%.
Thus, using a small flower filter in the browser, we saved a lot of time, since we do not need to make server calls for each URL entered.