कैसे TextView बोल्ड पर एक विशिष्ट पाठ बनाने के लिए

Question

मुझे नहीं पता कि TextView पर एक विशिष्ट टेक्स्ट कैसे बोल्ड हो जाता है।

ऐसी बात हे

txtResult.setText(id+" "+name);

मैं चाहता हूं कि आउटपुट ऐसा हो:

1111 नील

idऔर nameवे चर हैं जिन्हें मैंने डेटाबेस से मान लिया है, और मैं idइसे बोल्ड बनाना चाहता हूं , लेकिन केवल idइतना ही nameप्रभावित नहीं होगा, मुझे नहीं पता कि यह कैसे करना है।

Comments

संभावित डुप्लिकेट क्या एक TextView के अंदर कई शैलियों का होना संभव है?

— सिरो सेंटिल्ली 郝海东 冠状 iro i 法轮功 '

4 तरीके - TextView बोल्ड पर विशिष्ट स्ट्रिंग - निश्चित रूप से आपकी मदद करते हैं।

— c49

Answer 1

बस HTML में अपनी स्ट्रिंग बनाएँ और इसे सेट करें:

String sourceString = "<b>" + id + "</b> " + name; 
mytextview.setText(Html.fromHtml(sourceString));

Comments

चूंकि एपीआई 24 में एचटीटीपीएलएम (सोर्सस्ट्रिंग) को अपग्रेड किया गया है, आपको अगले कोड का उपयोग करना होगा: स्पैन किए गए अवधि; if (android.os.Build.VERSION.SDK_INT> = android.os.Build.VERSION_CODES.N) {periodSpanned = Html.fromHtml (periodFormed, Html.FROM_HTML_MODE_LEGACY); } और {periodSpanned = Html.fromHtml (periodFormatted); }

— म्लाडेन रकोनजैक

यह एकमात्र विकल्प है जो आपके ऐप को स्थानीय बनाने पर काम करेगा।

— हॉवेटल

इसका एक अच्छा समाधान है, लेकिन मुझे पता चला है कि यह <और> @ wtsang02 समाधान के लिए काम नहीं करता है अधिक इष्टतम है

— उमर बोश्रा

यह साथ काम नहीं करता है <यदि आप String.format का उपयोग करते हैं, तो कम से कम आप ब्रैकेट से बाहर निकलें, जैसा कि यहां वर्णित है ।

— युसुफ एक्स

Html.fromHtml()अब पदावनत हो गया है

— कोई व्यक्ति

Answer 2

जब आप Html.fromHtml () का उपयोग कर सकते हैं तो आप एक अधिक मूल दृष्टिकोण का उपयोग कर सकते हैं जो कि SpannableStringBuilder है , यह पोस्ट सहायक हो सकती है।

