将像素转换为 dp

Question

我已经为分辨率为 480x800 的 Pantech 设备创建了应用程序，高度和宽度以像素为单位。

我需要转换 G1 设备的高度和宽度。
我认为将其转换为 dp 可以解决问题并为两种设备提供相同的解决方案。

有没有简单的方法将像素转换为 dp？
有什么建议吗？

Answer 1

Java 代码：

// Converts 14 dip into its equivalent px
float dip = 14f;
Resources r = getResources();
float px = TypedValue.applyDimension(
    TypedValue.COMPLEX_UNIT_DIP,
    dip,
    r.getDisplayMetrics()
);

Kotlin 代码：

 val dip = 14f
 val r: Resources = resources
 val px = TypedValue.applyDimension(
     TypedValue.COMPLEX_UNIT_DIP,
     dip,
     r.displayMetrics
 )

Kotlin 扩展：

fun Context.toPx(dp: Int): Float = TypedValue.applyDimension(
  TypedValue.COMPLEX_UNIT_DIP,
  dp.toFloat(),
  resources.displayMetrics)

Answer 2

/**
 * This method converts dp unit to equivalent pixels, depending on device density. 
 * 
 * @param dp A value in dp (density independent pixels) unit. Which we need to convert into pixels
 * @param context Context to get resources and device specific display metrics
 * @return A float value to represent px equivalent to dp depending on device density
 */
public static float convertDpToPixel(float dp, Context context){
    return dp * ((float) context.getResources().getDisplayMetrics().densityDpi / DisplayMetrics.DENSITY_DEFAULT);
}

/**
 * This method converts device specific pixels to density independent pixels.
 * 
 * @param px A value in px (pixels) unit. Which we need to convert into db
 * @param context Context to get resources and device specific display metrics
 * @return A float value to represent dp equivalent to px value
 */
public static float convertPixelsToDp(float px, Context context){
    return px / ((float) context.getResources().getDisplayMetrics().densityDpi / DisplayMetrics.DENSITY_DEFAULT);
}

Answer 3

最好放在 Util.java 类中

public static float dpFromPx(final Context context, final float px) {
    return px / context.getResources().getDisplayMetrics().density;
}

public static float pxFromDp(final Context context, final float dp) {
    return dp * context.getResources().getDisplayMetrics().density;
}

Answer 4

float density = context.getResources().getDisplayMetrics().density;
float px = someDpValue * density;
float dp = somePxValue / density;

密度等于

• ldpi上的.75 (120 dpi)
• 1.0 () mdpi（160 dpi；基线）
• 1.5，hdpi（240 dpi）
• 2.0，xhdpi (320 dpi)
• 3.0，xxhdpi (480) dpi)
• 4.0 on xxxhdpi (640 dpi)

使用此 在线转换器来使用 dpi 值。

编辑：
看起来dpi存储桶和密度之间不存在1:1的关系。看起来 Nexus 5X 的 xxhdpi 的 密度 值为 2.625（而不是 3< /代码>）。请自行查看设备指标。

Answer 5

您可以使用这个..没有上下文

public static int pxToDp(int px) {
    return (int) (px / Resources.getSystem().getDisplayMetrics().density);
}

public static int dpToPx(int dp) {
    return (int) (dp * Resources.getSystem().getDisplayMetrics().density);
}

正如@Stan提到的..如果系统改变密度，使用这种方法可能会导致问题。所以要注意这一点！

就我个人而言，我使用 Context 来做到这一点。这只是我想与您分享的另一种方法

Answer 6

如果您可以使用维度 XML，那就非常简单了！

在您的 res/values/dimens.xml 中：

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <dimen name="thumbnail_height">120dp</dimen>
    ...
    ...
</resources>

然后在您的 Java 中：

getResources().getDimensionPixelSize(R.dimen.thumbnail_height);

Answer 7

根据 Android 开发指南：

px = dp * (dpi / 160)

但当您收到以像素为单位的设计时，您通常会希望以相反的方式执行此操作。因此：

dp = px / (dpi / 160)

如果您使用的是 240dpi 设备，则该比率为 1.5（如前所述），因此这意味着 60px 图标等于应用程序中的 40dp。

Answer 8

没有Context，优雅的静态方法：

public static int dpToPx(int dp)
{
    return (int) (dp * Resources.getSystem().getDisplayMetrics().density);
}

public static int pxToDp(int px)
{
    return (int) (px / Resources.getSystem().getDisplayMetrics().density);
}

Answer 9

使用 kotlin-extension 使其更好

fun Int.toPx(context: Context): Int = (this * context.resources.displayMetrics.density).toInt()

