So erstellen Sie einen bestimmten Text in TextView BOLD


251

Ich weiß nicht, wie ich einen bestimmten Text in TextView fett machen soll.

es ist so

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

Ich möchte, dass die Ausgabe folgendermaßen aussieht:

1111 neil

idund namesind Variablen, die ich den Wert aus der Datenbank abgerufen habe, und ich möchte die idzu fett machen, aber nur die, iddamit die namenicht betroffen sind, ich habe keine Ahnung, wie das geht.



Antworten:


379

Erstellen Sie einfach Ihren String in HTML und legen Sie ihn fest:

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

5
Da fromHtml (sourceString) in API 24 veraltet ist, müssen Sie den nächsten Code verwenden: Spanned durationSpanned; if (android.os.Build.VERSION.SDK_INT> = android.os.Build.VERSION_CODES.N) {durationSpanned = Html.fromHtml (durationFormatted, Html.FROM_HTML_MODE_LEGACY); } else {durationSpanned = Html.fromHtml (durationFormatted); }
Mladen Rakonjac

2
Dies ist die einzige Option, die funktioniert, wenn Sie Ihre App lokalisieren.
Howettl

Es ist eine gute Lösung, aber ich fand heraus, dass es nicht funktioniert für <und> @ wtsang02 Lösung ist optimaler
Omar Boshra

Es funktioniert nicht mit <WENN Sie String.format verwenden, es sei denn, Sie entkommen auch der Klammer, wie hier beschrieben .
Yusuf X

5
Html.fromHtml()ist jetzt veraltet
Jemand irgendwo

384

Während Sie Html.fromHtml () verwenden können , können Sie einen nativeren Ansatz verwenden , nämlich SpannableStringBuilder. Dieser Beitrag kann jedoch hilfreich sein.

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);

Wenn diese Antwort nicht funktioniert, versuchen Sie, Ihren Text mit einer spannbaren Zeichenfolge anzuhängen: mSpannable.append (Ihr verbleibender Text);
Gowtham Kumar

10
Für Personen, die ohne Vorkenntnisse von Google kommen: INT_START / INT_END ist der Ort, an dem der Fettdruck beginnen und enden soll.
Spotlight

2
Wenn Sie nur ein Markup auf die Quellzeichenfolge anwenden müssen, ohne sie zu ändern, verwenden Sie besser die SpannableString-Klasse
Buckstabue

26
Dies wird vollständig unterbrochen, wenn Sie Ihre Kopie lokalisieren müssen. INT_START und INT_END sind unterschiedliche Positionen in unterschiedlichen Lokalisierungen.
Howettl

4
Versuchen Sie zu verstehen, was der Code im Zweifelsfall tut. Der int start ist eine von Ihnen definierte Zahl, die den Startindex der Spanne darstellt. Versuchen Sie 0 für Start, Zeichenfolge. (). Größe () für Ende.
wtsang02

85

Erstens: Sie müssen sich keine Gedanken über die Verwendung des langsamen Leistungscodes aus der Antwort von Raghav Sood machen .

Zweitens: Sie müssen keine Erweiterungsfunktion schreiben, die durch die Antwort von w3bshark bereitgestellt wird , wenn Sie Kotlin verwenden.

Finnaly: Alles , was Sie tun müssen, ist die Kotlin verwenden Android-ktx Bibliothek von Google (siehe hier , um weitere Informationen und wie Sie sind es auf Ihrem Projekt zu finden):

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

Produziert: 1111 Neil


AKTUALISIEREN:

Weil ich denke, es kann jemand anderem helfen und zeigen, wie weit Sie hier gehen können, gibt es mehr Anwendungsfälle.

  • Wenn Sie einen Text mit einigen Teilen in Blau und Kursiv anzeigen müssen:

    val myCustomizedString = SpannableStringBuilder()
        .color(blueColor, { append("A blue text ") })
        .append("showing that ")
        .italic{ append("it is painless") }
    
  • Wenn Sie einen Text fett und kursiv anzeigen müssen:

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

Kurz gesagt bold, append, colorund italicsind Erweiterungsfunktionen SpannableStringBuilder. Weitere Erweiterungsfunktionen finden Sie in der offiziellen Dokumentation , von wo aus Sie nach anderen Möglichkeiten suchen können.


Das ist großartig und alles andere als ich denke, dass jede Antwort in Bezug auf Zeichenfolgen Übersetzungen berücksichtigen sollte. Wörter in Sätzen können in einigen Sprachen völlig anders geordnet und strukturiert werden, sodass das Anhängen in bestimmten Situationen nicht immer möglich ist. Auch nicht ideal für Dinge wie Mengenzeichenfolgen in XML.
Edward van Raak

