Store a number as ASCII text in Java?

It's probably a stupid question but here's the thing. I was reading this question:

Storing 1 million phone numbers

and the accepted question was what I was thinking: using a开发者_如何学编程 trie. In the comments Matt Ball suggested:

I think storing the phone numbers as ASCII text and compressing is a very reasonable suggestion

Problem: how do I do that in Java? And ASCII text does stand for String?

For in-memory storage as indicated in the question:

ByteArrayOutputStream baos = new ByteArrayOutputStream();
OutputStreamWriter out = new OutputStreamWriter(
    new GZIPOutputStream(baos), "US-ASCII");
for(String number : numbers){
    out.write(number);
    out.write('\n');
}
byte[] data = baos.toByteArray();

But as Pete remarked: this may be good for memory efficiency, but you can't really do anything with the data afterwards, so it's not really very useful.

Yes, ASCII means Strings in this case. You can store compressed data in Java using the java.util.zip.GZIPOutputStream.

In answer to an implied, but different question;

Q: You have 1 billion phones numbers and you need to send these over a low bandwidth connection. You only need to send whether the phone number is in the collection or not. (No other information required)

A: This is the general approach

• First sort the list if its not sorted already.
• From the lowest number find regions of continuous numbers. Send the start of the region and the phones which are taken. This can be stored a BitSet (1-bit per possible number) Send the phone number at the start and the BitSet whenever the gap is more than some threshold.
• Write the stream to a compressed data set.
• Test this to compare with a simple sending of all numbers.

You can use Strings in a sorted TreeMap. One million numbers is not very much and will use about 64 MB. I don't see the need for a more complex solution.

The latest version of Java can store ASCII text efficiently by using a byte[] instead of a char[] however, the overhead of your data structure is likely to be larger.

If you need to store a phone numbers as a key, you could store them with the assumption that large ranges will be continous. As such you could store them like

NavigableMap<String, PhoneDetails[]>

In this structure, the key would define the start of the range and you could have a phone details for each number. This could be not much bigger than the reference to the PhoneDetails (which is the minimum)

BTW: You can invent very efficient structures if you don't need access to the data. If you never access the data, don't keep it in memory, in fact you can just discard it as it won't ever be needed.

Alot depending on what you want to do with the data and why you have it in memory at all.

You can Use DeflatorOutputStream to a ByteArrayOutputStream, which will be very small, but not very useful.

I suggest using DeflatorOutputStream as its more light weight/faster/smaller than GZIPOutputStream.

Java String are by default UTF-8 encoded, you have to change the encoding if you want to manipulate ASCII text.