Edit: Just realized that if you are actually storing albums as sObjects and can retrieve with SOQL, none of this is necessary. It would be one line:

List<Album> filteredCDs = [ Select Id, Name... etc from Album Where Id in : CDs and Id Not in : LPs ];

Given that, I bet all my assumptions were wrong, eh? Perhaps I should have asked more questions, but hey, nothing like writing a novel about code... while at work... supposedly working on work related code...

The problem with lists is you can only remove items by passing an index. Once it's removed, the indeces are reset, so it's pretty much impossible to iterate through a list and remove items while you're in the same loop.

Here's how I'd do it without maps (and by making big assumptions about your existing code):

private List<Album> filterCDs(List<Album> CDs, List<Album> LPs) {

    List<Album> filteredCDs = new List<Album>();

    for ( Album CD: CDs) {
        for ( Album LP : LPs ) {
            if ( LP.ArtistName != CD.ArtistName && LP.AlbumName != CD.AlbumName )
                filteredCDs .add(CD);
        }
    }

    return filteredCDs;
}

So this doesn't actually remove anything, it just only returns the cds that don't appear in the LP list. If your lists are large, this is crazy inefficient though, with the number of comparisons being CDs.size() * LPs.size().

Maps are not as scary as they seem, and are extremely useful! They're basically the same as a list/array, but can use an index other than an integer. What's cool about maps is you can build one with SOQL, and it gives you a kind of list where each index is the ID of the record.

Here's how I'd do it with a map (assuming albums are an sObject and not just a Class):

private List<Album> filterCDs(List<Album> CDs, List<Album> LPs) {

    Map<Id, Album> LPMap = new Map<Id, Album>([ Select Id from Album where Id in : LPs ]);

   /*
    ^ returns a kind of list where the indexes are the Ids of each record, like:

        LPMap = {
            'albumid0' = Album{
                Id = 'albumid0'
            },
            'alumbid1' = Album{
                Id = 'albumid1'
            },...
        }
    */

    List<Album> filteredCDs = new List<Album>();

    for ( Album CD: CDs) { // iterate through CDs
        if ( !LPMap.containsKey(CD.Id) ) // if the LP map does *not* contain this CD id
            filteredCDs.add(CD); // add it to the new list
    }

    return filteredCDs;
}

Calling LPMap.containsKey(some_album_id) is better than iterating through the entire list and physically checking if an album with the same title/artist is present. It's similar to checking whether or not LPMap.get(some_album_id) == null. And now the number of comparisons is just the size of the CDs list.

Definitely find more info about maps and how to build them manually with .put(key, value). Removing is just .remove(key).

Anyway, hope that makes some amount of sense... I'd have to know more about how you're already organizing things to know whether or not everything I've just typed is utterly useless or not!

I don't know if it's a best practice, but one way to reverse your approach and make a second list of the items you want to keep, then once you're done iterating, reassign that to your primary list.

So, using your code, it would be:

    List<Integer> list = new ArrayList<Integer>();
    list.add(1);
    list.add(2);
    list.add(3);

    List<Integer> listToKeep = new ArrayList<Integer>();

    for (Integer num : list) {
        if (num != 1){
            listToKeep.add(num);
        }
    }

    list = listToKeep;
    System.out.println(list);

A clear and efficient solution would be by using keySet() and removeAll() methods.

Explanation:

map.keyset() will return a reference to the set of keys of the respective map, enabling the interface to use set class methods. which in turn allows us to use the removeAll() method to remove all the keys from the map at once.

Example:

Map <String, String> mapOne = new Map <String, String>();
mapOne.put('key1', 'value1');
mapOne.put('key2', 'value2');
mapOne.put('key3', 'value3');
mapOne.put('key4', 'value4');

Map <String, String> mapTwo = new Map <String, String>();
mapTwo.put('key1', 'value1');
mapTwo.put('key2', 'value2');

System.debug(mapOne);
mapOne.keySet().removeAll(mapTwo.keyset()); // removing elements from map
System.debug(mapOne);

You can rewrite your Strings:

Iterate through words and if you have different words just add them to the end of new strings

    // inside loop
    if (!word1.equals(word2)) {
        str1new += word1;
        str2new += word2;
    }

// outside of loop
s1 = str1new;
s2 = str2new;

Of course you need to add spaces between words. And how do you expect your program will work with strings with differ length?