1
@CoolMind Sie können Android KTX nicht verwenden. Unter github.com/android/android-ktx finden Sie Informationen dazu, wie Sie Fehler melden, einen Funktionsvorschlag machen oder zu dieser Bibliothek beitragen können. Es ist also immer noch eine gültige Referenz. Ich habe meine Antwort aktualisiert, um weitere Informationen zur Bibliothek und deren Verwendung in Ihrem Projekt aufzunehmen.
Filipe Brito

1
Gib diesem Kerl eine Medaille für diese moderne Lösung und Ressource !! Vielen Dank!!!
Sjd

37

Ich dachte, dass die gewählte Antwort kein zufriedenstellendes Ergebnis lieferte. Ich habe meine eigene Funktion geschrieben, die 2 Zeichenfolgen benötigt. Der vollständige Text und der Teil des Textes, den Sie fett machen möchten.

Es wird ein SpannableStringBuilder zurückgegeben, bei dem 'textToBold' von 'text' fett gedruckt ist.

Ich finde die Möglichkeit, einen Teilstring fett zu machen, ohne ihn in Tags zu verpacken, nützlich.

    /**
     * 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;
  }

Können Sie ein Beispiel dafür geben, wie dies im Code verwendet wird?
Micro

2
@MicroR Sie müssen zwei Zeichenfolgen übergeben, die zweite Zeichenfolge muss ein Textabschnitt sein, der in der ersten enthalten ist. zB makeSectionOfTextBold ("Dies ist ein großartiger Text.", "großartig").
Leon

1
Sie sollten Ihre if-Anweisung mit if (textToBold! = null &&! textToBold.isEmpty ()) ändern
Arda Kara

2
Diese Funktion erwartet nicht, dass der Teilstring mehrmals im Volltext vorkommen kann. Zum Beispiel kann in "Mein Benutzername ist Name" der 2. "Name" nicht fett gedruckt werden.
Jadamec

1
Dann sollte diese Methode eigentlich makeAllBold (text, textToBold) heißen.
wtsang02

29

Wie wtsang02 sagte, ist die Verwendung von HTML ein teurer Aufwand. Verwenden Sie einfach die native Lösung. Wenn Sie die Zeichenfolge nicht ändern müssen, verwenden Sie einfach SpannableString und nicht 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);

23

Wenn Sie die Zeichenfolge aus XML verwenden möchten, können Sie Folgendes tun:

string.xml (der Teil "CDATA" ist wichtig, sonst funktioniert er nicht)

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

Layoutdatei

<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>

Code

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

Das funktioniert bei mir <string name="test"><b>text bold</b> other text</string>. Funktioniert nicht, wenn ich schreibe<![CDATA[
Sara

@sara Jetzt erneut getestet, auf Pixel 2 mit Q. Funktioniert einwandfrei. Hier habe ich aktualisiert, wie es mit Kotlin funktioniert. Bitte versuche es erneut.
Android-Entwickler

Dies ist die akzeptable Antwort, wenn Sie benutzerdefinierte Schriftarten verwenden. Kudus an den Schöpfer.
Raghul Sugathan

13

Es ist einfach, einfach den angegebenen Text wie folgt zu schließen <b>"your text here:"</b>

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

Ergebnis: Hauptsitz: Mooresville, North Carolina, USA


Dies funktioniert nur, wenn eine Zeichenfolge aus XML verwendet wird. Wenn diese Zeichenfolge programmgesteuert aufgerufen wird, wird die HTML-Codierung entfernt.
Starwave

11

Wenn Sie Kotlin verwenden, wird die Verwendung noch einfacher core-ktx, da hierfür eine domänenspezifische Sprache (DSL) bereitgestellt wird:

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

Weitere Optionen sind:

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

Endlich können Sie einfach:

textView.text = string

10

Hier ist eine bessere Lösung, wenn Sie mehrere Texte fett formatieren möchten. Ich habe Eitans Code verbessert. danke 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;
}

8

Basierend auf der Antwort von @ mladj0ni habe ich den folgenden Code zum Laufen gebracht. Das Problem war, dass bei Verwendung von String.format das HTML-Markup entfernt wird, sodass Sie die Klammer-Symbole in strings.xml umgehen müssen:

string.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);

Es ist einfacher als SpannableStringBuilder. Wenn Sie nur eine Zeichenfolge anzeigen, bemerkt der Benutzer die zusätzliche Millisekunde zum Parsen nicht.

Siehe die Dokumentation hier .


Vielen Dank für & lt; b> ... & lt; / b>
am

4

Mit diesem Code können Sie einen Teil Ihres Textes fett setzen. Für alles, was sich zwischen den fett gedruckten HTML-Tags befindet, wird es fett gedruckt.

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;
        }

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

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

    return Html.fromHtml(resultant);

}

Versuche dies. Es kann definitiv helfen


3

Machen Sie das erste Zeichen der Zeichenfolge spannbar, während Sie nach Zeichen in Liste / Recycler suchen

r a vi und ajay

zuvor so hervorgehoben, aber ich wollte wie unten sein

Ravi a nd ajay OR Ravi und ein jay

Dafür habe ich nach der Wortlänge gesucht, wenn sie gleich 1 ist. Ich habe die Hauptzeichenfolge in Wörter getrennt und die Wortstartposition berechnet. Dann habe ich nach Wörtern gesucht, die mit char beginnen.

 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;
}

3

Ich bin hierher gekommen, um eine aktuellere Lösung anzubieten, weil ich mit den vorhandenen Antworten nicht zufrieden war. Ich brauchte etwas, das für übersetzte Texte funktioniert und nicht den Leistungseinbruch hat, den ich habe Html.fromHtml(). Wenn Sie Kotlin verwenden, finden Sie hier eine Erweiterungsfunktion, mit der mehrere Teile Ihres Textes leicht fett gedruckt werden können . Dies funktioniert genau wie Markdown und kann bei Bedarf erweitert werden, um andere Markdown-Tags zu unterstützen.

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())
    }
}

3

Die Antwort wtsang02 ist der beste Weg, da Html.fromHtml ("") jetzt veraltet ist. Hier werde ich es nur ein wenig verbessern, für alle, die Probleme haben, das erste Wort dynamisch fett zu machen, unabhängig von der Größe des Satzes.

Zuerst erstellen wir eine Methode, um das erste Wort zu erhalten:

 private String getFirstWord(String input){

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

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

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

    return input;
}

Angenommen, Sie haben eine lange Zeichenfolge wie diese:

String sentence = "friendsAwesomeName@gmail.com want's to be your friend!"

Und du willst, dass dein Satz so ist wie deinAwesomeName@gmail.com will dein Freund sein! Alles, was Sie tun müssen, ist, das erste Wort zu erhalten und die Länge zu ermitteln, um das erste Wort fett zu machen.

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

Befolgen Sie nun einfach die Schritte von wtsang02 wie folgt :

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

Und das ist es! Jetzt sollten Sie in der Lage sein, ein Wort mit einer beliebigen Größe aus einem langen / kurzen Satz fett zu schreiben. Hoffe es wird jemandem helfen, fröhliches Codieren :)


3

Dies ist die Kotlin-Erweiterungsfunktion, die ich dafür verwende

/**
 * 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)
}

Verwendung:

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
    )
)

2

Sie können die beiden Zeichenfolgen im Builder separat hinzufügen. Eine davon ist spannedString, die andere ist eine reguläre Zeichenfolge. Auf diese Weise müssen Sie die Indizes nicht berechnen.

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)

2

Wenn die Position von fettem Text festgelegt ist (z. B. wenn am Anfang der Textansicht steht), verwenden Sie zwei verschiedene Textansichten mit demselben Hintergrund. Dann können Sie den textStyle der anderen textView fett formatieren.

Dies erfordert doppelt so viel Speicher wie eine einzelne Textansicht, aber die Geschwindigkeit erhöht sich.


1

Ich habe eine statische Methode zum Festlegen eines Teils des Textes Fett für TextView und EditText erstellt

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);

        }
    }

Ein weiterer kundenspezifischerer Code

  /*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);
        }
    }

1

Falls jemand die Datenbindung verwendet. Wir können den Bindungsadapter so definieren

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

Dann können wir es in einer Textansicht verwenden

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

wo fett_text ist

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

Wo schreiben Sie die Funktion "setHtml"?
Android-Entwickler

developer.android.com/topic/libraries/data-binding/… Es ist im Grunde jede Klasse, solange Sie Anmerkungen haben
logcat

Oh, das ist so komisch für mich. Danke dir. Kennen Sie vielleicht ein nettes Tutorial / Beispiel für Neulinge dieses Themas?
Android-Entwickler

Ich kenne keine Tutorials. Google einfach "android BindingAdapter"
logcat

1

Es ist langweilig, einen Weg zu finden, falls Sie mit der Lokalisierung in mehreren Sprachen umgehen möchten. Es funktioniert jedoch. Nehmen wir an, wir möchten Folgendes:

Auf Englisch:

Es sind keine Zahlungen registriert

In Spanisch:

Keine Heupagos registrados

Sie müssen 3 Zeichenfolgen erstellen

Englisch:

<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>

Spanisch:

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

Jetzt können Sie dies tun:

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)

1

Ihre String-Ressource

<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> 

Ihre Java-Klasse

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

0

Hier ist meine Komplettlösung für dynamische String-Werte mit Fallprüfung.

/**
 * 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;
}

Z.B. completeString = "Ich bin mutig"

FALL I wenn *targetStringToFormat* = "bold"und*matchCase* = true

gibt "I am BOLD" zurück (da fett! = BOLD)

FALL II wenn *targetStringToFormat* = "bold"und*matchCase* = false

gibt "Ich bin mutig " zurück

Bewerben:

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

Hoffentlich hilft das!

Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.