como criar um texto específico no TextView BOLD

252

Não sei como transformar um texto específico no TextView em BOLD.

É tipo isso

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

Eu quero que a saída seja assim:

1111 neil

ide namesão variáveis ​​que recuperei o valor do banco de dados e desejo que o idnegrito seja, mas apenas o idque namenão será afetado, não tenho idéia de como fazer isso.

Budi Darmawan
fonte
1
Possível duplicata de É possível ter vários estilos dentro de um TextView?
Ciro Santilli publicou em
4 maneiras - seqüência específica no TextView negrito - Definitivamente ajudá-lo.
c49 4/06

Respostas:

379

Basta criar sua String em HTML e configurá-la:

String sourceString = "<b>" + id + "</b> " + name; 
mytextview.setText(Html.fromHtml(sourceString));
Raghav Sood
fonte
5
Como fromHtml (sourceString) está obsoleto na API 24, você deve usar o próximo código: 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
Essa é a única opção que funcionará se você estiver localizando seu aplicativo.
howettl
Sua solução de um bom, mas eu descobri que não funciona para <e> @ wtsang02 solução é mais ideal
Omar Boshra
Não funciona com <SE você usa String.format, a menos que você também escape do suporte, conforme descrito aqui .
Yusuf X
5
Html.fromHtml()agora está obsoleto
Someone Somewhere
384

Embora você possa usar Html.fromHtml (), você pode usar uma abordagem mais nativa, que é SpannableStringBuilder , esta publicação pode ser útil.

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);
wtsang02
fonte
Se essa resposta não funcionar, tente anexar seu texto com uma string que pode ser estendida, algo como: mSpannable.append (yourremainingtext);
Gowtham Kumar
10
Para pessoas vindas do Google sem conhecimento prévio: INT_START / INT_END é o local onde o negrito deve começar e terminar.
Spotlight
2
se você só precisa aplicar alguma marcação na string de origem sem alterá-la, é melhor usar a classe
SpannableString
26
Isso será interrompido completamente se você precisar localizar sua cópia. INT_START e INT_END terão posições diferentes em diferentes localizações.
howettl
4
Tente entender o que o código está fazendo quando estiver em dúvida. O int start é um número que você define, que é o índice inicial do período. Tente 0 para iniciar, string. (). Tamanho () para final.
Wtsang02 17/05/19
85

Primeiro: você não precisa se preocupar em usar o código de desempenho lento da resposta do Raghav Sood .

Segundo: você não precisa escrever uma função de extensão fornecida pela resposta do w3bshark ao usar o Kotlin.

Finnaly: Tudo que você precisa fazer é usar a biblioteca android-ktx Kotlin do Google (consulte aqui para obter mais informações e como incluí-la em seu projeto):

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

Produção: 1111 neil


ATUALIZAR:

Porque acho que isso pode ajudar alguém e demonstrar até onde você pode ir aqui há mais casos de uso.

  • Quando você precisar exibir um texto com algumas partes em azul e itálico:

    val myCustomizedString = SpannableStringBuilder()
        .color(blueColor, { append("A blue text ") })
        .append("showing that ")
        .italic{ append("it is painless") }
    
  • Quando você precisar exibir um texto em negrito e itálico:

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

Em suma, bold, append, colore italicsão funções de extensão para SpannableStringBuilder. Você pode ver outras funções de extensão na documentação oficial , de onde você pode pensar em outras possibilidades.

Filipe Brito
fonte
Isso é ótimo e tudo, mas acho que todas as respostas relacionadas a strings devem considerar traduções. As palavras nas frases podem ser ordenadas e estruturadas de maneira completamente diferente em alguns idiomas, portanto, anexar assim nem sempre é aplicável em determinadas situações. Também não é ideal para coisas como seqüências de quantidade em XML.
Edward van Raak
1
@CoolMind Isso não o torna incapaz de usar o Android KTX. Você pode encontrar informações em github.com/android/android-ktx sobre como reportar erros, fazer uma sugestão de recurso ou contribuir com essa biblioteca. Portanto, ainda é uma referência válida. Atualizei minha resposta para incluir mais informações sobre a biblioteca e como usá-la em seu projeto.
Filipe Brito
1
dê a esse cara uma medalha por esta solução e recurso modernos !! obrigado!!!
Sjd 12/06
37

