如何在Android中更改TextView的fontFamily

您想要的是不可能的。您必须在代码中设置TypeFace。

XML你能做的就是

android:typeface="sans" | "serif" | "monospace"

除此之外，您无法使用XML中的字体玩太多。：）

对于Arial，您需要在代码中设置类型脸。

这是以编程方式设置字体的方法：

TextView tv = (TextView) findViewById(R.id.appname);Typeface face = Typeface.createFromAsset(getAssets(),"fonts/epimodem.ttf");tv.setTypeface(face);

将字体文件放在您的资产文件夹中。在我的例子中，我创建了一个名为字体的子目录。

编辑：如果您想知道您的资产文件夹在哪里，请参阅这个问题

它与android:typeface相同。

内置字体是：

• 正常
• sans
• 衬线
• 等宽

见android：字体。

Android不允许您从XML布局设置自定义字体。相反，您必须将特定字体文件捆绑在应用程序的资产文件夹中，并以编程方式进行设置。类似于：

TextView textView = (TextView) findViewById(<your TextView ID>);Typeface typeFace = Typeface.createFromAsset(getAssets(), "<file name>");textView.setTypeface(typeFace);

请注意，您只能在调用setContentView（）后运行此代码。此外，Android只支持某些字体，并且应该是.ttf (TrueType)或.otf (OpenType)格式。即使这样，某些字体可能无法工作。

这个是一种绝对适用于Android的字体，您可以使用它来确认您的代码是否正常工作，以防Android不支持您的字体文件。

Android O更新：根据Roger的评论，现在可以使用Android中的XML。

从android 4.1/4.2/5.0，以下Roboto字体系列可用：

android:fontFamily="sans-serif"           // roboto regularandroid:fontFamily="sans-serif-light"     // roboto lightandroid:fontFamily="sans-serif-condensed" // roboto condensedandroid:fontFamily="sans-serif-black"     // roboto blackandroid:fontFamily="sans-serif-thin"      // roboto thin (android 4.2)android:fontFamily="sans-serif-medium"    // roboto medium (android 5.0)

结合

android:textStyle="normal|bold|italic"

这16种变体是可能的：

• 常规机器人
• Roboto斜体字
• 机器人大胆
• Roboto粗体斜体字
• Roboto-Light
• Roboto-Light斜体字
• Roboto-Thin
• Roboto-Thin斜体字
• 机器人浓缩
• 机器人浓缩斜体字
• 机器人浓缩粗体
• 简体斜体字
• 黑色机器人
• 黑色斜体字
• 中型机器人
• 机器人-中型斜体字

fonts.xml

<?xml version="1.0" encoding="utf-8"?><resources><string name="font_family_light">sans-serif-light</string><string name="font_family_medium">sans-serif-medium</string><string name="font_family_regular">sans-serif</string><string name="font_family_condensed">sans-serif-condensed</string><string name="font_family_black">sans-serif-black</string><string name="font_family_thin">sans-serif-thin</string></resources>

通过一些尝试和错误，我学到了以下内容。

在*. xml中，您可以将股票字体与以下函数组合在一起，而不仅仅是字体：

 android:fontFamily="serif"android:textStyle="italic"

有了这两种样式，在任何其他情况下都不需要使用字体。使用fontFamily和text Style的组合范围要大得多。

我正在使用Chris Jenx设计的优秀库书法，旨在允许您在Android应用程序中使用自定义字体。试一试！

如果你想编程，你可以使用

label.setTypeface(Typeface.SANS_SERIF, Typeface.ITALIC);

SANS_SERIF您可以使用：

• DEFAULT
• DEFAULT_BOLD
• MONOSPACE
• SANS_SERIF
• SERIF

ITALIC你可以使用：

• BOLD
• BOLD_ITALIC
• ITALIC
• NORMAL

一切都表明在android开发者

你在res/layout/value/style.xml中设置样式如下：

<style name="boldText"><item name="android:textStyle">bold|italic</item><item name="android:textColor">#FFFFFF</item></style>

要在main.xml文件中使用此样式，请使用：

style="@style/boldText"

android： fontFamily的有效期在 /system/etc/system_fonts.xml（4. x）或 /system/etc/fonts.xml（5. x）中定义。但设备制造商可能会修改它，因此设置fontFamily值所使用的实际字体取决于指定设备的上述文件。

