Properties File MRU Cache
There's a little-known, though powerful feature of Java's LinkedHashMap code, and it is purpose-built for managing caches like yours. In your case, you should create the Map with the access-order constructor:

private static final class MyCache extends LinkedHashMap&lt;String, String&gt; {

    private final int limit;

    public MyCache(int limit) {
        super(limit, 0.75f, true);
        this.limit = limit;
    }

    @Override
    protected boolean removeEldestEntry(Map.Entry&lt;String, String&gt; eldest) {
        return size() &gt; limit;
    }
}


Note how you can override the removeEldestEntry method?

If you put this all together in an application, it looks like:

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.LinkedHashMap;
import java.util.Map;


public class PropertiesFileMRUCache {
    private static final class MyCache extends LinkedHashMap&lt;String, String&gt; {

        private final int limit;

        public MyCache(int limit) {
            super(limit, 0.75f, true);
            this.limit = limit;
        }

        @Override
        protected boolean removeEldestEntry(Map.Entry&lt;String, String&gt; eldest) {
            return size() &gt; limit;
        }
    }

    private final MyCache cache;

    private final Path propertiesFile;

    public PropertiesFileMRUCache(int limit, String file) {
        cache = new MyCache(limit);
        propertiesFile = Paths.get(file);
    }

    public String getCapital(String country) {
        return cache.computeIfAbsent(country, c -&gt; readFromFile(c));
    }

    private String readFromFile(String country) {
        final String prefix = country + "=";
        try (Stream&lt;String&gt; lines = Files.lines(propertiesFile)){
            return lines.filter(line -&gt; line.startsWith(prefix))
                    .map(line -&gt; line.substring(prefix.length()))
                    .findFirst()
                    .orElse(null);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }


    public static void main(String[] args) {
        PropertiesFileMRUCache pfc = new PropertiesFileMRUCache(8, "ccap.properties");
        pfc.getCapital("India");
        pfc.getCapital("USA");
        pfc.getCapital("UK");
        pfc.getCapital("Kuwait");
        pfc.getCapital("Iraq");
        pfc.getCapital("Canada");
        pfc.getCapital("Australia");
        pfc.getCapital("India");
        pfc.getCapital("India");
        pfc.getCapital("India");
        pfc.getCapital("Germany");
        pfc.getCapital("India");
        pfc.getCapital("Germany");
        pfc.getCapital("China");
        pfc.getCapital("Pakistan");
        System.out.println(pfc.cache);
    }
}


Note how I have also hacked around in your readFromFile method. I have made it NIO2-based using Paths, and Files. This is the best practice way to do it in Java 8. I have also streamed the lines, which I believe will help. A try-with-resources cleanly closes the stream too. Additionally, a computeIfAbsent is the right way to reuse an existing entry, and create a missing one.

There are a number of things you should identify as being different. Consider the extension of the LinkedHashMap to be the most significant, and the improved use of the computeIfAbsent to be second most important.