String クラス

1String s = 'Hello Maximillian';
2String s2 = s.abbreviate(8);
3System.assertEquals('Hello...', s2);
4System.assertEquals(8, s2.length());

1String s = 'Hello Maximillian';
2// Start at M
3String s2 = s.abbreviate(9,6);
4System.assertEquals('...Max...', s2);
5System.assertEquals(9, s2.length());

1String s = 'hello maximillian';
2String s2 = s.capitalize();
3System.assertEquals('Hello maximillian', s2);

1String s = 'hello';
2String s2 = s.center(9);
3System.assertEquals(
4   '  hello  ',
5   s2);

1String s = 'hello';
2String s2 = s.center(9, '-');
3System.assertEquals('--hello--', s2);

1String str = 'Ω is Omega.';
2System.assertEquals(937, str.charAt(0));

1String str = '\uD835\uDD0A';
2System.assertEquals(55349, str.charAt(0), 
3    'charAt(0) didn\'t return the high surrogate.');
4System.assertEquals(120074, str.codePointAt(0),
5    'codePointAt(0) didn\'t return the entire two-character supplementary value.');

1String str = '\u03A9 is Ω (Omega), and \uD835\uDD0A ' + 
2    ' is Fraktur Capital G.';
3System.assertEquals(937, str.codePointAt(0));
4System.assertEquals(120074, str.codePointAt(20));
5// Escaped or unescaped forms of the same character have the same code point
6System.assertEquals(str.codePointAt(0), str.codePointAt(5));

1String str = '\u03A9 is Ω (Omega), and \uD835\uDD0A ' + 
2    ' is Fraktur Capital G.';
3System.assertEquals(937, str.codePointBefore(1));
4System.assertEquals(120074, str.codePointBefore(22));

1String str = '\u03A9 and \uD835\uDD0A characters.';
2System.debug('Count of code points for ' + str.substring(0,1) 
3             + ': ' + str.codePointCount(0,1));
4System.debug('Count of code points for ' + str.substring(6,8) 
5             + ': ' + str.codePointCount(6,8));
6
7// Output:
8// Count of code points for Ω: 1
9// Count of code points for : 1

1String myString1 = 'abcde';
2String myString2 = 'abcd';
3Integer result = 
4   myString1.compareTo(myString2);
5System.assertEquals(result, 1);

1String myString1 = 'abcde';
2String myString2 = 'abcd';
3Boolean result = 
4   myString1.contains(myString2);
5System.assertEquals(result, true);

1String s = 'hello';
2Boolean b1 = s.containsAny('hx');
3Boolean b2 = s.containsAny('x');
4System.assertEquals(true, b1);
5System.assertEquals(false, b2);

1String s = 'hello';
2Boolean b = s.containsIgnoreCase('HE');
3System.assertEquals(
4   true,
5   b);

1String s1 = 'abcde';
2System.assert(s1.containsNone('fg'));

1String s1 = 'abba';
2String s2 = 'abba xyz';
3Boolean b1 = 
4   s1.containsOnly('abcd');
5System.assertEquals(
6   true,
7   b1);
8Boolean b2 = 
9   s2.containsOnly('abcd');
10System.assertEquals(
11   false,
12   b2);

1String s = 'Hello Jane';
2System.assert(s.containsWhitespace()); //true
3s = 'HelloJane ';
4System.assert(s.containsWhitespace()); //true
5s = ' HelloJane';
6System.assert(s.containsWhitespace()); //true
7s = 'HelloJane';
8System.assert(!s.containsWhitespace()); //false

1String s = 'Hello Jane';
2System.assertEquals(1, s.countMatches('Hello'));
3s = 'Hello Hello';
4System.assertEquals(2, s.countMatches('Hello'));
5s = 'Hello hello';
6System.assertEquals(1, s.countMatches('Hello'));

1String s1 = ' Hello Jane ';
2String s2 = 'HelloJane';
3System.assertEquals(s2, s1.deleteWhitespace());

1String s = 'Hello Jane';
2String d1 = 
3   s.difference('Hello Max');
4System.assertEquals(
5   'Max',
6   d1);
7String d2 = 
8   s.difference('Goodbye');
9System.assertEquals(
10   'Goodbye',
11   d2);

1String s = 'Hello Jason';
2System.assert(s.endsWith('Jason'));

1String s = 'Hello Jason';
2System.assert(s.endsWithIgnoreCase('jason'));

1String myString1 = 'abcde';
2String myString2 = 'abcd';
3Boolean result = myString1.equals(myString2);
4System.assertEquals(result, false);

1// Compare a string to an object containing a string
2Object obj1 = 'abc';
3String str = 'abc';
4Boolean result1 = str.equals(obj1);
5System.assertEquals(true, result1);
6
7// Compare a string to an object containing a number
8Integer obj2 = 100;
9Boolean result2 = str.equals(obj2);
10System.assertEquals(false, result2);
11
12// Compare a string to an ID of the same length.
13// 15-character ID
14Id idValue15 = '001D000000Ju1zH';
15// 15-character ID string value
16String stringValue15 = '001D000000Ju1zH';
17Boolean result3 = stringValue15.equals(IdValue15);
18System.assertEquals(true, result3); 
19
20// Compare two equal ID values of different lengths:
21//  15-character ID and 18-character ID
22Id idValue18 = '001D000000Ju1zHIAR';
23Boolean result4 = stringValue15.equals(IdValue18);
24System.assertEquals(true, result4);