在AOSP中，Arial字体是有效的，但必须使用“arial”而不是“Arial”来定义，例如android：字体系列="arial"。

    <family><nameset><name>sans-serif</name><name>arial</name><name>helvetica</name><name>tahoma</name><name>verdana</name></nameset><fileset><file>Roboto-Regular.ttf</file><file>Roboto-Bold.ttf</file><file>Roboto-Italic.ttf</file><file>Roboto-BoldItalic.ttf</file></fileset></family>

//////////////////////////////////////////////////////////////////////////

在布局中定义“字体”有三个相关的xml属性——安卓：fontFamily、android：字体和安卓：文本样式。“fontFamily”和“text Style”或“typeface”和“text Style”的组合可用于更改文本中字体的外观，单独使用也是如此。TextView.java中的代码片段如下所示：

    private void setTypefaceFromAttrs(String familyName, int typefaceIndex, int styleIndex) {Typeface tf = null;if (familyName != null) {tf = Typeface.create(familyName, styleIndex);if (tf != null) {setTypeface(tf);return;}}switch (typefaceIndex) {case SANS:tf = Typeface.SANS_SERIF;break;
case SERIF:tf = Typeface.SERIF;break;
case MONOSPACE:tf = Typeface.MONOSPACE;break;}setTypeface(tf, styleIndex);}