fun Int.toDp(context: Context): Int = (this / context.resources.displayMetrics.density).toInt()

更新：

因为 displayMetrics 是 全局共享资源，我们可以使用Resources.getSystem()

val Float.toPx get() = this * Resources.getSystem().displayMetrics.density
    
val Float.toDp get() = this / Resources.getSystem().displayMetrics.density
    

    
val Int.toPx get() = (this * Resources.getSystem().displayMetrics.density).toInt()
    
val Int.toDp get() = (this / Resources.getSystem().displayMetrics.density).toInt()
    

PS：根据@EpicPandaForce的评论：

您不应该为此使用 Resources.getSystem()，因为它不处理可折叠设备和 Chrome 操作系统设备。

Answer 10

对于 DP 到像素

在 dimens.xml 中创建一个值

<dimen name="textSize">20dp</dimen>

在 pixel 中获取该值，如下所示：

int sizeInPixel = context.getResources().getDimensionPixelSize(R.dimen.textSize);

Answer 11

对于任何使用 Kotlin 的人：

val Int.toPx: Int
    get() = (this * Resources.getSystem().displayMetrics.density).toInt()

val Int.toDp: Int
    get() = (this / Resources.getSystem().displayMetrics.density).toInt()

用法：

64.toPx
32.toDp

Answer 12

因此，您可以使用以下公式根据 dp 中指定的尺寸计算正确的像素数量

public int convertToPx(int dp) {
    // Get the screen's density scale
    final float scale = getResources().getDisplayMetrics().density;
    // Convert the dps to pixels, based on density scale
    return (int) (dp * scale + 0.5f);
}

Answer 13

android SDK中有一个默认的util：
http://developer.android.com/reference/android/util/TypedValue.html

float resultPix = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,1,getResources().getDisplayMetrics())

Answer 14

科特林

fun convertDpToPixel(dp: Float, context: Context): Float {
    return dp * (context.resources.displayMetrics.densityDpi.toFloat() / DisplayMetrics.DENSITY_DEFAULT)
}

fun convertPixelsToDp(px: Float, context: Context): Float {
    return px / (context.resources.displayMetrics.densityDpi.toFloat() / DisplayMetrics.DENSITY_DEFAULT)
}

Java

public static float convertDpToPixel(float dp, Context context) {
    return dp * ((float) context.getResources().getDisplayMetrics().densityDpi / DisplayMetrics.DENSITY_DEFAULT);
}

public static float convertPixelsToDp(float px, Context context) {
    return px / ((float) context.getResources().getDisplayMetrics().densityDpi / DisplayMetrics.DENSITY_DEFAULT);
}

Answer 15

这应该为您提供 dp 到像素的转换：

public static int dpToPx(int dp)
{
    return (int) (dp * Resources.getSystem().getDisplayMetrics().density);
}

这应该为您提供 dp 的转换像素：

public static int pxToDp(int px)
{
    return (int) (px / Resources.getSystem().getDisplayMetrics().density);
}

Answer 16

如果您在values/dimen中拥有尺寸，最好的方法可能是直接从getDimension()方法获取尺寸，它将返回已经转换为像素值的尺寸。

context.getResources().getDimension(R.dimen.my_dimension)

为了更好地解释这一点，

getDimension(int resourceId) 

将返回已转换为像素的尺寸作为浮点数。

getDimensionPixelSize(int resourceId)

将返回相同的值，但被截断为 int，所以 AS AN
整数。

请参阅 Android 参考

Answer 17

科特林：

fun spToPx(ctx: Context, sp: Float): Float {
    return sp * ctx.resources.displayMetrics.scaledDensity
}

fun pxToDp(context: Context, px: Float): Float {
    return px / context.resources.displayMetrics.density
}

fun dpToPx(context: Context, dp: Float): Float {
    return dp * context.resources.displayMetrics.density
}

Java：

public static float spToPx(Context ctx,float sp){
    return sp * ctx.getResources().getDisplayMetrics().scaledDensity;
}

public static float pxToDp(final Context context, final float px) {
    return px / context.getResources().getDisplayMetrics().density;
}

public static float dpToPx(final Context context, final float dp) {
    return dp * context.getResources().getDisplayMetrics().density;
}

Answer 18

像这样：

public class ScreenUtils {

    public static float dpToPx(Context context, float dp) {
        if (context == null) {
            return -1;
        }
        return dp * context.getResources().getDisplayMetrics().density;
    }

    public static float pxToDp(Context context, float px) {
        if (context == null) {
            return -1;
        }
        return px / context.getResources().getDisplayMetrics().density;
    }
}

依赖于上下文，返回浮点值，静态方法