1String myString1 = 'abcd';
2String myString2 = 'ABCD';
3Boolean result = 
4myString1.equalsIgnoreCase(myString2);
5System.assertEquals(result, true);

1String s1 = 'Max1, "Max2"';
2String s2 = s1.escapeCsv();
3System.assertEquals('"Max1, ""Max2"""', s2);

1String s1 = '"grade": 3.9/4.0';
2String s2 = s1.escapeEcmaScript();
3System.debug(s2);
4// Output is:
5// \"grade\": 3.9\/4.0
6System.assertEquals(
7   '\\"grade\\": 3.9\\/4.0', 
8    s2);

1String s1 = 
2   '"<Black&White>"';
3String s2 = 
4   s1.escapeHtml3();
5System.debug(s2);
6// Output:
7// &quot;&lt;Black&amp;
8// White&gt;&quot;

1String s1 = 
2   '"<Black&White>"';
3String s2 = 
4   s1.escapeHtml4();
5System.debug(s2);
6// Output:
7// &quot;&lt;Black&amp;
8// White&gt;&quot;

1// Input string contains quotation marks
2String s = 'Company: "Salesforce.com"';
3String escapedStr = s.escapeJava();
4// Output string has the quotes escpaded
5System.assertEquals('Company: \\"Salesforce.com\\"', escapedStr);

1String s = '\'Hello Jason\'';
2system.debug(s); // Outputs 'Hello Jason'
3String escapedStr = String.escapeSingleQuotes(s);
4// Outputs \'Hello Jason\'
5system.debug(escapedStr); 
6// Escapes the string \\\' to string \'
7system.assertEquals('\\\'Hello Jason\\\'', escapedStr);

1String s = 'De onde você é?';
2String escapedStr = s.escapeUnicode();
3System.assertEquals('De onde voc\\u00EA \\u00E9?', escapedStr);

1String s1 = 
2   '"<Black&White>"';
3String s2 = 
4   s1.escapeXml();
5System.debug(s2);
6// Output:
7// &quot;&lt;Black&amp;
8// White&gt;&quot;

1String template = '{0} was last updated {1}';
2List<Object> parameters = new List<Object> {'Universal Containers', DateTime.newInstance(2018, 11, 15) };
3String formatted = String.format(template, parameters);
4System.debug ('Newly formatted string is:' + formatted);

1List<Integer> charArr= new Integer[]{74};
2String convertedChar = String.fromCharArray(charArr);
3System.assertEquals('J', convertedChar);

1String str = 'Jane goes fishing.';
2Integer[] chars = str.getChars();
3// Get the value of 'J'
4System.assertEquals(74, chars[0]);

1List<String> ls = new List<String>{'SFDCApex', 'SFDCVisualforce'};
2String prefix = String.getCommonPrefix(ls);
3System.assertEquals('SFDC', prefix);

1String s = 'Hello Joe';
2Integer i = s.getLevenshteinDistance('Hello Max');
3System.assertEquals(3, i);

1String s = 'Hello Jane';
2Integer i = s.getLevenshteinDistance('Hello Max', 2);
3System.assertEquals(-1, i);

1public class MyCustomClass {
2   String x,y;
3   // Provide a custom hash code
4   public Integer hashCode() {
5    return 
6    (31*x.hashCode())^(y.hashCode());
7   }
8}

1String myString1 = 'abcde';
2String myString2 = 'cd';
3Integer result = myString1.indexOf(mystring2);
4System.assertEquals(2, result);

1String myString1 = 'abcdabcd';
2String myString2 = 'ab';
3Integer result = myString1.indexOf(mystring2, 1);
4System.assertEquals(4, result);

1String s1 = 'abcd';
2String s2 = 'xc';
3Integer result = s1.indexOfAny(s2);
4System.assertEquals(2, result);

1String s1 = 'abcd';
2String s2 = 'xc';
3Integer result = s1.indexOfAnyBut(s2);
4System.assertEquals(0, result);

1String str = '\\u03A9 is Ω (Omega)';
2// Returns 0, which is the first character.
3System.debug('indexOfChar(937)=' + str.indexOfChar(937));
4
5// Output:
6// indexOfChar(937)=0

1String str = 'Ω and \\u03A9 and Ω';
2System.debug('indexOfChar(937)=' + str.indexOfChar(937));
3System.debug('indexOfChar(937,1)=' + str.indexOfChar(937,1));
4System.debug('indexOfChar(937,10)=' + str.indexOfChar(937,10));
5
6// Output:
7// indexOfChar(937)=0
8// indexOfChar(937,1)=6, (corresponds to the escaped form \\u03A9)
9// indexOfChar(937,10)=12

1String s1 = 'abcd';
2String s2 = 'abxc';
3Integer result = s1.indexOfDifference(s2);
4System.assertEquals(2, result);

1String s1 = 'abcd';
2String s2 = 'BC';
3Integer result = s1.indexOfIgnoreCase(s2, 0);
4System.assertEquals(1, result);

1String allLower = 'abcde';
2System.assert(allLower.isAllLowerCase());

1String allUpper = 'ABCDE';
2System.assert(allUpper.isAllUpperCase());

1// Letters only
2String s1 = 'abc';
3// Returns true
4Boolean b1 = 
5   s1.isAlpha();
6System.assertEquals(
7   true, b1);
8
9// Letters and numbers
10String s2 = 'abc 21';
11// Returns false
12Boolean b2 = 
13   s2.isAlpha();
14System.assertEquals(
15   false, b2);