public void setTypeface(Typeface tf, int style) {if (style > 0) {if (tf == null) {tf = Typeface.defaultFromStyle(style);} else {tf = Typeface.create(tf, style);}
setTypeface(tf);// now compute what (if any) algorithmic styling is neededint typefaceStyle = tf != null ? tf.getStyle() : 0;int need = style & ~typefaceStyle;mTextPaint.setFakeBoldText((need & Typeface.BOLD) != 0);mTextPaint.setTextSkewX((need & Typeface.ITALIC) != 0 ? -0.25f : 0);} else {mTextPaint.setFakeBoldText(false);mTextPaint.setTextSkewX(0);setTypeface(tf);}}

从代码中我们可以看到：

1. 如果设置了“fontFamily”，则“typeface”将被忽略。
2. “typeface”有标准和有限的有效期。实际上，这些值是“正常”“无衬线”和“等宽”，它们可以在system_fonts.xml（4. x）或fonts.xml（5. x）中找到。实际上“正常”和“无衬线”都是系统的默认字体。
3. “fontFamily”可用于设置内置字体的所有字体，而“typeface”仅提供“sans-serif”“serif”和“monSpace”（世界上字体类型的三大类）的典型字体。
4. 当只设置“文本样式”时，我们实际上设置了默认字体和指定的样式。有效的值是“正常”“粗体”“斜体字”和“粗体|斜体字”。

我不得不在最近的一个项目中解析/system/etc/fonts.xml。以下是Lollipop的当前字体系列：

╔════╦════════════════════════════╦═════════════════════════════╗║    ║ FONT FAMILY                ║ TTF FILE                    ║╠════╬════════════════════════════╬═════════════════════════════╣║  1 ║ casual                     ║ ComingSoon.ttf              ║║  2 ║ cursive                    ║ DancingScript-Regular.ttf   ║║  3 ║ monospace                  ║ DroidSansMono.ttf           ║║  4 ║ sans-serif                 ║ Roboto-Regular.ttf          ║║  5 ║ sans-serif-black           ║ Roboto-Black.ttf            ║║  6 ║ sans-serif-condensed       ║ RobotoCondensed-Regular.ttf ║║  7 ║ sans-serif-condensed-light ║ RobotoCondensed-Light.ttf   ║║  8 ║ sans-serif-light           ║ Roboto-Light.ttf            ║║  9 ║ sans-serif-medium          ║ Roboto-Medium.ttf           ║║ 10 ║ sans-serif-smallcaps       ║ CarroisGothicSC-Regular.ttf ║║ 11 ║ sans-serif-thin            ║ Roboto-Thin.ttf             ║║ 12 ║ serif                      ║ NotoSerif-Regular.ttf       ║║ 13 ║ serif-monospace            ║ CutiveMono.ttf              ║╚════╩════════════════════════════╩═════════════════════════════╝

这是解析器（基于字体列表解析）：

import java.io.File;import java.io.FileInputStream;import java.io.IOException;import java.io.InputStream;import java.util.ArrayList;import java.util.Collections;import java.util.Comparator;import java.util.List;
import org.xmlpull.v1.XmlPullParser;import org.xmlpull.v1.XmlPullParserException;
import android.util.Xml;
/*** Helper class to get the current font families on an Android device.</p>** Usage:</p> {@code List<SystemFont> fonts = FontListParser.safelyGetSystemFonts();}</p>*/public final class FontListParser {
private static final File FONTS_XML = new File("/system/etc/fonts.xml");
private static final File SYSTEM_FONTS_XML = new File("/system/etc/system_fonts.xml");
public static List<SystemFont> getSystemFonts() throws Exception {String fontsXml;if (FONTS_XML.exists()) {fontsXml = FONTS_XML.getAbsolutePath();} else if (SYSTEM_FONTS_XML.exists()) {fontsXml = SYSTEM_FONTS_XML.getAbsolutePath();} else {throw new RuntimeException("fonts.xml does not exist on this system");}Config parser = parse(new FileInputStream(fontsXml));List<SystemFont> fonts = new ArrayList<>();
for (Family family : parser.families) {if (family.name != null) {Font font = null;for (Font f : family.fonts) {font = f;if (f.weight == 400) {break;}}SystemFont systemFont = new SystemFont(family.name, font.fontName);if (fonts.contains(systemFont)) {continue;}fonts.add(new SystemFont(family.name, font.fontName));}}
for (Alias alias : parser.aliases) {if (alias.name == null || alias.toName == null || alias.weight == 0) {continue;}for (Family family : parser.families) {if (family.name == null || !family.name.equals(alias.toName)) {continue;}for (Font font : family.fonts) {if (font.weight == alias.weight) {fonts.add(new SystemFont(alias.name, font.fontName));break;}}}}
if (fonts.isEmpty()) {throw new Exception("No system fonts found.");}
Collections.sort(fonts, new Comparator<SystemFont>() {
@Overridepublic int compare(SystemFont font1, SystemFont font2) {return font1.name.compareToIgnoreCase(font2.name);}
});
return fonts;}
public static List<SystemFont> safelyGetSystemFonts() {try {return getSystemFonts();} catch (Exception e) {String[][] defaultSystemFonts = \{\{"cursive", "DancingScript-Regular.ttf"}, {"monospace", "DroidSansMono.ttf"}, {"sans-serif", "Roboto-Regular.ttf"}, {"sans-serif-light", "Roboto-Light.ttf"}, {"sans-serif-medium", "Roboto-Medium.ttf"}, {"sans-serif-black", "Roboto-Black.ttf"}, {"sans-serif-condensed", "RobotoCondensed-Regular.ttf"}, {"sans-serif-thin", "Roboto-Thin.ttf"}, {"serif", "NotoSerif-Regular.ttf"}};List<SystemFont> fonts = new ArrayList<>();for (String[] names : defaultSystemFonts) {File file = new File("/system/fonts", names[1]);if (file.exists()) {fonts.add(new SystemFont(names[0], file.getAbsolutePath()));}}return fonts;}}
/* Parse fallback list (no names) */public static Config parse(InputStream in) throws XmlPullParserException, IOException {try {XmlPullParser parser = Xml.newPullParser();parser.setInput(in, null);parser.nextTag();return readFamilies(parser);} finally {in.close();}}
private static Alias readAlias(XmlPullParser parser) throws XmlPullParserException, IOException {Alias alias = new Alias();alias.name = parser.getAttributeValue(null, "name");alias.toName = parser.getAttributeValue(null, "to");String weightStr = parser.getAttributeValue(null, "weight");if (weightStr == null) {alias.weight = 0;} else {alias.weight = Integer.parseInt(weightStr);}skip(parser); // alias tag is empty, ignore any contents and consume end tagreturn alias;}
private static Config readFamilies(XmlPullParser parser) throws XmlPullParserException,IOException {Config config = new Config();parser.require(XmlPullParser.START_TAG, null, "familyset");while (parser.next() != XmlPullParser.END_TAG) {if (parser.getEventType() != XmlPullParser.START_TAG) {continue;}if (parser.getName().equals("family")) {config.families.add(readFamily(parser));} else if (parser.getName().equals("alias")) {config.aliases.add(readAlias(parser));} else {skip(parser);}}return config;}
private static Family readFamily(XmlPullParser parser) throws XmlPullParserException,IOException {String name = parser.getAttributeValue(null, "name");String lang = parser.getAttributeValue(null, "lang");String variant = parser.getAttributeValue(null, "variant");List<Font> fonts = new ArrayList<Font>();while (parser.next() != XmlPullParser.END_TAG) {if (parser.getEventType() != XmlPullParser.START_TAG) {continue;}String tag = parser.getName();if (tag.equals("font")) {String weightStr = parser.getAttributeValue(null, "weight");int weight = weightStr == null ? 400 : Integer.parseInt(weightStr);boolean isItalic = "italic".equals(parser.getAttributeValue(null, "style"));String filename = parser.nextText();String fullFilename = "/system/fonts/" + filename;fonts.add(new Font(fullFilename, weight, isItalic));} else {skip(parser);}}return new Family(name, fonts, lang, variant);}
private static void skip(XmlPullParser parser) throws XmlPullParserException, IOException {int depth = 1;while (depth > 0) {switch (parser.next()) {case XmlPullParser.START_TAG:depth++;break;case XmlPullParser.END_TAG:depth--;break;}}}
private FontListParser() {
}
public static class Alias {
public String name;
public String toName;
public int weight;}
public static class Config {
public List<Alias> aliases;
public List<Family> families;
Config() {families = new ArrayList<Family>();aliases = new ArrayList<Alias>();}
}
public static class Family {
public List<Font> fonts;
public String lang;
public String name;
public String variant;
public Family(String name, List<Font> fonts, String lang, String variant) {this.name = name;this.fonts = fonts;this.lang = lang;this.variant = variant;}
}
public static class Font {
public String fontName;
public boolean isItalic;
public int weight;
Font(String fontName, int weight, boolean isItalic) {this.fontName = fontName;this.weight = weight;this.isItalic = isItalic;}
}
public static class SystemFont {
public String name;
public String path;
public SystemFont(String name, String path) {this.name = name;this.path = path;}
}}

随意在您的项目中使用上述类。例如，您可以为您的用户提供一系列字体系列并根据他们的偏好设置字体。

一个不完整的小例子：

final List<FontListParser.SystemFont> fonts = FontListParser.safelyGetSystemFonts();String[] items = new String[fonts.size()];for (int i = 0; i < fonts.size(); i++) {items[i] = fonts.get(i).name;}
new AlertDialog.Builder(this).setSingleChoiceItems(items, -1, new DialogInterface.OnClickListener() {@Overridepublic void onClick(DialogInterface dialog, int which) {FontListParser.SystemFont selectedFont = fonts.get(which);// TODO: do something with the fontToast.makeText(getApplicationContext(), selectedFont.path, Toast.LENGTH_LONG).show();}}).show();

管理字体的一种简单方法是通过资源声明它们，如下所示：

<!--++++++++++++++++++++++++++--><!--added on API 16 (JB - 4.1)--><!--++++++++++++++++++++++++++--><!--the default font--><string name="fontFamily__roboto_regular">sans-serif</string><string name="fontFamily__roboto_light">sans-serif-light</string><string name="fontFamily__roboto_condensed">sans-serif-condensed</string>
<!--+++++++++++++++++++++++++++++--><!--added on API 17 (JBMR1 - 4.2)--><!--+++++++++++++++++++++++++++++--><string name="fontFamily__roboto_thin">sans-serif-thin</string>
<!--+++++++++++++++++++++++++++--><!--added on Lollipop (LL- 5.0)--><!--+++++++++++++++++++++++++++--><string name="fontFamily__roboto_medium">sans-serif-medium</string><string name="fontFamily__roboto_black">sans-serif-black</string><string name="fontFamily__roboto_condensed_light">sans-serif-condensed-light</string>

这是基于源代码<强>这里和<强>这里的

这里您可以查看所有可用的font-Family值及其对应的字体文件名（此文件在android 5.0+中使用）。在移动设备上，您可以在以下位置找到它：

/system/etc/fonts.xml (for 5.0+)

（对于android 4.4及以下版本使用这个版本，但我认为fonts.xml格式更清晰，易于理解。）

例如，

    <!-- first font is default -->20    <family name="sans-serif">21        <font weight="100" style="normal">Roboto-Thin.ttf</font>22        <font weight="100" style="italic">Roboto-ThinItalic.ttf</font>23        <font weight="300" style="normal">Roboto-Light.ttf</font>24        <font weight="300" style="italic">Roboto-LightItalic.ttf</font>25        <font weight="400" style="normal">Roboto-Regular.ttf</font>26        <font weight="400" style="italic">Roboto-Italic.ttf</font>27        <font weight="500" style="normal">Roboto-Medium.ttf</font>28        <font weight="500" style="italic">Roboto-MediumItalic.ttf</font>29        <font weight="900" style="normal">Roboto-Black.ttf</font>30        <font weight="900" style="italic">Roboto-BlackItalic.ttf</font>31        <font weight="700" style="normal">Roboto-Bold.ttf</font>32        <font weight="700" style="italic">Roboto-BoldItalic.ttf</font>33    </family>

family标签的name属性name="sans-serif"定义了您可以在android： fontFamily中使用的值。

font标签定义了对应的字体文件。

在这种情况下，您可以忽略<!-- fallback fonts -->下的源，它用于字体的兜底逻辑。

我使用信件出版社作为我的NonTextView的东西，如按钮和kianoni字体加载库作为我的TextViews，因为在这个库中使用样式对我来说比按字母更容易，我得到了理想的反馈。这对于那些想要使用除Roboto字体之外的自定义字体的人来说非常棒。这是我使用字体库的经验。对于那些想要使用自定义类来更改字体的人，我强烈建议使用这个片段创建这个类

public class TypefaceSpan extends MetricAffectingSpan {/** An <code>LruCache</code> for previously loaded typefaces. */private static LruCache<String, Typeface> sTypefaceCache =new LruCache<String, Typeface>(12);
private Typeface mTypeface;
/*** Load the {@link android.graphics.Typeface} and apply to a {@link android.text.Spannable}.*/public TypefaceSpan(Context context, String typefaceName) {mTypeface = sTypefaceCache.get(typefaceName);
if (mTypeface == null) {mTypeface = Typeface.createFromAsset(context.getApplicationContext().getAssets(), String.format("fonts/%s", typefaceName));
// Cache the loaded TypefacesTypefaceCache.put(typefaceName, mTypeface);}}
@Overridepublic void updateMeasureState(TextPaint p) {p.setTypeface(mTypeface);
// Note: This flag is required for proper typeface renderingp.setFlags(p.getFlags() | Paint.SUBPIXEL_TEXT_FLAG);}
@Overridepublic void updateDrawState(TextPaint tp) {tp.setTypeface(mTypeface);
// Note: This flag is required for proper typeface renderingtp.setFlags(tp.getFlags() | Paint.SUBPIXEL_TEXT_FLAG);}}

并像这样使用类：

AppData = PreferenceManager.getDefaultSharedPreferences(this);TextView bannertv= (TextView) findViewById(R.id.txtBanner);SpannableString s = new SpannableString(getResources().getString(R.string.enterkey));s.setSpan(new TypefaceSpan(this, AppData.getString("font-Bold",null)), 0, s.length(),Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);bannertv.setText(s);

也许这个帮助。

以编程方式设置Roboto：

paint.setTypeface(Typeface.create("sans-serif-thin", Typeface.NORMAL));

<string name="font_family_display_4_material">sans-serif-light</string><string name="font_family_display_3_material">sans-serif</string><string name="font_family_display_2_material">sans-serif</string><string name="font_family_display_1_material">sans-serif</string><string name="font_family_headline_material">sans-serif</string><string name="font_family_title_material">sans-serif-medium</string><string name="font_family_subhead_material">sans-serif</string><string name="font_family_menu_material">sans-serif</string><string name="font_family_body_2_material">sans-serif-medium</string><string name="font_family_body_1_material">sans-serif</string><string name="font_family_caption_material">sans-serif</string><string name="font_family_button_material">sans-serif-medium</string>

这是一个在某些情况下可以工作的更容易y。原则是在xml布局中添加一个不可见的TextVview，并在java代码中添加获取其typeFace。

xml文件中的布局：

<TextViewandroid:text="The classic bread is made of flour hot and salty. The classic bread is made of flour hot and salty. The classic bread is made of flour hot and salty."android:layout_width="0dp"android:layout_height="0dp"android:fontFamily="sans-serif-thin"android:id="@+id/textViewDescription"/>

java代码：

myText.setTypeface(textViewSelectedDescription.getTypeface());

它为我工作（例如在TextSwitcher中）。

从android-Studio 3.0开始，很容易更改字体系列

使用支持库26，它可以在运行Android API版本16及更高版本的设备上运行

在res目录下创建一个文件夹font。下载您想要的字体并将其粘贴到font文件夹中。结构应该如下所示

备注：从Android Support Library 26.0开始，您必须声明两组属性（android：和app：）以确保您的字体在运行的设备上加载API 26或更低。

现在您可以使用布局更改字体

<TextViewandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:fontFamily="@font/dancing_script"app:fontFamily="@font/dancing_script"/>

改变编程

 Typeface typeface = getResources().getFont(R.font.myfont);//or to support all versions useTypeface typeface = ResourcesCompat.getFont(context, R.font.myfont);textView.setTypeface(typeface);

要使用styles.xml更改字体，请创建样式

 <style name="Regular"><item name="android:fontFamily">@font/dancing_script</item><item name="fontFamily">@font/dancing_script</item><item name="android:textStyle">normal</item></style>

并将此样式应用于TextView

  <TextViewandroid:layout_width="wrap_content"android:layout_height="wrap_content"style="@style/Regular"/>

您也可以创建自己的字体系列

-右键单击字体文件夹并转到新>字体资源文件。出现新资源文件窗口。

-输入文件名，然后单击好的。新的字体资源XML将在编辑器中打开。

例如，在这里编写您自己的字体系列

<font-family xmlns:android="http://schemas.android.com/apk/res/android"><fontandroid:fontStyle="normal"android:fontWeight="400"android:font="@font/lobster_regular" /><fontandroid:fontStyle="italic"android:fontWeight="400"android:font="@font/lobster_italic" /></font-family>

这只是将特定fontStyle和fontWeight映射到将用于呈现该特定变体的字体资源。fontStyle的有效期是正常或斜体字；fontWeight符合CSS字体重量规范

1.到改变 fontFamily在布局你可以写

 <TextViewandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:fontFamily="@font/lobster"/>

2.改变编程

 Typeface typeface = getResources().getFont(R.font.lobster);//or to support all versions useTypeface typeface = ResourcesCompat.getFont(context, R.font.lobster);textView.setTypeface(typeface);

更改整个应用程序的字体添加这两行在AppTheme

 <style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar"><item name="android:fontFamily">@font/your_font</item><item name="fontFamily">@font/your_font</item></style>

查看需求文档，Android自定义字体教程更多信息

如果您想在具有相同字体系列的许多地方使用TextView，请扩展TextView类并像这样设置字体：-

public class ProximaNovaTextView extends TextView {public ProximaNovaTextView(Context context) {super(context);applyCustomFont(context);}public ProximaNovaTextView(Context context, AttributeSet attrs) {super(context, attrs);
applyCustomFont(context);}public ProximaNovaTextView(Context context, AttributeSet attrs, int defStyle) {super(context, attrs, defStyle);applyCustomFont(context);}private void applyCustomFont(Context context) {Typeface customFont = FontCache.getTypeface("proximanova_regular.otf", context);setTypeface(customFont);}}

然后在XML中为TextView使用这个自定义类，如下所示：-

<com.myapp.customview.ProximaNovaTextViewandroid:id="@+id/feed_list_item_name_tv"android:layout_width="match_parent"android:layout_height="wrap_content"android:textSize="14sp"/>

您可以使用以下库轻松完成

https://github.com/sunnag7/FontStyler

<com.sunnag.fontstyler.FontStylerViewandroid:textStyle="bold"android:text="@string/about_us"android:layout_width="match_parent"android:layout_height="match_parent"android:paddingTop="8dp"app:fontName="Lato-Bold"android:textSize="18sp"android:id="@+id/textView64" />

它重量轻，易于实现，只需将字体复制到资产文件夹中并在xml中使用名称。

我只想提一下Android内部字体的地狱即将结束，因为今年在Google IO上我们终于得到了这个->https://developer.android.com/preview/features/working-with-fonts.html

现在有一个新的资源类型a字体，您可以将所有应用程序字体放在res/字体文件夹中，然后使用R.font.my_custom_font访问，就像您可以访问字符串 res值、可绘制 res值等一样。您甚至有机会创建font-face xml文件，它将设置您的自定义字体（关于斜体字、粗体和下划线attr）。

阅读上面的链接了解更多信息。让我们看看支持。

动态地，您可以使用以下命令在xml中设置类似于android： fontFamily的fontFamily，

For Custom font:
TextView tv = ((TextView) v.findViewById(R.id.select_item_title));Typeface face=Typeface.createFromAsset(getAssets(),"fonts/mycustomfont.ttf");tv.setTypeface(face);
For Default font:
tv.setTypeface(Typeface.create("sans-serif-medium",Typeface.NORMAL));

这些是使用的默认字体系列的列表，通过替换双引号字符串"无衬线介质"来使用其中的任何一个

FONT FAMILY                    TTF FILE
1  casual                      ComingSoon.ttf2  cursive                     DancingScript-Regular.ttf3  monospace                   DroidSansMono.ttf4  sans-serif                  Roboto-Regular.ttf5  sans-serif-black            Roboto-Black.ttf6  sans-serif-condensed        RobotoCondensed-Regular.ttf7  sans-serif-condensed-light  RobotoCondensed-Light.ttf8  sans-serif-light            Roboto-Light.ttf9  sans-serif-medium           Roboto-Medium.ttf10  sans-serif-smallcaps       CarroisGothicSC-Regular.ttf11  sans-serif-thin            Roboto-Thin.ttf12  serif                      NotoSerif-Regular.ttf13  serif-monospace            CutiveMono.ttf

“mycustomfont.ttf”是ttf文件。路径将在mycustomfont.ttf中，您可以在此默认字体系列中参考有关默认字体的更多信息

尝试这些简单的步骤。1.在res文件夹中创建字体文件夹。2.将. ttf文件复制粘贴到字体文件夹中。3.现在像下面这样给出xml中的路径。

 android:fontFamily="@font/frutiger"

或者你的文件名是什么。这是快乐的代码

对于android-Studio 3及更高版本，您可以使用此样式，然后在应用程序内更改所有textView字体。

在您的style.xml中创建此样式：

<!--OverRide all textView font--><style name="defaultTextViewStyle" parent="android:Widget.TextView"><item name="android:fontFamily">@font/your_custom_font</item></style>

然后在你的主题中使用它：

<!-- Base application theme. --><style name="AppTheme" parent="Theme.AppCompat.Light.NoActionBar"><!-- Customize your theme here. --><item name="colorPrimary">@color/colorPrimary</item><item name="colorPrimaryDark">@color/colorPrimaryDark</item><item name="colorAccent">@color/colorAccent</item><item name="android:textViewStyle">@style/defaultTextViewStyle</item></style>

最简单的方法以编程方式将字体添加到TextView是，首先，在项目的资产文件夹中添加字体文件。例如，您的字体路径如下所示：assets/fonts/my_font.otf

并将其添加到TextView中：

静态编程语言

val font_path = "fonts/my_font.otf"
myTypeface = Typeface.createFromAsset(MyApplication.getInstance().assets, font_path)
textView.typeface = myTypeface

Java

String font_path = "fonts/my_font.otf";Typeface myTypeface = Typeface.createFromAsset(MyApplication.getInstance().assets, font_path)textView.setTypeface(myTypeface);

试试这个：

TextView textview = (TextView) findViewById(R.id.textview);Typeface tf= Typeface.createFromAsset(getAssets(),"fonts/Tahoma.ttf");textview .setTypeface(tf);

有一个不错的图书馆可供使用

    implementation 'uk.co.chrisjenx:calligraphy:2.3.0'

您还可以使用setTextAppearance更改标准字体（需要API 16），请参阅https://stackoverflow.com/a/36301508/2914140：

<style name="styleA"><item name="android:fontFamily">sans-serif</item><item name="android:textStyle">bold</item><item name="android:textColor">?android:attr/textColorPrimary</item></style><style name="styleB"><item name="android:fontFamily">sans-serif-light</item><item name="android:textStyle">normal</item><item name="android:textColor">?android:attr/textColorTertiary</item></style>

if(condition){TextViewCompat.setTextAppearance(textView, R.style.styleA);} else {TextViewCompat.setTextAppearance(textView,R.style.styleB);}

Typeface typeface = ResourcesCompat.getFont(context, R.font.font_name);textView.setTypeface(typeface);

以编程方式轻松将字体设置为res>字体目录中的任何textview

我想我太晚了，但也许这个解决方案对其他人有用。对于使用自定义字体，请将字体文件放在字体目录中。

textView.setTypeface(ResourcesCompat.getFont(this, R.font.lato));

一种简单的方法是在项目中添加所需的字体。

转到文件->新->新资源目录选择字体

这将在您的资源中创建一个新目录字体。

下载你的字体（. ttf）。我用https://fonts.google.com来做同样的事情

将其添加到字体文件夹，然后在XML中或以编程方式使用它们。

xml-

<TextViewandroid:id="@+id/textView"android:layout_width="wrap_content"android:layout_height="wrap_content"android:fontFamily="@font/your_font"/>

方案-

 Typeface typeface = ResourcesCompat.getFont(this, R.font.your_font);textView.setTypeface(typeface);

如果您使用的是Android Studio 3.5+，更改字体非常简单。在设计视图中选择文本小部件，并在属性窗口中检查字体系列。值下拉列表包含所有可用的字体，您可以从中选择一种。如果您正在寻找Google字体，请单击更多字体选项。

属性窗口

谷歌字体

您也可以通过在res目录下添加一个字体文件夹来做到这一点，如下所示。

然后，选择字体作为资源类型。

您可以从https://www.1001fonts.com/中找到可用的字体，然后将TTF文件解压缩到此字体目录。

最后，只需通过添加android： fontFamily："@fontfilename"来更改包含文本视图的XML文件

新的字体资源允许直接使用font设置

android:fontFamily="@font/my_font_in_font_folder"

要按程序设置字体，请写入…

 TextView tv7 = new TextView(this);tv7.setText(" TIME ");tv7.setTypeface(Typeface.create("sans-serif-condensed",Typeface.BOLD));tv7.setTextSize(12);tbrow.addView(tv7);

名称“sans-serif-comed”是从fonts.xml文件中引用的，该文件应该在应用程序->res->值文件夹中创建，并在其中保存字体。

<?xml version="1.0" encoding="utf-8"?><resources><string name="font_family_light">sans-serif-light</string><string name="font_family_medium">sans-serif-medium</string><string name="font_family_regular">sans-serif</string><string name="font_family_condensed">sans-serif-condensed</string><string name="font_family_black">sans-serif-black</string><string name="font_family_thin">sans-serif-thin</string></resources>

希望这是清楚的！

您可以像这样定义自定义FontFamily：

/res/font/usual.xml：

<?xml version="1.0" encoding="utf-8"?><font-family xmlns:tools="http://schemas.android.com/tools"xmlns:android="http://schemas.android.com/apk/res/android"xmlns:app="http://schemas.android.com/apk/res-auto"tools:ignore="UnusedAttribute"><fontandroid:fontStyle="normal"android:fontWeight="200"android:font="@font/usual_regular"app:fontStyle="normal"app:fontWeight="200"app:font="@font/usual_regular" />
<fontandroid:fontStyle="italic"android:fontWeight="200"android:font="@font/usual_regular_italic"app:fontStyle="italic"app:fontWeight="200"app:font="@font/usual_regular_italic" />
<fontandroid:fontStyle="normal"android:fontWeight="600"android:font="@font/usual_bold"app:fontStyle="normal"app:fontWeight="600"app:font="@font/usual_bold" />
<fontandroid:fontStyle="italic"android:fontWeight="600"android:font="@font/usual_bold_italic"app:fontStyle="italic"app:fontWeight="600"app:font="@font/usual_bold_italic" /></font-family>

现在你可以做

android:fontFamily="@font/usual"

假设你的其他font资源也在那里，用小写字母和_。

静态编程语言代码-从资源文件夹设置自定义字体的文本视图

从res->字体->avenir_next_regular.ttf设置自定义字体

textView!!.typeface = ResourcesCompat.getFont(context!!, R.font.avenir_next_regular)

<?xml version="1.0" encoding="utf-8"?><font-family xmlns:android="http://schemas.android.com/apk/res/android"xmlns:app="http://schemas.android.com/apk/res-auto"xmlns:tools="http://schemas.android.com/tools"tools:ignore="UnusedAttribute"><fontandroid:font="@font/google_sans_regular"android:fontStyle="normal"android:fontWeight="400"app:font="@font/google_sans_regular"app:fontStyle="normal"app:fontWeight="400" />
<fontandroid:font="@font/google_sans_italic"android:fontStyle="italic"android:fontWeight="400"app:font="@font/google_sans_italic"app:fontStyle="italic"app:fontWeight="400" />
<fontandroid:font="@font/google_sans_medium"android:fontStyle="normal"android:fontWeight="500"app:font="@font/google_sans_medium"app:fontStyle="normal"app:fontWeight="500" />
<fontandroid:font="@font/google_sans_medium_italic"android:fontStyle="italic"android:fontWeight="500"app:font="@font/google_sans_medium_italic"app:fontStyle="italic"app:fontWeight="500" />
<fontandroid:font="@font/google_sans_bold"android:fontStyle="normal"android:fontWeight="600"app:font="@font/google_sans_bold"app:fontStyle="normal"app:fontWeight="600" />
<fontandroid:font="@font/google_sans_bold_italic"android:fontStyle="italic"android:fontWeight="600"app:font="@font/google_sans_bold_italic"app:fontStyle="italic"app:fontWeight="600" />
</font-family>

可能我的评论对某人有用：我试图意识到为什么app:fontFamily="@font/my_font"不起作用，浪费了一些时间后发现工作解决方案是android:fontFamily="@font/my_font"