TextView의 특정 텍스트를 BOLD로 만드는 방법을 모르겠습니다.
이것처럼
txtResult.setText(id+" "+name);
출력이 다음과 같기를 원합니다.
1111 닐
id
그리고 name
나는 데이터베이스에서 값을 검색 한 변수가 있고, 내가 만들고 싶어 id
굵게, 그러나 단지 id
이 때문에 name
영향을받지 않습니다, 나는이 작업을 수행하는 방법을 모르겠어요.
TextView의 특정 텍스트를 BOLD로 만드는 방법을 모르겠습니다.
이것처럼
txtResult.setText(id+" "+name);
출력이 다음과 같기를 원합니다.
1111 닐
id
그리고 name
나는 데이터베이스에서 값을 검색 한 변수가 있고, 내가 만들고 싶어 id
굵게, 그러나 단지 id
이 때문에 name
영향을받지 않습니다, 나는이 작업을 수행하는 방법을 모르겠어요.
답변:
HTML로 문자열을 작성하고 설정하십시오.
String sourceString = "<b>" + id + "</b> " + name;
mytextview.setText(Html.fromHtml(sourceString));
Html.fromHtml()
더 이상 사용되지 않습니다
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);
첫째 : Raghav Sood의 답변 에서 성능이 느린 코드를 사용하는 것에 대해 걱정할 필요가 없습니다 .
둘째 : Kotlin을 사용할 때 w3bshark의 답변에서 제공하는 확장 기능을 작성할 필요가 없습니다 .
Finnaly : Google 의 Kotlin android-ktx 라이브러리 를 사용하기 만하면 됩니다 ( 자세한 내용 및 프로젝트에 포함시키는 방법 은 여기 참조 ).
// 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
, color
및 italic
확장 기능에 있습니다 SpannableStringBuilder
. 공식 문서 에서 다른 가능성을 생각할 수있는 다른 확장 기능을 볼 수 있습니다 .
선택한 답변이 만족스러운 결과를 제공하지 못한다고 생각했습니다. 나는 2 개의 문자열을 취하는 내 자신의 함수를 작성했습니다. 전체 텍스트 및 굵게 표시하려는 텍스트 부분.
'text'의 '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;
}
wtsang02가 말했듯이 HTML을 사용하는 것은 비용이 많이 드는 오버 헤드입니다. 기본 솔루션을 사용하십시오. 문자열을 수정할 필요가 없으면 SpannableStringBuilder가 아닌 SpannableString을 사용하십시오.
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);
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)
<string name="test"><b>text bold</b> other text</string>
. 내가 글을 쓰면 작동하지 않습니다<![CDATA[
Kotlin을 사용 하는 경우이를 수행하기위한 DSL (Domain-Specific-language) 을 core-ktx
제공 하므로을 사용하면 훨씬 쉽게 수행 할 수 있습니다.
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
여러 텍스트를 굵게 표시하려면 더 나은 해결책이 있습니다. Eitan의 코드를 개선했습니다. 고마워 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;
}
@ mladj0ni의 답변을 바탕으로 아래 코드가 작동합니다. 문제는 String.format 을 사용 하면 html 태그를 제거하므로 strings.xml에서 대괄호 기호를 이스케이프해야한다는 것입니다.
strings.xml :
<string name="welcome_messages">Hello, %1$s! You have <b>%2$d new messages</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보다 간단합니다. 성능과 관련하여 문자열을 하나만 표시하면 구문 분석에 추가 밀리 초가 표시되지 않습니다.
이 코드를 사용하여 텍스트의 일부를 굵게 설정할 수 있습니다. 굵은 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;
}
다음과 같이 list / recycler에서 char을 검색하는 동안 문자열의 첫 번째 문자를 확장 가능하게 만듭니다.
R a vi와 ajay
이전에 이와 같이 강조했지만 아래에 있고 싶었습니다.
라비 차 아제 또는 라비와 제이
이를 위해 1과 같은 경우 단어 길이를 검색하고 기본 문자열을 단어로 분리하고 단어 시작 위치를 계산 한 다음 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;
}
기존 답변에 만족하지 않았기 때문에 최신 솔루션을 제공하기 위해 여기에 왔습니다. 번역 된 텍스트에 작동하고 성능을 발휘하지 못하는 무언가가 필요했습니다 Html.fromHtml()
. Kotlin을 사용하는 경우 텍스트의 여러 부분을 굵게 표시 하는 확장 기능이 있습니다 . 이것은 Markdown과 동일하게 작동하며 필요한 경우 다른 Markdown 태그를 지원하도록 확장 될 수 있습니다.
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())
}
}
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 = "friendsAwesomeName@gmail.com want's to be your friend!"
그리고 당신은 당신의 문장이 yourAwesomeName@gmail.com 이 친구가 되기를 원하는 것처럼 되기를 원합니다! firstWord를 가져 와서 firstWord를 굵게 만들려면 다음과 같이하십시오.
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);
그리고 그게 다야! 이제 긴 문장이나 짧은 문장에서 어떤 크기의 단어라도 굵게 표시 할 수 있습니다. 그것이 누군가에게 도움이되기를 바랍니다, 행복한 코딩 :)
이것이 내가 사용하는 Kotlin 확장 기능입니다
/**
* 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
)
)
빌더에서 두 문자열을 별도로 추가 할 수 있습니다. 하나는 spannedString이고 다른 하나는 일반 문자열입니다. 이러한 방식으로 인덱스를 계산할 필요가 없습니다.
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)
에 대한 정적 메서드를 만들었습니다 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);
}
}
누군가 데이터 바인딩을 사용하는 경우. 다음과 같이 바인딩 어댑터를 정의 할 수 있습니다
@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>
여러 언어로 현지화를 처리하려는 경우를 대비 한 방법을 찾았지만 지루하지만 작동하지만 다음과 같이 가정 해 봅시다.
영어로:
등록 된 지불 이 없습니다
스페인어:
어떤 건초 pagos의 registrados 없습니다
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)
다음은 대소 문자를 확인하는 동적 문자열 값에 대한 완벽한 솔루션입니다.
/**
* 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 = "나는 BOLD"
CASE I
의 경우 *targetStringToFormat* = "bold"
와*matchCase* = true
"I am BOLD"를 반환합니다 (굵게! = BOLD이므로)
CASE II
의 경우 *targetStringToFormat* = "bold"
와*matchCase* = false
"나는 BOLD "를 반환합니다.
신청하기 :
myTextView.setText(formatAStringPortionInBold("I am BOLD", "bold", false))
희망이 도움이됩니다!