7
स्ट्रिंग वर्ग कुछ तरीकों कि मैं नहीं समझ सकता है कि वे इस तरह से लागू किया गया है ... की जगह उनमें से एक है।JVM स्ट्रिंग तरीकों कार्यान्वयन
public String replace(CharSequence target, CharSequence replacement) {
return Pattern.compile(target.toString(), Pattern.LITERAL).matcher(
this).replaceAll(Matcher.quoteReplacement(replacement.toString()));
}
क्या सरल और अधिक कुशल (तेज़!) विधि पर कुछ महत्वपूर्ण फायदे हैं?
public static String replace(String string, String searchFor, String replaceWith) {
StringBuilder result=new StringBuilder();
int index=0;
int beginIndex=0;
while((index=string.indexOf(searchFor, index))!=-1){
result.append(string.substring(beginIndex, index)+replaceWith);
index+=searchFor.length();
beginIndex=index;
}
result.append(string.substring(beginIndex, string.length()));
return result.toString();
}
आँकड़े जावा 7 के साथ: "AXC"
टाइम्स:
string.replace:
1000000 पुनरावृत्तियों
साथ "x" "abc" में
परिणाम "बी" की जगह 485ms
string.replaceAll: 490ms
वें तरह की जगह = 180ms
कोड अनुकूलित
public String replaceAll(String regex, String replacement) {
return Pattern.compile(regex).matcher(this).replaceAll(replacement);
}
विभाजन कार्यान्वयन होना चाहिए::
public String[] split(String regex, int limit) {
return Pattern.compile(regex).split(this, limit);
}
public String[] split(String regex, int limit) {
/* fastpath if the regex is a
(1)one-char String and this character is not one of the
RegEx's meta characters ".$|()[{^?*+\\", or
(2)two-char String and the first char is the backslash and
the second is not the ascii digit or ascii letter.
*/
char ch = 0;
if (((regex.value.length == 1 &&
".$|()[{^?*+\\".indexOf(ch = regex.charAt(0)) == -1) ||
(regex.length() == 2 &&
regex.charAt(0) == '\\' &&
(((ch = regex.charAt(1))-'0')|('9'-ch)) < 0 &&
((ch-'a')|('z'-ch)) < 0 &&
((ch-'A')|('Z'-ch)) < 0)) &&
(ch < Character.MIN_HIGH_SURROGATE ||
ch > Character.MAX_LOW_SURROGATE))
{
int off = 0;
int next = 0;
boolean limited = limit > 0;
ArrayList<String> list = new ArrayList<>();
while ((next = indexOf(ch, off)) != -1) {
if (!limited || list.size() < limit - 1) {
list.add(substring(off, next));
off = next + 1;
} else { // last one
//assert (list.size() == limit - 1);
list.add(substring(off, value.length));
off = value.length;
break;
}
}
// If no match was found, return this
if (off == 0)
return new String[]{this};
// Add remaining segment
if (!limited || list.size() < limit)
list.add(substring(off, value.length));
// Construct result
int resultSize = list.size();
if (limit == 0)
while (resultSize > 0 && list.get(resultSize - 1).length() == 0)
resultSize--;
String[] result = new String[resultSize];
return list.subList(0, resultSize).toArray(result);
}
return Pattern.compile(regex).split(this, limit);
}
की जगह विधि के तर्क के बाद: ई जावा 7 विभाजन विधि भारी पैटर्न संकलन/regex प्रसंस्करण से बचने के लिए जब संभव अनुकूलित है
प्रदर्शन हानि प्रतिस्थापन विधियों पर पाए गए लोगों से बहुत दूर नहीं हैं। किसी कारण से ओरेकल कुछ तरीकों पर नहीं, बल्कि कुछ अन्य तरीकों पर फास्टपाथ दृष्टिकोण देता है।
"जावा मूल विधि के कार्यान्वयन के कारण क्या हैं?" <- जावा टीम से पूछें? –
उनकी 'प्रतिस्थापन() 'उनके' replaceAll()' का उपयोग करता है। वहां क्या गलत है? प्रतिस्थापन के लिए कोड डुप्लिकेट क्यों करें? –
विधि दक्षता? – marcolopes