SpannableStringBuilder str = new SpannableStringBuilder("Your awesome text");
str.setSpan(new android.text.style.StyleSpan(android.graphics.Typeface.BOLD), INT_START, INT_END, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
TextView tv=new TextView(context);
tv.setText(str);

Comments

यदि यह जवाब काम नहीं करता है तो अपने पाठ को स्पैननेबल स्ट्रिंग के साथ जोड़ने की कोशिश करें जैसे कुछ: mSpannable.append (yourremainingtext);

— गौतम कुमार

बिना किसी पूर्व ज्ञान के Google से आने वाले लोगों के लिए: INT_START / INT_END वह स्थान है जहां पर साहसिक शुरू होना चाहिए और समाप्त होना चाहिए।

— स्पॉटलाइट

यदि आपको इसे बदलने के बिना केवल स्रोत स्ट्रिंग में कुछ मार्कअप लागू करने की आवश्यकता है, तो आप बेहतर SpannableString वर्ग का उपयोग करते हैं

— Buckstabue

यह पूरी तरह से टूट जाएगा यदि आपको अपनी प्रतिलिपि को स्थानीय बनाने की आवश्यकता है। INT_START और INT_END अलग-अलग स्थानीयकरणों में अलग-अलग स्थिति में होंगे।

— Howettl

यह समझने की कोशिश करें कि संदेह होने पर कोड क्या कर रहा है। इंट स्टार्ट एक संख्या है जिसे आप परिभाषित करते हैं, जो स्पैन का स्टार्ट इंडेक्स है। प्रारंभ, स्ट्रिंग के लिए 0 का प्रयास करें। ()। आकार () अंत के लिए।

— वत्संग ०२

Answer 3

पहला: आपको राघव सूद के जवाब से धीमे प्रदर्शन कोड का उपयोग करने के बारे में चिंता करने की आवश्यकता नहीं है ।

दूसरा: आपको w3bshark के उत्तर द्वारा प्रदान किए गए एक्सटेंशन फ़ंक्शन को लिखने की आवश्यकता नहीं है उपयोग करते समय ।

फ़िनलैनी: आपको बस Google से कोटलिन एंड्रॉइड-केटीएक्स लाइब्रेरी का उपयोग करना है ( अधिक जानकारी प्राप्त करने और इसे अपने प्रोजेक्ट में शामिल करने के लिए यहां देखें ):

// Suppose id = 1111 and name = neil (just what you want). 
val s = SpannableStringBuilder()
          .bold { append(id) } 
          .append(name)
txtResult.setText(s) 

उत्पादन: 1111 नील

---

अपडेट करें:

क्योंकि मुझे लगता है कि यह किसी और के साथ-साथ यह प्रदर्शित करने में आपकी मदद कर सकता है कि आप यहां कितनी दूर तक जा सकते हैं।

• जब आपको नीले और इटैलिक में कुछ भागों के साथ पाठ प्रदर्शित करने की आवश्यकता होती है:

  val myCustomizedString = SpannableStringBuilder()
      .color(blueColor, { append("A blue text ") })
      .append("showing that ")
      .italic{ append("it is painless") }

• जब आपको बोल्ड और इटैलिक दोनों में टेक्स्ट प्रदर्शित करने की आवश्यकता होती है:

      bold { italic { append("Bold and italic") } }

संक्षेप में bold, और append, विस्तार कार्य हैं । आप आधिकारिक प्रलेखन में एक और विस्तार कार्य देख सकते हैं , जहाँ से आप अन्य संभावनाओं के लिए सोच सकते हैं।coloritalicSpannableStringBuilder

Comments

यह बहुत अच्छा है और सभी लेकिन मुझे लगता है कि स्ट्रिंग्स से संबंधित हर उत्तर को अनुवाद पर विचार करना चाहिए। वाक्यों में शब्दों को क्रमबद्ध किया जा सकता है और कुछ भाषाओं में पूरी तरह से अलग तरीके से संरचित किया जा सकता है, इसलिए इस तरह की अपील हमेशा कुछ स्थितियों में लागू नहीं होती है। XML में मात्रा स्ट्रिंग्स जैसे सामान के लिए भी आदर्श नहीं है।

— एडवर्ड वैन राक

@CoolMind यह आपको Android KTX का उपयोग करने में असमर्थ बनाता है। आप github.com/android/android-ktx से बग रिपोर्ट कैसे करें, इस बारे में जानकारी प्राप्त कर सकते हैं, एक सुविधा सुझाव दे सकते हैं या उस पुस्तकालय में योगदान कर सकते हैं। तो, यह अभी भी एक वैध संदर्भ है। मैंने लाइब्रेरी के बारे में अधिक जानकारी और इसे अपने प्रोजेक्ट पर उपयोग करने के तरीके के बारे में जानकारी देने के लिए अपना उत्तर अपडेट कर दिया है।

— ब्रिटो

इस आदमी को इस आधुनिक समाधान और संसाधन के लिए एक पदक दें !! धन्यवाद!!!

— Sjd

Answer 4

मैंने सोचा था कि चुना हुआ उत्तर संतोषजनक परिणाम प्रदान नहीं करता है। मैंने अपना स्वयं का फ़ंक्शन लिखा है जिसमें 2 तार लगते हैं; पूर्ण पाठ और पाठ का वह भाग जिसे आप बोल्ड बनाना चाहते हैं।

यह 'textToBold' के साथ 'टेक्स्ट' से बोल्ड होकर एक SpannableStringBuilder देता है।

मुझे टैग में उपयोगी लपेटे बिना एक विकल्प को बोल्ड बनाने की क्षमता मिलती है।

    /**
     * Makes a substring of a string bold.
     * @param text          Full text
     * @param textToBold    Text you want to make bold
     * @return              String with bold substring
     */

    public static SpannableStringBuilder makeSectionOfTextBold(String text, String textToBold){

        SpannableStringBuilder builder=new SpannableStringBuilder();

        if(textToBold.length() > 0 && !textToBold.trim().equals("")){

            //for counting start/end indexes
            String testText = text.toLowerCase(Locale.US);
            String testTextToBold = textToBold.toLowerCase(Locale.US);
            int startingIndex = testText.indexOf(testTextToBold);
            int endingIndex = startingIndex + testTextToBold.length();
            //for counting start/end indexes

            if(startingIndex < 0 || endingIndex <0){
                return builder.append(text);
            }
            else if(startingIndex >= 0 && endingIndex >=0){

                builder.append(text);
                builder.setSpan(new StyleSpan(Typeface.BOLD), startingIndex, endingIndex, 0);
            }
        }else{
            return builder.append(text);
        }

        return builder;
  }

Comments

क्या आप इसे कोड में उपयोग करने का एक उदाहरण प्रदान कर सकते हैं?

— माइक्रो

@ मैक्रो आपको दो स्ट्रिंग्स पास करने की आवश्यकता है, दूसरे स्ट्रिंग को पहले के भीतर निहित पाठ का एक खंड होना चाहिए। जैसे makeSectionOfTextBold ("यह कुछ महान पाठ है।", "महान")।

— लियोन

यदि आप अपना विवरण बदल सकते हैं तो यदि (textToBold! = null &&! textToBold.isEmpty ())

— Arda Kara

यह फ़ंक्शन यह उम्मीद नहीं करता है कि सबस्टेशन पूरे पाठ में कई बार हो सकता है। उदाहरण के लिए "मेरा उपयोगकर्ता नाम है" यह 2 "नाम" को बोल्ड नहीं कर सकता है।

— जादमेक

फिर इस विधि को वास्तव में मेकओल्ड (टेक्स्ट, टेक्स्टबॉल्ड) नाम दिया जाना चाहिए।

— wtsang02

Answer 5

जैसा कि wtsang02 ने कहा, HTML का उपयोग करना एक महंगा ओवरहेड है। बस मूल समाधान का उपयोग करें। यदि आपको स्ट्रिंग को संशोधित करने की आवश्यकता नहीं है, तो बस SpannableString का उपयोग करें, SpannableStringBuilder का नहीं।

String boldText = "id";
String normalText = "name";
SpannableString str = new SpannableString(boldText + normalText);
str.setSpan(new StyleSpan(Typeface.BOLD), 0, boldText.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
textView.setText(str);

Answer 6

यदि आप XML से स्ट्रिंग का उपयोग करना चाहते हैं, तो आप कुछ इस तरह से कर सकते हैं:

strings.xml ("CDATA" भाग महत्वपूर्ण है, अन्यथा यह काम नहीं करेगा)

<string name="test">
     <![CDATA[
 <b>bold!</b> normal
    ]]>
</string>

लेआउट फ़ाइल

<FrameLayout
    xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent" android:layout_height="match_parent" tools:context=".MainActivity">

    <TextView
        android:id="@+id/textView" android:layout_width="wrap_content" android:layout_height="wrap_content"
        android:layout_gravity="center" />

</FrameLayout>

कोड

textView.text = HtmlCompat.fromHtml(getString(R.string.test), HtmlCompat.FROM_HTML_MODE_LEGACY)

Comments

यह मेरे लिए काम करता है <string name="test"><b>text bold</b> other text</string>। काम नहीं करता अगर मैं लिखता हूं<![CDATA[

— सारा

@sara ने फिर से परीक्षण किया, पिक्सेल 2 पर क्यू वर्क्स के साथ ठीक है। यहाँ, मैंने अद्यतन किया कि यह कोटलिन के साथ कैसे काम करता है। कृपया पुन: प्रयास करें।

— Android डेवलपर

यदि आप कस्टम फोंट का उपयोग करते हैं तो यह स्वीकार्य उत्तर है। कूडस को कोटरेट।

— रघुल सुगाथन

Answer 7

इसका सरल उदाहरण के लिए इस तरह निर्दिष्ट पाठ को बंद करें <b>"your text here:"</b>

<string name="headquarters">"<b>"Headquarters:"</b>" Mooresville, North Carolina, U.S.</string>

परिणाम: मुख्यालय: Mooresville, उत्तरी कैरोलिना, अमेरिका

Comments

यह केवल तभी काम करता है जब स्ट्रिंग का उपयोग xml से किया जाता है। यदि इस स्ट्रिंग को प्रोग्रामेटिक रूप से कहा जाता है, तो html एन्कोडिंग दूर हो जाती है।

— स्टारवेट

Answer 8

यदि आप कोटलिन का उपयोग कर रहे हैं, तो इसका उपयोग करना और भी आसान हो जाता है core-ktx, क्योंकि यह करने के लिए एक डोमेन-विशिष्ट-भाषा (DSL) प्रदान करता है :

val string: SpannedString = buildSpannedString {
    bold {
        append("foo")
    }
    append("bar")     
}

इसके द्वारा दिए गए अधिक विकल्प हैं:

append("Hello There")
bold {
    append("bold")
    italic {
        append("bold and italic")
        underline {
            append("then some text with underline")
        }
    }
}

अंत में, आप कर सकते हैं:

textView.text = string

Answer 9

यदि आप कई टेक्स्ट को बोल्ड बनाना चाहते हैं, तो यहां बेहतर समाधान है। मैंने Eitan का कोड सुधार लिया है। धन्यवाद इतन।

public static SpannableStringBuilder makeSectionOfTextBold(String text, String... textToBold) {
    SpannableStringBuilder builder = new SpannableStringBuilder(text);

    for (String textItem :
            textToBold) {
        if (textItem.length() > 0 && !textItem.trim().equals("")) {
            //for counting start/end indexes
            String testText = text.toLowerCase(Locale.US);
            String testTextToBold = textItem.toLowerCase(Locale.US);
            int startingIndex = testText.indexOf(testTextToBold);
            int endingIndex = startingIndex + testTextToBold.length();

            if (startingIndex >= 0 && endingIndex >= 0) {
                builder.setSpan(new StyleSpan(Typeface.BOLD), startingIndex, endingIndex, 0);
            }
        }
    }

    return builder;
}

Answer 10

@ Mladj0ni के जवाब के आधार पर, मुझे काम करने के लिए नीचे कोड मिला। समस्या यह थी कि यदि आप String.format का उपयोग करते हैं , तो यह html मार्कअप को स्ट्रिप्स करता है, इसलिए आपको स्ट्रिंग्स.xml में ब्रैकेट प्रतीकों से बचना होगा:

strings.xml:

<string name="welcome_messages">Hello, %1$s! You have &lt;b>%2$d new messages&lt;/b>.</string>

code.java:

String unspanned = String.format(Locale.US, "%s%s", getResources().getString(R.string. welcome_messages), 99);

Spanned spanned;
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.N) {
    spanned = Html.fromHtml(unspanned, Html.FROM_HTML_MODE_LEGACY);
} else {
    spanned = Html.fromHtml(unspanned);
}

textView.setText(spanned);

यह SpannableStringBuilder की तुलना में सरल है। प्रदर्शन के लिए, यदि आप सिर्फ एक स्ट्रिंग प्रदर्शित कर रहे हैं, तो उपयोगकर्ता अतिरिक्त मिलीसेकंड को पार्स करने के लिए नोटिस नहीं करेगा।

दस्तावेज़ यहाँ देखें ।

Comments

&

— Lt

Answer 11

अपने पाठ का भाग बोल्ड करने के लिए आप इस कोड का उपयोग कर सकते हैं। बोल्ड html टैग के बीच में जो कुछ भी है, वह इसे बोल्ड बना देगा।

String myText = "make this <b>bold</b> and <b>this</b> too";
textView.setText(makeSpannable(myText, "<b>(.+?)</b>", "<b>", "</b>"));

public SpannableStringBuilder makeSpannable(String text, String regex, String startTag, String endTag) {

            StringBuffer sb = new StringBuffer();
            SpannableStringBuilder spannable = new SpannableStringBuilder();

            Pattern pattern = Pattern.compile(regex);
            Matcher matcher = pattern.matcher(text);
            while (matcher.find()) {
                sb.setLength(0);
                String group = matcher.group();
                String spanText = group.substring(startTag.length(), group.length() - endTag.length());
                matcher.appendReplacement(sb, spanText);

                spannable.append(sb.toString());
                int start = spannable.length() - spanText.length();

                spannable.setSpan(new android.text.style.StyleSpan(android.graphics.Typeface.BOLD), start, spannable.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
            }
            sb.setLength(0);
            matcher.appendTail(sb);
            spannable.append(sb.toString());
            return spannable;
        }

Answer 12

public static Spanned getBoldString(String textNotBoldFirst, String textToBold, String textNotBoldLast) {
    String resultant = null;

    resultant = textNotBoldFirst + " " + "<b>" + textToBold + "</b>" + " " + textNotBoldLast;

    return Html.fromHtml(resultant);

}

इसे इस्तेमाल करे। यह निश्चित रूप से मदद कर सकता है

Answer 13

जैसे सूची / पुनर्नवीनीकरण में चार की खोज करते समय स्ट्रिंग स्पैनेबल का पहला चार्ट बनाएं

r a vi और ajay

पहले इस तरह पर प्रकाश डाला, लेकिन मैं नीचे की तरह बनना चाहता था

ravi a nd ajay OR ravi और a jay

इसके लिए मैंने शब्द की लंबाई की खोज की अगर यह 1 के बराबर है, तो मैंने मुख्य स्ट्रिंग को शब्दों में अलग कर दिया और शब्द प्रारंभ की स्थिति की गणना की तो मैंने शब्द को चार से शुरू किया।

 public static SpannableString colorString(int color, String text, String... wordsToColor) {
    SpannableString coloredString = new SpannableString(text);

    for (String word : wordsToColor) {

        Log.e("tokentoken", "-wrd len-" + word.length());
        if (word.length() !=1) {
            int startColorIndex = text.toLowerCase().indexOf(word.toLowerCase());
            int endColorIndex = startColorIndex + word.length();
            try {
                coloredString.setSpan(new ForegroundColorSpan(color), startColorIndex, endColorIndex,
                        Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);

            } catch (Exception e) {
                e.getMessage();
            }
        } else {
            int start = 0;

            for (String token : text.split("[\u00A0 \n]")) {
                if (token.length() > 0) {
                    start = text.indexOf(token, start);
                   // Log.e("tokentoken", "-token-" + token + "   --start--" + start);
                    char x = token.toLowerCase().charAt(0);
                    char w = word.toLowerCase().charAt(0);
                   // Log.e("tokentoken", "-w-" + w + "   --x--" + x);

                    if (x == w) {
                        // int startColorIndex = text.toLowerCase().indexOf(word.toLowerCase());
                        int endColorIndex = start + word.length();
                        try {
                            coloredString.setSpan(new ForegroundColorSpan(color), start, endColorIndex,
                                    Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);

                        } catch (Exception e) {
                            e.getMessage();
                        }
                    }
                }
            }

        }

    }

    return coloredString;
}

Answer 14

मैं यहां एक और अप-टू-डेट समाधान प्रदान करने के लिए आया था, क्योंकि मैं मौजूदा उत्तरों से संतुष्ट नहीं था। मुझे कुछ ऐसी चीज़ों की ज़रूरत थी जो अनुवादित ग्रंथों के लिए काम करें और उपयोग करने के लिए प्रदर्शन हिट न हो Html.fromHtml()। यदि आप Kotlin का उपयोग कर रहे हैं, तो यहां एक एक्सटेंशन फ़ंक्शन है जो आपके टेक्स्ट के कई हिस्सों को आसानी से बोल्ड करने के लिए सेट करेगा । यह मार्कडाउन की तरह ही काम करता है, और जरूरत पड़ने पर अन्य मार्कडाउन टैग का समर्थन करने के लिए इसे बढ़ाया जा सकता है।

val yourString = "**This** is your **string**.".makePartialTextsBold()
val anotherString = getString(R.string.something).makePartialTextsBold()

/**
 * This function requires that the parts of the string that need
 * to be bolded are wrapped in ** and ** tags
 */
fun String.makePartialTextsBold(): SpannableStringBuilder {
    var copy = this
    return SpannableStringBuilder().apply {
        var setSpan = true
        var next: String
        do {
            setSpan = !setSpan
            next = if (length == 0) copy.substringBefore("**", "") else copy.substringBefore("**")
            val start = length
            append(next)
            if (setSpan) {
                setSpan(StyleSpan(Typeface.BOLD), start, length,
                        Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
            }
            copy = copy.removePrefix(next).removePrefix("**")
        } while (copy.isNotEmpty())
    }
}

Answer 15

wtsang02 उत्तर इसके बारे में जाने का सबसे अच्छा तरीका है, क्योंकि, Html.fromHtml ("") अब अपदस्थ है। यहाँ मैं इसे थोड़ा बढ़ाने के लिए जा रहा हूँ, जो किसी को भी गतिशील रूप से पहला शब्द बोल्ड करने में समस्या हो रही है, कोई फर्क नहीं पड़ता कि वाक्य का आकार क्या है।

पहले पहले शब्द को पाने के लिए एक विधि बनाते हैं:

 private String getFirstWord(String input){

    for(int i = 0; i < input.length(); i++){

        if(input.charAt(i) == ' '){

            return input.substring(0, i);
        }
    }

    return input;
}

अब हम कहते हैं कि आपके पास एक लंबा तार है:

String sentence = "[e-mail] want's to be your friend!"

और आप चाहते हैं कि आपकी सजा आपकी पसंद के अनुसार हो। आपको बस इतना करना है- फर्स्टवार्ड प्राप्त करें और पहले वाले को बोल्ड बनाने के लिए इसे प्राप्त करें, कुछ इस प्रकार है:

String myFirstWord = getFirstWord(sentence);
int start = 0; // bold will start at index 0
int end = myFirstWord.length(); // and will finish at whatever the length of your first word

अब बस इस तरह से wtsang02 के चरणों का पालन करें:

SpannableStringBuilder fancySentence = new SpannableStringBuilder(sentence);
fancySentence.setSpan(new android.text.style.StyleSpan(Typeface.BOLD), start, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
textView.setText(fancySentence);

और बस! अब आपको लंबे / छोटे वाक्य से किसी भी आकार के साथ एक शब्द को बोल्ड करने में सक्षम होना चाहिए। आशा है कि यह किसी की मदद करेगा, खुश कोडिंग :)

Answer 16

यह कोटलिन एक्सटेंशन फ़ंक्शन है जो मैं इसके लिए उपयोग करता हूं

/**
 * Sets the specified Typeface Style on the first instance of the specified substring(s)
 * @param one or more [Pair] of [String] and [Typeface] style (e.g. BOLD, ITALIC, etc.)
 */
fun TextView.setSubstringTypeface(vararg textsToStyle: Pair<String, Int>) {
    val spannableString = SpannableString(this.text)
    for (textToStyle in textsToStyle) {
        val startIndex = this.text.toString().indexOf(textToStyle.first)
        val endIndex = startIndex + textToStyle.first.length

        if (startIndex >= 0) {
            spannableString.setSpan(
                StyleSpan(textToStyle.second),
                startIndex,
                endIndex,
                Spannable.SPAN_EXCLUSIVE_EXCLUSIVE
            )
        }
    }
    this.setText(spannableString, TextView.BufferType.SPANNABLE)
}

उपयोग:

text_view.text="something bold"
text_view.setSubstringTypeface(
    Pair(
        "something bold",
        Typeface.BOLD
    )
)

।

text_view.text="something bold something italic"
text_view.setSubstringTypeface(
    Pair(
        "something bold ",
        Typeface.BOLD
    ),
    Pair(
        "something italic",
        Typeface.ITALIC
    )
)

Answer 17

आप बिल्डर में दो स्ट्रिंग्स को अलग-अलग जोड़ सकते हैं, उनमें से एक स्पैनस्ट्रिंग है, दूसरा एक नियमित है। इस तरह से आप अनुक्रमित की गणना नहीं करते हैं।

val instructionPress = resources?.getString(R.string.settings_press)

val okText = resources?.getString(R.string.ok)
val spannableString = SpannableString(okText)

val spannableBuilder = SpannableStringBuilder()
spannableBuilder.append(instructionPress)
spannableBuilder.append(spannableString, StyleSpan(Typeface.BOLD), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)

instructionText.setText(spannableBuilder,TextView.BufferType.SPANNABLE)

Answer 18

यदि बोल्ड टेक्स्ट की स्थिति निर्धारित है (उदाहरण: यदि टेक्स्ट व्यू की शुरुआत है), तो एक ही पृष्ठभूमि के साथ दो अलग-अलग टेक्स्ट व्यू का उपयोग करें। तो फिर आप अन्य textView के textStyle को बोल्ड बना सकते हैं।

इसके लिए किसी एकल टेक्स्ट व्यू की तुलना में दो बार मेमोरी की आवश्यकता होगी लेकिन गति बढ़ जाएगी।

Answer 19

मैंने TextView टेक्स्ट और EditText के लिए टेक्स्ट बोल्ड का हिस्सा स्थापित करने के लिए एक स्थिर विधि बनाई है

public static void boldPartOfText(View mView, String contentData, int startIndex, int endIndex){
        if(!contentData.isEmpty() && contentData.length() > endIndex) {
            final SpannableStringBuilder sb = new SpannableStringBuilder(contentData);

            final StyleSpan bss = new StyleSpan(Typeface.BOLD); // Span to make text bold
            final StyleSpan iss = new StyleSpan(Typeface.NORMAL); //Span to make text normal
            sb.setSpan(iss, 0, startIndex, Spanned.SPAN_INCLUSIVE_INCLUSIVE);
            sb.setSpan(bss, startIndex, endIndex, Spannable.SPAN_INCLUSIVE_INCLUSIVE); // make first 4 characters Bold
            sb.setSpan(iss,endIndex, contentData.length()-1, Spanned.SPAN_INCLUSIVE_INCLUSIVE);

            if(mView instanceof TextView)
               ((TextView) mView).setText(sb);
            else if(mView instanceof EditText)
               ((EditText) mView).setText(sb);

        }
    }

एक और अधिक अनुकूलित कोड

  /*typeFaceStyle can be passed as 

    Typeface.NORMAL = 0;
    Typeface.BOLD = 1;
    Typeface.ITALIC = 2;
    Typeface.BOLD_ITALIC = 3;*/

    public static void boldPartOfText(View mView, String contentData, int startIndex, int endIndex,int typeFaceStyle){
        if(!contentData.isEmpty() && contentData.length() > endIndex) {
            final SpannableStringBuilder sb = new SpannableStringBuilder(contentData);

            final StyleSpan bss = new StyleSpan(typeFaceStyle); // Span to make text bold
            final StyleSpan iss = new StyleSpan(Typeface.NORMAL); //Span to make text italic
            sb.setSpan(iss, 0, startIndex, Spanned.SPAN_INCLUSIVE_INCLUSIVE);
            sb.setSpan(bss, startIndex, endIndex, Spannable.SPAN_INCLUSIVE_INCLUSIVE); // make first 4 characters Bold
            sb.setSpan(iss,endIndex,contentData.length()-1,Spanned.SPAN_INCLUSIVE_INCLUSIVE);

            if(mView instanceof TextView)
                ((TextView) mView).setText(sb);
            else if(mView instanceof EditText)
                ((EditText) mView).setText(sb);
        }
    }

Answer 20

मामले में कोई व्यक्ति डेटा बाइंडिंग का उपयोग कर रहा है। हम बाइंडिंग एडॉप्टर को इस तरह परिभाषित कर सकते हैं

@BindingAdapter("html")
fun setHtml(view: TextView, html: String) {
    view.setText(HtmlCompat.fromHtml(html, HtmlCompat.FROM_HTML_MODE_LEGACY))
}

तब हम इसका उपयोग TextView पर कर सकते हैं

app:html="@{@string/bold_text}"

जहाँ bold_text है

<string name="bold_text"><![CDATA[Part of text is <b>bold</b>]]></string>

Comments

आप "setHtml" फ़ंक्शन कहाँ लिखते हैं?

— Android डेवलपर

developer.android.com/topic/lbooks/data-binding/… यह मूल रूप से कोई भी वर्ग है, जब तक आपके पास एनोटेशन है

— logcat

ओह यह मेरे लिए बहुत अजीब है। धन्यवाद। क्या आप जानते हैं कि इस विषय के नए लोगों के लिए एक अच्छा ट्यूटोरियल / नमूना है?

— Android डेवलपर

मैं ट्यूटोरियल के बारे में नहीं जानता। बस google "android BindingAdapter"

— logcat

Answer 21

यदि आप कई भाषाओं में स्थानीयकरण को संभालना चाहते हैं, तो यह एक तरीका है, लेकिन ऐसा करना उबाऊ है, लेकिन यह काम करता है, मान लीजिए कि हम यह चाहते हैं:

अंग्रेजी में:

कोई भुगतान पंजीकृत नहीं हैं

स्पेनिश में:

नो हय पगोस रेजिस्ट्रडोस

आपको 3 तार बनाने होंगे

अंग्रेज़ी:

<string name="start_string">There are no</string>
<string name="middle_string">payments</string>
<string name="end_string">registered.</string>
<string name="string_format" translatable="false">%1$s %2$s %3$s</string>

स्पेनिश:

<string name="start_string">No hay</string>
<string name="middle_string">pagos</string>
<string name="end_string">registrados</string>

अब आप यह कर सकते हैं:

val startSpanPosition = getString(R.string.start_string).length
val endSpanPosition = startSpanPosition + getString(R.string.middle_string).length
val mySpannableString = SpannableStringBuilder(String.format(getString(R.string.string_format),
        getString(R.string.start_string), getString(R.string.middle_string))), getString(R.string.end_string)))

mySpannableString.setSpan(StyleSpan(Typeface.BOLD), spanStartPosition, endSpanPosition, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)

Answer 22

आपका स्ट्रिंग संसाधन

<resources>
   <string name="your_string_resource_name">This is normal text<![CDATA[<b> but this is bold </b>]]> and <![CDATA[<u> but this is underline text</u>]]></string>
</resources> 

आपका जावा वर्ग

yourtextView.setText(getString(R.string.your_string_resource_name));

Answer 23

यहां केस चेक के साथ गतिशील स्ट्रिंग मानों के लिए मेरा पूरा समाधान है।

/**
 * Makes a portion of String formatted in BOLD.
 *
 * @param completeString       String from which a portion needs to be extracted and formatted.<br> eg. I am BOLD.
 * @param targetStringToFormat Target String value to format. <br>eg. BOLD
 * @param matchCase Match by target character case or not. If true, BOLD != bold
 * @return A string with a portion formatted in BOLD. <br> I am <b>BOLD</b>.
 */
public static SpannableStringBuilder formatAStringPortionInBold(String completeString, String targetStringToFormat, boolean matchCase) {
    //Null complete string return empty
    if (TextUtils.isEmpty(completeString)) {
        return new SpannableStringBuilder("");
    }

    SpannableStringBuilder str = new SpannableStringBuilder(completeString);
    int start_index = 0;

    //if matchCase is true, match exact string
    if (matchCase) {
        if (TextUtils.isEmpty(targetStringToFormat) || !completeString.contains(targetStringToFormat)) {
            return str;
        }

        start_index = str.toString().indexOf(targetStringToFormat);
    } else {
        //else find in lower cases
        if (TextUtils.isEmpty(targetStringToFormat) || !completeString.toLowerCase().contains(targetStringToFormat.toLowerCase())) {
            return str;
        }

        start_index = str.toString().toLowerCase().indexOf(targetStringToFormat.toLowerCase());
    }

    int end_index = start_index + targetStringToFormat.length();
    str.setSpan(new StyleSpan(BOLD), start_index, end_index, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
    return str;
}

उदाहरण के लिए। completeString = "मैं बोल्ड हूँ"

CASE I अगर *targetStringToFormat* = "bold"और*matchCase* = true

रिटर्न "मैं बोल्ड हूं" (बोल्ड! = बोल्ड)

मामला II यदि *targetStringToFormat* = "bold"और*matchCase* = false

रिटर्न "मैं बोल्ड हूँ "

लगा देना:

myTextView.setText(formatAStringPortionInBold("I am BOLD", "bold", false))

उम्मीद है की वो मदद करदे!