I am new to java. Trying to create a function to remove a given string "arg" from myString which is previously set and return a new string not affecting myString. I believe i could solve this problem if it was not for all non alphabetical character of arg should remain in the string. so if arg has a 7 in it that should still be included in the final string. characters being removed are case insensitive as well. I have messed around with the code so much I am now unable to run it. and feel i have complicated things for myself. please help!

public String remove(String arg) {
    char[] arrayOfArg = arg.toCharArray();
    String newArg = "";

    if (myString == null || myString == "") {
        this.myString="";
    }

    if (myString != null) {
        for (int i = 0; i < arrayOfArg.length; i  ) {
             if (boolean arrayOfArg([i]) = Character.isLetter(arrayOfArg[i])) {
                 String newArg= newArg arrayOfArg[i];
             }
         }

         String newString = myString.replaceAll(newArg, "");
     }

     return newString;

CodePudding user response：

I believe i could solve this problem if it was not for all non alphabetical character of arg should remain in the string.

The good news is that you can solve it yourself.

The bad news is that the code above is in such a mess that it would be difficult for you to fix it by yourself. (Given your current level understand of Java syntax, way of working, etcetera.)

(Also, there is a long more wrong than the "if it were not for ..." ...)

So here is what I advise you to do.

1. Save a copy of the current version of the (entire) class somewhere safe so that you can look it again if you need to, or revert to it.

2. Develop a model of what the method needs to do and how it will do it; see below.

3. Delete all lines of code between the first { and last } shown in the question. Yes. Delete them.

4. Compose the new version of the code, one line at a time. As follows:

   1. Add a line.

   2. Compile the code (or let the IDE compile it for you).

   3. Read the compilation error(s) that just appeared.

   4. Understand the compilation errors.

   5. Make the necessary changes to fix the compilation errors. Don't rely on your IDE's facility for suggesting corrections. (The IDE doesn't understand your code, what you are going to add next, or what you are trying to achieve. Its suggestions are liable to be unhelpful or even wrong.)

   6. Repeat until you have dealt with all of the compilation errors that were introduced.

   7. Now you are ready to add another line.

5. Once you have a complete method, you can then try to run it.

You will most likely find that the code doesn't work. But at least it will be valid Java code. And in the process of doing 4. above, you will (hopefully!) have learned enough Java syntax to be able to read and understand the code that you wrote. And 2. will help you understand what the code you are writing should do.

My other observation is that it looks like you have been adding and removing statements to this code with no clear understanding of what they do or what needs to happen. Maybe you started with some code that did something else ... correctly ... but it is hard to tell now.

Changing things randomly to try to make the code work is not a sensible approach. It rarely works. You need to have a model (or plan) in your head or on paper (as pseudo-code) about how the code ought to work.

Programming is about 1) developing the model, then 2) translating the model into code. The first part is the hard (and interesting) part. But if you skip the first part, the second part is an essentially random process, and unlikely to succeed.

The problem with starting with someone else's code is that you risk not developing a mental model of how that code works. Let alone the model that you are aiming for.

Finally, a professional programmer will use a version control system for their source code, and make relatively frequent commits of their code to their repository. Among other things, that allows them to quickly "roll back" to an earlier version if they need to, or keep track of exactly what they changed.

It is probably too early for you to learn about (say) using Git ... but it would help you solve your problem if you could just "roll back" all of the changes where you were "messing" with the code to get it to work.

CodePudding user response：

Here is one way using streams. Just create a stream of characters via the chars() method and allow only letters to pass thru. Then each character to a String and join them together. Then remove that result from the original passed string.

String myString = "abcdTLK123efgh";
String arg = "TLK@@@123";
String result = remove(arg, myString);
System.out.println("Result = "   result);

prints

Result = abcd123efgh

The method

• I modified the method to accept two strings.
  • the one to remove characters(arg).
  • and the from which to remove modified arg from myString
• it works by
  • streaming all the characters of arg.
  • filtering out all but letters and digits
  • joining them as a string.
  • and then removing that filtered string from the myString.

public static String remove(String arg, String myString) {
    if (myString == null || myString.isBlank()) {
        return "";
    }
    return arg.chars().filter(
            ch -> Character.isLetter(ch))
            .mapToObj(Character::toString)
            .collect(Collectors.collectingAndThen(
                    Collectors.joining(),
                    str -> myString.replace(str, "")));
}

Note: If myString is null then assigning an empty string to it will contain nothing to change. Nor an initial empty string. So I just returned an empty String if those conditions existed.