HashMap IS basic.

Using two parallel arrays is extremely inefficient. For each word that you read in, you need to search through the keys array, find the index where the word is stored, and then go to the same place in the values array and increase the value in that location by 1.

It doesn't make sense to use a 2D array either, since you are trying to store a String word and an int count frequency, and they are different data types.

If your were counting how many times certain numbers appeared in a document, then you can easily use a single array, but not if you are counting Strings.

In your case, a HashMap is really the ideal data structure to use to keep track of the data. Unless it is a requirement to not use Collections, I would suggest at least trying HashMap.

Scanner file = new Scanner(new File("filename.txt"));
Map<String, Integer> map = new HashMap<String, Integer>();
while (file.hasNext()) {
    String key = file.next();
    Integer value = map.get(key);
    if (value == null) {
        map.put(key, 1);
    }
    else {
        map.put(key, ++value);
    }
}

A type of map. You aren't saying much besides "I need a key-value thingy". If you need to iterate the map by insertion order, there is a LinkedHashMap. If you need to iterate the map by ascending or descending key values, there are sorted maps. If the map will be shared by multiple threads a concurrent map will be useful. If there will be billions of items in the list and you don't mind hemorraghing data (say this is a caching algorithm), a WeakHashMap is for you.

If by "key is not duplicated" you mean it is a violation if a key is inserted if it already exists, you have a few options.

Data Structure Logic:

Hashmaps are used to access the content via its key.

In this sample, I guess you are scanning 'tuples' one by one and each tuple is different from other, so you won't need to access an old tuple via it's key.

So here, I suggest you to create the model class suitable for the key-value pairs and store them in a list. You can push that list when you are done.

Sample model for tuple:

public class KeyValuePair {
    private String key;
    private String value;
    public KeyValuePair(String key, String value) {
        this.key = key;
        this.value = value;
    }
}

Sample List to store:

List<KeyValuePair> keyValuePairList = new ArrayList<>();
keyValuePairList.add(new KeyValuePair("0", "816444014066"));
keyValuePairList.add(new KeyValuePair("1", "747083010945"));
keyValuePairList.add(new KeyValuePair("2", "816444010969"));

Storing:

If you cannot pass the data between activities, check out SQLite. You can store the data in SQLite and fetch it when needed. It is an offline database works on Android devices. You can delete the data when pushed to upstream.

Edit:

If the keys are the orders, you can simply use a String List like this:

List<String> keyValuePairList = new ArrayList<>();
keyValuePairList.add("816444014066");
keyValuePairList.add("747083010945");
keyValuePairList.add("816444010969");

I would advocate using BidiMap by apache collections.

You can use the various implementations of java.util.Map (see http://docs.oracle.com/javase/7/docs/api/java/util/Map.html). The most commonly used Map implementation for a dictionary-like map should be HashMap.

However, depending on the exact usage scenario, another type of map might be better.

Look at these key-value stores: Berkeley DB Java Edition, or JDBM (JDBM3 is the latest), or MapDB (JDBM successor). Tokyo Cabinet is not native Java but has a Java wrapper.

For an overview see http://en.wikipedia.org/wiki/Dbm.

private static final String[] DIRECTIONS = {
    "N", "NNE", "NE", "ENE", "E", "ESE", "SE", "SSE",
    "S", "SSW", "SW", "WSW", "W", "WNW", "NW", "NNW"
};

String degreeToName(double degree) {
    int corner = (int)((degree + 11.25) / 22.5) % 16; // Or % DIRECTIONS.length
    return DIRECTIONS[corner];
}

String degreeToRange(double degree) {
    int corner = (int)((degree + 11.25) / 22.5) % 16; // Or % DIRECTIONS.length
    double lowerBound = corner * 22.5 - 11.25 + (corner == 0 ? 360 : 0);
    double upperBound = corner * 22.5 + 11.25;
    return String.format("%.2f - %.2f", lowerBound, upperBound);
}

A calculation seems best suited.

Under circumstances harden the code with:

while (degree < 0) degree += 360;

For completeness sake added degreeToRange.