Splitting the List on given size..

    static <T> List<List<T>> chopped(List<T> list, final int L) {
        List<List<T>> parts = new ArrayList<List<T>>();
        final int N = list.size();
        for (int i = 0; i < N; i += L) {
            parts.add(new ArrayList<T>(
                list.subList(i, Math.min(N, i + L)))
            );
        }
        return parts;
    }

Sorting Map based on values - java

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class MapValueSort {
 
    public static void main(String[] args){
        Map<String, Integer> unsortedData = new HashMap<String, Integer>();
        unsortedData.put("Left forehead",2);
        unsortedData.put("Right forehead",2);
        unsortedData.put("Right face",3);
        unsortedData.put("Left face",2);
     
        Set<Entry<String, Integer>>  entrySet = unsortedData.entrySet();
        List<MyEntry> sortedEntries =  new ArrayList<MyEntry>();
     
        for (Iterator iterator = entrySet.iterator(); iterator.hasNext();) {
            Entry<String, Integer> entry = (Entry<String, Integer>) iterator.next();
            sortedEntries.add(new MyEntry(entry));
        }
      
        Collections.sort(sortedEntries);
        Collections.reverse(sortedEntries);
        for(int i=0;i<sortedEntries.size();i++){
            System.out.println(sortedEntries.get(i).getKey()+" "+sortedEntries.get(i).getValue());
        }
    
        System.out.println("--------------->> unsortedData "+unsortedData);
        System.out.println("--------------->> entrySet "+entrySet);
        System.out.println("--------------->> sortedEntries "+sortedEntries);
    }
  
  
}
class MyEntry implements java.util.Map.Entry,Comparable<MyEntry>{
  
    private String key;
    private Integer value;
    public MyEntry(Entry<String, Integer> entry) {
        super();
        key = entry.getKey();
        value = entry.getValue();
    }

    @Override
    public Object getKey() {
        return key;
    }

    @Override
    public Object getValue() {
        return value;
    }

    @Override
    public Object setValue(Object value) {
        return null;
    }

    @Override
    public int compareTo(MyEntry o) {
        Integer currentValue = (Integer)this.getValue();
        Integer targetValue = (Integer)o.getValue();
        return currentValue.compareTo(targetValue);
    }
}

Glossary of Rooting Terms

Glossary of Rooting Terms

As you learn more about the rooting process, you'll probably run into a bunch of terms that can be confusing. Here are some of the most important ones and what they mean.

Rooting Terms

• Root: Rooting means you have root access to your device—that is, it can run the sudo command, and has enhanced privileges allowing it to run apps like Wireless Tether or SetCPU. You can root either by installing the Superuser application—which many of the below root processes include—or by flashing a custom ROM that has root access included.
• ROM: A ROM is a modified version of Android. It may contain extra features, a different look, speed enhancements, or even a version of Android that hasn't been released yet. you can read more about doing that here.
• Flash: Flashing essentially means installing something on your device, whether it be a ROM, a kernel, or something else that comes in the form of a ZIP file. Sometimes the rooting process requires flashing ZIP file, sometimes it doesn't.
• Bootloader: Your bootloader is the lowest level of software on your phone, running all the code that's necessary to start up your operating system. Most bootloaders come locked, which keeps you from rooting your phone. Unlocking your bootloader doesn't root your phone directly, but it does allow you to root, then flash custom ROMs if you so desire.
• Recovery: Your recovery is the software on your phone that lets you make backups, flash ROMs, and perform other system-level tasks. The default recoveries can't do much, but you can flash a custom recovery—like ClockworkMod—after you've unlocked your bootloader that will give you much more control over your device. This is often an integral part of the rooting process.
• ADB: ADB stands for Android Debug Bridge, and it's a command line tool for your computer that can communicate with an Android device you've connected to it. It's part of the Android Software Developers Kit (SDK). Many of the root tools below use ADB, whether you're typing the commands yourself or not. Unless the instructions call for installing the SDK and running ADB commands, you won't need to mess with it—you'll just need to know that it's what most of the tools use to root your phone.
• S-OFF: HTC phones use a feature called Signature Verification in HBOOT, their bootloader. By default, your phone has S-ON, which means it blocks you from flashing radio images—the code that manages your data, Wi-Fi, and GPS connections. Switching your phone to S-OFF lets you flash new radios. Rooting doesn't require S-OFF, but many rooting tools will give you S-OFF in addition to root access, which is nice.
• RUU and SBF: ROM Upgrade Utilities (for HTC phones) and System Boot Files (for Motorola phones) are files direct from the manufacturer that change the software on your phone. RUU and SBF files are how the manufacturers deliver your over-the-air upgrades, and modders often post leaked RUU and SBF files for flashing when the updates haven't been released yet. They're also handy when downgrading your phone, if a rooting method isn't available for the newest software version yet. You can flash RUUs right from your HTC phone, but Motorola users will need a Windows program called RSD Lite to flash SBF files.
• cyanogen-mod : CyanogenMod is an aftermarket firmware for a number of cell phones based on the open-source Android operating system. It offers features not found in the official Android based firmwares of vendors of these cell phones.CyanogenMod is developed as free and open source software based on the official releases of Android by Google, with added original and third-party code.