File editing program

Naming
You should give your classes and variable meaningful names.

Class names should not be verbs, but rather nouns - SwitchTo also doesn't really convey what the class does - DatabaseConfigurationSwitcher will do a better job.

Variable names like file, total and newText might be technically accurate, but they don't help the reader know what they mean - currentPropertiesFileContents, newPropertiesFileContents and selectedUser would better convey meaning, and will make your code a lot easier to read.

You should always abide by the naming conventions of you language of choice - camelCase for java variables - newdb is a bad variable name. File is worse.

There is no need to repeat the type of the container in its name: schemas is better than schemaMap.

Redundant code
You found a very curious way to assign the newText variable - you are actually assigning it <num of args> + 1 times! There is no need to assign it with "", and definitely no need to override it arg.length times a simple:

String newText = args[args.length - 1];

would do. The only reason I can think of which might have driven you to this strange code is your fear that args will be empty, in which case you can add:

String newText = (args == null || args.length == 0) ? "" : args[args.length - 1];

Of course, as @chillworld suggested, both are wrong, as you should check that there is exactly one argument so:

if (args.length != 1) throw new Exception("Give only one argument");
String newText = args[0];

Assumptions
For some reason, you assume that the username and password are always equal, and known at compile time. If that is the case, you could have made you life easier and instead of commenting and un-commenting lines in your code you could simply re-write the section, since you know its values:

test.properties

#local
db.url=jdbc:oracle:thin:@localhost:test

#### overwrite everything below this line with db.user=user;db.password=user ####
db.user=testa
db.password=testa

Of course, a better solution would be not to assume that you know either the username or the password at compile time, and use an external repository to hold this information (even the properties file itself could be it, as @chillworld suggested).

String concatenation
Using a String variable to collect all the lines in your code is not a good idea, as it results in a lot of new objects being built. A StringBuilder is a better type to do that, but in your situation.

Close your resources
You open a file reader, and then a file writer, but you never close them! This is very problematic, since you leave open file handles which may result in a serious memory leak. It is true that java will close all open handles when the process exits, but you should never count on that!

Don't catch what you can't handle
You have a try block, and two catch clauses, which do nothing but output the exception to the console.
A better way would be to declare main(String[] args) throws FileNotFoundException, IOException, and not even write the try block.
This way, in case of an error, not only will its stack trace be printed in the console (via the error stream), but the console will also be notifies that the command ended abnormally, and the command users will be able to refer to that (looking at the errorlevel).

I suggest to add some meta-information in comments as follows:

#local
db.url=jdbc:oracle:thin:@localhost:test

#begin_schema: a
#db.user=testa
#db.password=testa
#end_schema

#other unchangeable properties
some.property.a=value1
some.property.b=value2

#begin_schema: b
db.user=testb
db.password=testb
#end_schema

so, the comments #begin_schema/#end_schema will demarcates the boundary of blocks for facilitation of parse and process.

here is my solution:

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class SchemaSwitcher {

    static final Pattern BEGIN_PATTERN = Pattern.compile("^#*\\s*begin_schema:\\s*(.+)\\s*$");
    static final Pattern END_PATTERN = Pattern.compile("^#*\\s*end_schema.*$");

    static enum State {NO_OP, ADD_COMMENT, REM_COMMENT}

    public static void main(String[] args) throws Exception {
        String fileName = args[0];
        String schema = args[1];
        Path path = Paths.get(fileName);
        Files.write(path, switchSchema(Files.readAllLines(path), schema));
    }

    static List<String> switchSchema(List<String> lines, String schema) {
        State state = State.NO_OP;
        for (int i = 0; i < lines.size(); i++) {
            String line = lines.get(i);
            switch (state) {
                case NO_OP:
                    Matcher matcher = BEGIN_PATTERN.matcher(line);
                    if (matcher.matches()) {
                        state = schema.equals(matcher.group(1)) ? State.REM_COMMENT : State.ADD_COMMENT;
                    }
                    break;
                case ADD_COMMENT:
                    if (END_PATTERN.matcher(line).matches()) {
                        state = State.NO_OP;
                    } else {
                        if (!line.startsWith("#")) line = "#" + line;
                    }
                    break;
                case REM_COMMENT:
                    if (END_PATTERN.matcher(line).matches()) {
                        state = State.NO_OP;
                    } else {
                        while (line.startsWith("#")) line = line.substring(1);
                    }
                    break;
            }
            lines.set(i, line);
        }
        return lines;
    }
}