来自： https://github.com/Trinea/android-common/blob/master/src/cn/trinea/android/common/util/ScreenUtils.java#L15

Answer 19

如果您开发性能关键型应用程序，请考虑以下优化类：

public final class DimensionUtils {

    private static boolean isInitialised = false;
    private static float pixelsPerOneDp;

    // Suppress default constructor for noninstantiability.
    private DimensionUtils() {
        throw new AssertionError();
    }

    private static void initialise(View view) {
        pixelsPerOneDp = view.getResources().getDisplayMetrics().densityDpi / 160f;
        isInitialised = true;
    }

    public static float pxToDp(View view, float px) {
        if (!isInitialised) {
            initialise(view);
        }

        return px / pixelsPerOneDp;
    }

    public static float dpToPx(View view, float dp) {
        if (!isInitialised) {
            initialise(view);
        }

        return dp * pixelsPerOneDp;
    }
}

Answer 20

float scaleValue = getContext().getResources().getDisplayMetrics().density;
int pixels = (int) (dps * scaleValue + 0.5f);

Answer 21

要将像素转换为 dp，请使用 TypedValue 。

正如文档中提到的：动态类型数据值的容器。

并使用 applyDimension 方法：

public static float applyDimension (int unit, float value, DisplayMetrics metrics) 

它将保存维度的解包复杂数据值转换为其最终浮点值，如下所示：

Resources resource = getResources();
float dp = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_PX, 69, resource.getDisplayMetrics());

希望有所帮助。

Answer 22

这对我来说是这样的：

DisplayMetrics displaymetrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(displaymetrics);
int  h = displaymetrics.heightPixels;
float  d = displaymetrics.density;
int heightInPixels=(int) (h/d);

你可以对宽度做同样的事情。

Answer 23

上面有很多很棒的解决方案。然而，我发现的最好的解决方案是谷歌的设计：

https://design.google.com/devices/

Answer 24

使用 kotlin 的扩展函数的更优雅的方法

/**
 * Converts dp to pixel
 */
val Int.dpToPx: Int get() = (this * Resources.getSystem().displayMetrics.density).toInt()

/**
 * Converts pixel to dp
 */
val Int.pxToDp: Int get() = (this / Resources.getSystem().displayMetrics.density).toInt()

用法：

println("16 dp in pixel: ${16.dpToPx}")
println("16 px in dp: ${16.pxToDp}")

Answer 25

PX 和 DP 不同但相似。

DP 是仅考虑屏幕物理尺寸时的分辨率。当您使用DP时，它会将您的布局缩放到具有不同像素密度的其他类似尺寸的屏幕。

有时您实际上需要像素，并且当您在代码中处理尺寸时，您总是在处理真实的像素，除非您转换它们。

因此，在 Android 设备上，正常尺寸的 hdpi 屏幕上，800x480 在 DP 中是 533x320（我相信）。将DP转换为像素/1.5，再转换回*1.5。这仅适用于一种屏幕尺寸和 dpi，它会根据设计而变化。不过，我们的艺术家给了我像素，然后我用上面的1.5方程转换为DP。

Answer 26

将 dp 转换为像素

public static int dp2px(Resources resource, int dp) {
    return (int) TypedValue.applyDimension(
        TypedValue.COMPLEX_UNIT_DIP,
        dp,resource.getDisplayMetrics()
    );
}

将像素转换为 dp。

public static float px2dp(Resources resource, float px)  {
    return (float)TypedValue.applyDimension(
        TypedValue.COMPLEX_UNIT_PX,
        px,
        resource.getDisplayMetrics()
    );
}

其中资源是 context.getResources()。

Answer 27

您应该像使用像素一样使用 dp。这就是它们的全部；显示独立像素。使用与中密度屏幕上相同的数字，在高密度屏幕上尺寸将神奇地正确。

但是，听起来您需要的是布局设计中的 fill_parent 选项。当您希望视图或控件扩展到父容器中的所有剩余大小时，请使用 fill_parent。

Answer 28

如果您想要整数值，那么使用 Math.round() 会将浮点四舍五入到最接近的整数。

public static int pxFromDp(final float dp) {
        return Math.round(dp * Resources.getSystem().getDisplayMetrics().density);
    }

Answer 29

最好的答案来自Android框架本身：只需使用这个等式...

public static int dpToPixels(final DisplayMetrics display_metrics, final float dps) {
    final float scale = display_metrics.density;
    return (int) (dps * scale + 0.5f);
}

（将dp转换为px）

Answer 30

private fun toDP(context: Context,value: Int): Int {
    return TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
        value.toFloat(),context.resources.displayMetrics).toInt()
}