Performance issue in collection

Question

Hi ,
I am dealing with lists,Maps in my program.I have huge amount of daya to process.I have 300000 elements to process
and them to the list.generally how much time it will take to process such huge amount of data if i have a simple for loop and adding to a list.

Answer 1

for (String each : Caps) {
            if (CodeMap.keySet().contains(each.toUpperCase())From there on i count two more calls to each.toUpperCase(), one of them in an inner loop, so will be called multiple times.
If you care about performance, why these repeated calls to each.toUpperCase()?
Do you believe you will get a different String each time?
Why not just
            String eachToUpperCase = each.toUpperCase();
            if (CodeMap.keySet().contains(eachToUpperCase)
                && CodeMap.get(eachToUpperCase).size() > 0) {Why do you guard each get() with a contains()?
If you care about performance, why not just one simple get(), which will return null if the Map does not contain a value for the key you have searched for.
The only case where contains makes sense is if you store null as a value explicitly in your map and want to execute a special action if null is stored.
As this is not the case in your code, just improve to:
            String eachToUpperCase = each.toUpperCase();
            List? <String? > codes = CodeMap.get(eachToUpperCase);
            if (codes==null && codes.size()> 0) {(Replace List? and String? with appropriate types).
The next line in your example is:
                if (BasedOnMap.get(each != null) {There definitely is a ")" missing here, so you want us to estimate the performance of code that does not even compile!
I would assume
                if (BasedOnMap.get(each) != null) {because in the next line you have
                    for (MatrixBo eachBo : BasedOnMap.get(each)) {Again a double lookup where a single one would have been enough!
Here i am guessing the type returned by BasedOnMap.get(each) is List<MatrixBo>.
Using this and adding missing brackets:
                List<MatrixBo> matrixBoList = BasedOnMap.get(each);
                if (matrixBoList != null) {
                    for (MatrixBo eachBo : matrixBoList ) {
                        String pointCode = eachBo.getPoint().getPointCode();
                        String pointCodeToUpperCase = pointCode.toUpperCase();
                        String? code=codes.get(pointCodeToUpperCase);
                        if (code!=null) {
                            if (!exceptionlist.contains(NameBoMap.get(pointCode))) {
                                filteredList.add(eachBo);
            }Same algorithm, improved performance, much more readable!
One further hint: The line
                            if (!exceptionlist.contains( ...indicates you are performing a search in a (potentially huge) List(!), which has linear performance for every single search.
As it is searched in an inner loop these searches will occur quite often.
As the exceptionlist appears to be unchanged through your algorithm, start with transforming it into a Set before starting the outer loop:
Set<String ?> exceptionSet = new HashSet<String ?>(exceptionlist);
for (String each : Caps) {then search into the set:
                            if (!exceptionSet.contains(NameBoMap.get(pointCode))) {
                                filteredList.add(eachBo);
                            }