搜索并从数组中删除项目

Question

Does anyone why when the search value matches a value stored in array it doesn't remove that item?

String titles = "";
String lengths = "";

for (int i = 0; i < numOfSongs; i++) {
    titles += songTitles[i] + " ";
    lengths += songLengths[i] + " ";
}

String search = JOptionPane.showInputDialog("Enter a song title to remove it or -1 to end:");

while (!search.equals("-1")) {  
    for (int i = 0; i < numOfSongs; i++) {
        if (search.equalsIgnoreCase(songTitles[i])) {
            songTitles[i] = songTitles[i + 1];
        }
    }
    numOfSongs--;

    JOptionPane.showMessageDialog(null, "**Current Playlist**" + "\nSong titles: " + titles + "\nSong lengths: " + lengths);

    search = JOptionPane.showInputDialog("Enter a song title to remove it or -1 to end:");
} 

Answer 1

Many things are wrong with this code:

1. You never update titles and lengths inside your while loop, so whatever happens inside has no effect on what's printed in the dialog
2. When you find song title to remove, you copy the next song title to the current one, but don't copy anything else, so [a, b, c, d] will after removing b change to [a, c, c, d] - you need to shift everything behind the deleted element left by one position
3. When you find song title to remove, you assume the i+1 th position is valid - this isn't true if you remove the last song on the list, that would either fail with ArrayIndexOutOfBounds exception or copy some garbage from behind the currently valid playlist
4. You're never updating songLengths array
5. Concatenating strings in a loop using += is very ineffective - use StringBuilder instead

Answer 2

Sorry this took a while, but hopefully it's pretty comprehensive.

I am assuming that song title and song length are supposed to correspond with one another, so that if you remove the title you also remove the length? It may be good to create a class, eg Song, which has a field for both title and length. There are more methods you can add, eg setters, default constructor, etc. You can also include more fields like Song Artist, year, etc. I'm just including those required for your program to run.

I'll use red's suggestion of an ArrayList, so you can see what they meant (in case you haven't learned what that is)

public class Song {
    String title; //these are known as fields, or instance variables
    String length;

    public Song(String title, String length) {
        this.title = title;
        this.length = length;
    }

    public String getTitle() {
        return title;
    }

    public String getLength() {
        return length;
    }

    //you can format this differently. Just keeping it simple though. If you don't include toString() method in this class, you will run into some problems if you try to print the object itself. 
    public String toString() {
        return "title = " + title + " length = " + length + "\n";
    }

From here, in your main method you can do...

ArrayList<Song> playlist = new ArrayList<>();

//here, inside a do-while loop, get input for each song, then store into strings, let's call them songTitle and songLength. I'm not showing this step since I don't know where you want the input to come from, but I'm sure you can figure this bit out. ;)

Then we create objects and add them to your list like so:

Song song = new Song(songTitle, songLength); //creates a new object with arguments songTitle and songLength
playlist.add(song); //adds object to array list.

Once you have your playlist set up, we return to your question regarding song removal, and here is where Lists(there are different ones you can use)/Objects really make things far simpler.

Iterator<Song> songIt = playlist.iterator();
while (!search.equals("-1") && songIt.hasNext()) {
    if (search.equalsIgnoreCase(songIt.next().getTitle())) {
        songIt.remove();
    }
}

And printing is simple too.

for (int i = 0; i < playlist.size(); i++) {
    System.out.println(playlist.get(i);
}

-EDIT-

To put into perspective, here is what you would have to do for removal in your program using array and without objects.

int removeCount = 0;
while (!search.equals("-1")) {
    for (int i = 0; i < songTitles.length; i++) {
        if (search.equalsIgnoreCase(songTitles[i])) {
             for (int j = i; j < songTitles.length - 1; j++) {
                songTitles[j] = songTitles[j + 1];
                songLengths[j] = songLengths[j + 1];
                removeCount ++;
            }
        }
    }
}

String remainingTitles[] = new String[songTitles.length - removeCount];
String remainingLengths[] = new String[songTitles.length - removeCount];
for (int i = 0; i < temp.length; i++) {
    remainingTitles[i] = songTitles[i];
    remainingLengths[i] = songLengths[i];
}

Suffice it to say, this is much more ugly, and there's many more places where you can make a stupid mistake that may or may not throw an exception.