Eu pensei que a resposta escolhida não forneceu um resultado satisfatório. Eu escrevi minha própria função, que tem 2 strings; O texto completo e a parte do texto que você deseja colocar em negrito.

Ele retorna um SpannableStringBuilder com o 'textToBold' de 'text' em negrito.

Acho que a capacidade de tornar uma substring em negrito sem envolvê-la em tags é útil.

    /**
     * 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;
  }
Eitan
fonte
Você pode fornecer um exemplo de como usar isso no código?
Micro
2
@MicroR Você precisa passar duas Strings, a segunda String precisa ser uma seção de texto contida na primeira. por exemplo, makeSectionOfTextBold ("Este é um ótimo texto.", "ótimo").
Leon
1
você deve mudar a sua declaração se com if (textToBold = null && textToBold.isEmpty ()!)
Arda Kara
2
Esta função não espera que a substring possa ocorrer no texto completo várias vezes. Por exemplo, em "Meu nome de usuário é nome", não é possível colocar o segundo "nome" em negrito.
Jadamec
1
Em seguida, esse método deve ser chamado de makeAllBold (text, textToBold).
wtsang02
30

Como disse wtsang02, o uso de HTML é uma sobrecarga cara. Basta usar a solução nativa. Se você não precisar modificar a sequência, use SpannableString, não 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);
Jadamec
fonte
23

Caso deseje usar a string do XML, você pode fazer algo assim:

strings.xml (a parte "CDATA" é importante, caso contrário não funcionará)

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

arquivo de layout

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

código

textView.text = HtmlCompat.fromHtml(getString(R.string.test), HtmlCompat.FROM_HTML_MODE_LEGACY)
desenvolvedor android
fonte
Isso funciona para mim <string name="test"><b>text bold</b> other text</string>. Não funciona se eu escrever<![CDATA[
sara
@sara Testado novamente agora, no Pixel 2 com Q. Funciona bem. Aqui, atualizei como ele funciona com o Kotlin. Por favor, tente novamente.
desenvolvedor android
Essa é a resposta aceitável se você usar fontes personalizadas. Kudus para o creater.
Raghul Sugathan
13

É simples apenas fechar o texto especificado como este, por exemplo <b>"your text here:"</b>

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

Resultado: Sede: Mooresville, Carolina do Norte, EUA

Ridha Rezzag
fonte
Isso funciona apenas se a string for usada no xml. Se essa string for chamada programaticamente, a codificação html será removida.
Starwave
11

Se você estiver usando o Kotlin, fica ainda mais fácil usar core-ktx, pois fornece uma linguagem específica de domínio (DSL) para fazer isso:

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

Mais opções fornecidas por ele são:

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

Por fim, você pode apenas:

textView.text = string
Devansh Maurya
fonte
10

Aqui está uma solução melhor, se você quiser colocar vários textos em negrito. Eu melhorei o código de Eitan. obrigado 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;
}
Krish
fonte
8

Com base na resposta de @ mladj0ni, obtive o código abaixo para funcionar. O problema era que, se você usar String.format , retira a marcação html, portanto, você precisa escapar dos símbolos de colchete em strings.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);

É mais simples que o SpannableStringBuilder. Quanto ao desempenho, se você estiver exibindo apenas uma sequência, o usuário não notará o milissegundo extra para analisá-la.

Veja a documentação aqui .

Yusuf X
fonte
Obrigado por & lt; b> ... & lt; / b>
oxied
4

Você pode usar esse código para definir parte do seu texto em negrito. Para o que quer que esteja entre as tags html em negrito, ele ficará em negrito.

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;
        }
amor ao vivo
fonte
3
public static Spanned getBoldString(String textNotBoldFirst, String textToBold, String textNotBoldLast) {
    String resultant = null;

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

    return Html.fromHtml(resultant);

}

Tente isso. Pode ajudar definitivamente

Saad Bilal
fonte
3

Torne o primeiro caractere da string extensível enquanto procura por char na lista / reciclador, como

r a vi e ajay

destacando anteriormente como este, mas eu queria ser como abaixo

Ravi um Ajay nd OU Ravi e um jay

Para isso, procurei o comprimento da palavra, se for igual a 1, separei a sequência principal em palavras e calculei a posição inicial da palavra, depois procurei a palavra começando com char.

 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;
}
Sagar
fonte
3

Eu vim aqui para fornecer uma solução mais atualizada, porque não estava satisfeito com as respostas existentes. Eu precisava de algo que funcionasse para textos traduzidos e não tem o desempenho de usar Html.fromHtml(). Se você estiver usando o Kotlin, aqui está uma função de extensão que definirá facilmente várias partes do seu texto para negrito . Isso funciona como o Markdown e pode ser estendido para suportar outras tags do Markdown, se necessário.

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())
    }
}
w3bshark
fonte
3

A resposta wtsang02 é a melhor maneira de fazer isso, pois o Html.fromHtml ("") agora está obsoleto. Aqui, eu apenas vou aprimorá-lo um pouco para quem está tendo problemas para tornar dinamicamente a primeira palavra em negrito, independentemente do tamanho da frase.

Primeiro vamos criar um método para obter a primeira palavra:

 private String getFirstWord(String input){

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

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

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

    return input;
}

Agora, digamos que você tenha uma sequência longa como esta:

String sentence = "[email protected] want's to be your friend!"

E você quer que sua frase seja como [email protected] quer ser sua amiga! Tudo o que você precisa fazer é obter a primeira palavra e obter o comprimento necessário para tornar a primeira palavra em negrito, algo como isto:

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

Agora basta seguir os passos do wtsang02 , desta maneira:

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

E é isso! Agora você deve poder colocar uma palavra em negrito com qualquer tamanho, de sentença longa / curta. Espero que ajude alguém, feliz codificação :)

Junia Montana
fonte
3

Esta é a função de extensão Kotlin que eu uso para isso

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

Uso:

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
    )
)
aaronmarino
fonte
2

Você pode adicionar as duas strings separadamente no construtor, uma delas é spannedString e a outra é regular. Dessa forma, você não precisa calcular os índices.

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)
Велина Дервентска
fonte
2

se a posição do texto em negrito for fixa (ex: se estiver no início do textView), use dois textView diferentes com o mesmo plano de fundo. Em seguida, você pode tornar o textStyle do outro textView em negrito.

Isso exigirá o dobro da memória em comparação com um único textView, mas a velocidade aumentará.

neens
fonte
1

Eu criei um método estático para definir parte do texto em negrito para TextView e 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);

        }
    }

Outro código mais personalizado

  /*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);
        }
    }
Zar E Ahmer
fonte
1

Caso alguém esteja usando vinculação de dados. Podemos definir um adaptador de ligação como este

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

Em seguida, podemos usá-lo em um TextView

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

onde bold_text é

<string name="bold_text"><![CDATA[Part of text is <b>bold</b>]]></string>
logcat
fonte
Onde você escreve a função "setHtml"?
desenvolvedor android
developer.android.com/topic/libraries/data-binding/… É basicamente qualquer classe, desde que você tenha anotação
logcat
Oh, isso é tão estranho para mim. Obrigado. Você conhece talvez um bom tutorial / exemplo para iniciantes neste tópico?
desenvolvedor android
Eu não sei de tutoriais. Apenas google "android BindingAdapter"
logcat
1

Foi encontrada uma maneira, caso você queira lidar com a localização em vários idiomas, é chato, mas funciona, vamos supor que queremos isso:

Em inglês:

Não há pagamentos registrados

Em espanhol:

No hay pago registrado

Você tem que criar 3 strings

Inglês:

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

Espanhol:

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

Agora você pode fazer isso:

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)
Jesus Almaral - Hackaprende
fonte
1

Seu recurso String

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

sua classe java

yourtextView.setText(getString(R.string.your_string_resource_name));
Yıldırım
fonte
0

Aqui está minha solução completa para valores dinâmicos de String com verificação de caso.

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

Por exemplo. completeString = "Estou em negrito"

CASO I se *targetStringToFormat* = "bold"e*matchCase* = true

retorna "Estou em negrito" (pois em negrito! = Negrito)

CASO II se *targetStringToFormat* = "bold"e*matchCase* = false

retorna "eu sou corajoso "

Aplicar:

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

Espero que ajude!

sud007
fonte