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);

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!

Salesforce prohitbits (or at least used to do that earlier) removing items from list while traversing it.

So, the solution would be to create another list, store all desired elements in there. For e.g.

List<CompanyInfo> companyinfos=new List<companyinfos>();
List<CompanyInfo> finalList=new List<companyinfos>();
companyinfos.add(***);
....

integer index=0;
For(CompanyInfo info: companyinfos)
{

    if(info.item!=****)
    {
        finalList.add(info);
    }
}  
companyinfos = finalList;