String target = "FOOBar";
target = target.replaceAll("(?i)foo", "");
System.out.println(target);

Output:

Bar

It's worth mentioning that replaceAll treats the first argument as a regex pattern, which can cause unexpected results. To solve this, also use Pattern.quote as suggested in the comments.

The option to replace case insensitive regex in java is Pattern.CASE_INSENSITIVE, which can also be specified as (?i)

(http://boards.developerforce.com/t5/Apex-Code-Development/Why-Pattern-CASE-INSENSITIVE-not-detectable/td-p/204337)

String srcStr = '{!id} value {!Id} is not {!ID}';
String replaceToken = '(?i)\\{!id\\}';
System.debug('REPLACEMENT ' + srcStr.replaceAll(replaceToken, ''));
System.assertEquals('  value  is not ', srcStr.replaceAll(replaceToken, ''));

You can also match case insensitive regexs and make it more readable by using the Pattern.CASE_INSENSITIVE constant like:

Pattern mypattern = Pattern.compile(MYREGEX, Pattern.CASE_INSENSITIVE);
Matcher mymatcher= mypattern.matcher(mystring);

Just add the "case insensitive" switch to the regex:

html.replaceAll("(?i)"+label, "WINDOWS");

Note: If the label could contain characters with special regex significance, eg if label was ".*", but you want the label treated as plain text (ie not a regex), add regex quotes around the label, either

html.replaceAll("(?i)\\Q" + label + "\\E", "WINDOWS");

or

html.replaceAll("(?i)" + Pattern.quote(label), "WINDOWS");

To do case-insensitive search and replace, you can change

outText = inText.replaceAll(word, word.replaceAll(" ", "~"));

into

outText = inText.replaceAll("(?i)" + word, word.replaceAll(" ", "~"));

Avoid ruining the original capitalization:

In the above approach however, you're ruining the capitalization of the replaced word. Here is a better suggestion:

String inText="Sony Ericsson is a leading company in mobile. " +
              "The company sony ericsson was found in oct 2001";
String word = "sony ericsson";

Pattern p = Pattern.compile(word, Pattern.CASE_INSENSITIVE);
Matcher m = p.matcher(inText);

StringBuffer sb = new StringBuffer();

while (m.find()) {
  String replacement = m.group().replace(' ', '~');
  m.appendReplacement(sb, Matcher.quoteReplacement(replacement));
}
m.appendTail(sb);

String outText = sb.toString();

System.out.println(outText);

Output:

Sony~Ericsson is a leading company in mobile.
The company sony~ericsson was found in oct 2001

Your code is pretty complicated. The simplest, albeit slow algorithm is:

public static String toUpper(String str, String word) {
    String result = "";
    int i = 0;
    while (i < str.length()) {
        if (i + word.length() <= str.length()
            && str.substring(i, i + word.length()).equalsIgnoreCase(word)) {

            result += word.toUpperCase();
            i += word.length();
        } else {
            result += str.charAt(i);
            i++;
        }
    }
    return result;
}

The above code may or may not work as expected for Turkish (dotless i) and German (Straße -> STRASSE), but all other languages should be fine.

Your code contains many duplicate lines, which is considered bad style because some day, someone will change one of the lines but not the other, and then your code does almost the same in the two different cases.

Do not compare strings with ==. In Java you have to write it in an uglier way: str1.equals(str2), or in your particular case str.isEmpty().

Your problem is that you're defining a regex with CASE_SENSITIVE flag but not using it correctly in replaceAll method.

You can also use (?i) in the middle of the regex for ignore case match of back-reference \1 like this:

String repl = "Hello hello".replaceAll("\\b(\\w+)(\\W+(?i:\\1)\\b)+", "$1");
//=> Hello

And then use Matcher.replaceAll later.

Working Code:

public class DuplicateWords {

    public static void main(String[] args) {

        String regex = "\\b(\\w+)(\\W+(?i:\\1)\\b)+";
        Pattern p = Pattern.compile(regex);

        // OR this one also works
        // String regex = "\\b(\\w+)(\\W+\\1\\b)+";
        // Pattern p = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);

        Scanner in = new Scanner(System.in);
        int numSentences = Integer.parseInt(in.nextLine());

        while (numSentences-- > 0) {
            String input = in.nextLine();

            Matcher m = p.matcher(input);

            // Check for subsequences of input that match the compiled pattern
            if (m.find()) {
                input = m.replaceAll("$1");
            }

            // Prints the modified sentence.
            System.out.println(input);
        }
        in.close();
    }
}

You can use replaceAll with (?i) which will do case-insensitive replace.

String str = "Software Industry. software Industry. SOFTWARE INDUSTRY. "+
                                                    "software industry. "
str = str.replaceAll("(?i)(software industry)", "\\*$1\\*");