• String.contains() which checks if the string contains a specified sequence of char values
• String.indexOf() which returns the index within the string of the first occurence of the specified character or substring (there are 4 variations of this method)

That's because you're comparing the whole String, and apparently you seem to be thinking it checks every substring split at the space which honestly doesn't work that way (it would be unintuitive too).

So,

String one= "ROLEAWARDS ROLEMOVIES ROLENOMINATIONS"; 
String two = "ROLENOMINATIONS ROLEAWARDS ROLEMOVIES";

String[] oneSplit = one.split(" ");
String[] twoSplit = two.split(" ");
boolean contains = false;
for(int i = 0; i < oneSplit.length; i++)
{
    for(int j = 0; j < twoSplit.length; j++)
    {
        if(oneSplit[i].contains(twoSplit[j])
        {
            contains = true;
            break;
        }
    }
}
if(contains)
{
    System.out.println("Contains");
}
else
{
    System.out.println("Doesn't Contain");
}

As mentioned in my comment to your question, you may use String#contains().

    String testString = "cor1210";
    // will not print yes, because none of the sequences fit
    if (testString.contains("cpr") || testString.contains("cvr") || testString.contains("nr")) {
        System.out.println("yes");
    }

Make sure your logic-syntax in the if-clause is correct.

I'm wondering to know if there is better solution for it?

There are lots of algorithms for simple string searching; see the Wikipedia String Search page. The page includes complexity characterizations ... and references.

The standard Java java.lang.String implementation uses naive search under the hood. Some of the algorithms on the Wikipedia page that have better complexity for the search phase, but require non-trivial setup. I expect that the Sun/Oracle engineers have done extensive empirical testing and found that naive search works best on average over a wide range of real-world applications.

Finally ...

I know the brute force approach with the time complexity of O(n*m)

In fact, that is the worst case complexity. The average complexity is O(n). Consider this:

boolean bruteForceMatch (String str1, String str2) {
    for (int i = 0; i < str.length(); i++) {
        boolean matches = true;
        for (int j = 0; j < str2.length(); j++) {
            if (i + j >= str.length || 
                str1.charAt(i + j) != str2.charAt(j)) {
                matched = false;
                break;
            }
        }
        if (matched) {
            return true;
        }
    }
    return false;
}

The worst case happens with inputs like "AAA..." and "AAA...B". (The dots denote repetition.)

But in the average case (e.g. randomly generated input strings) you won't have an "almost match" for str2 at every position of str1. The inner loop will typically break in the iteration.

The cleanest way to implement this is using StringUtils.containsAny(String, String)

package com.sandbox;

import org.apache.commons.lang.StringUtils;
import org.junit.Test;

import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;

public class SandboxTest {

    @Test
    public void testQuestionInput() {
        assertTrue(StringUtils.containsAny("39823839A983923", "ABCDEFGH"));
        assertTrue(StringUtils.containsAny("A", "ABCDEFGH"));
        assertTrue(StringUtils.containsAny("ABCDEFGH", "ABCDEFGH"));
        assertTrue(StringUtils.containsAny("AB", "ABCDEFGH"));
        assertFalse(StringUtils.containsAny("39823839983923", "ABCDEFGH"));
        assertFalse(StringUtils.containsAny("", "ABCDEFGH"));
    }

}

Maven dependency:

    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
        <version>3.5</version>
    </dependency>

How about matches()?

String string = "Madam, I am Adam";

// Starts with
boolean  b = string.startsWith("Mad");  // true

// Ends with
b = string.endsWith("dam");             // true

// Anywhere
b = string.indexOf("I am") >= 0;        // true

// To ignore case, regular expressions must be used

// Starts with
b = string.matches("(?i)mad.*");

// Ends with
b = string.matches("(?i).*adam");

// Anywhere
b = string.matches("(?i).*i am.*");

fullstring.contains(testStr)

To avoid NullPointerExceptions, use an if statement and && operator:

if (fullstring != null && fullstring.contains(testStr)) {
    // your logic
}

If fullstring is null, the second part won't execute.

Edit: I thought null was falsy.

import org.apache.commons.lang.StringUtils;

String Utils

Use:

StringUtils.indexOfAny(inputString, new String[]{item1, item2, item3})

It will return the index of the string found or -1 if none is found.