Create a Pair class, that holds both the Integer and the String and then add multiple Pair objects to a List, which will be shuffled.

public class Pair {
  private Integer integer;

  private String string;

  //accessors
}

Then:

List<Pair> list = new ArrayList<Pair>();
//...add some Pair objects to the list
Collections.shuffle(list);

When you call put on the map of type Map <Integer,String>, you will get the String returned. So when you do this:

new HashMap<Integer,String>().put(songID, songList.get(i).name);

it will return a String

and when you try to assign it to a map

Map<Integer,String> map 

compiler throws an error,

Type mismatch: cannot convert from String to Map

Here is the signature of put method form javadocs:

public V put(K key,
             V value)

you need to break down the this complex problematic statement:

Map<Integer,String> map = new HashMap<Integer,String>().put(songID, songList.get(i).name);

to something like:

Map<Integer,String> map = new HashMap<Integer,String>();

map.put(songID, songList.get(i).name);

Use the Map<K, V> interface, and the HashMap<K, V> class for example. Or see the "All Known Subinterfaces" section in the Map<K, V> interface description for more implementations.

http://download.oracle.com/javase/6/docs/api/java/util/Map.html

You can simply do:

Iterator<String> it = list.iterator();
while(it.hasNext()) {
    map.put(it.next(), it.next());
}

This will be more efficient than using the get(index) method (in case the list implementation does not allow random access)

This honestly sounds like something I would use a HashMap for. Map.values() will return a collection containing all the values, and you can use .foreach((key, value) -> {...}) on the map to iterate over key-value pairs.

When you say the HashMap is "inefficient" my first question is have you actually tried it? Have you done any benchmarking? Or have you even just tried deploying a version using a HashMap and observed that it isn't performant enough? Is your input size large enough for the random vs. contiguous memory access to truly matter?