安卓百宝箱：android.util.*

最新推荐文章于 2023-09-20 17:25:48 发布

doubledong1994

最新推荐文章于 2023-09-20 17:25:48 发布

阅读量495

点赞数

分类专栏：笔记文章标签：安卓 java android

本文链接：https://blog.csdn.net/doubledong1994/article/details/106204184

版权

笔记专栏收录该内容

4 篇文章 0 订阅

订阅专栏

安卓百宝箱：android.util.*

如果下面的类中有你需要实现的功能，请在安卓源码中使用 ctr+c，安卓源码阅读地址：
http://androidxref.com/9.0.0_r3/xref/frameworks/base/core/java/android/util/

android.util.Range（区间的表示与操作）

public final class Range<T extends Comparable<? super T>>
此函数使用两个 T 类型的对象：mLower、mUpper 记录一个范围，并提供了下面几个操作：

在这里插入图片描述

extend::Range: 函数使用例子：

Range a=new Range(1,2);
Range b= new Range(4,5);
Range c=a.extend(b); // 也可以写成 Range c=a.extend(4,5); 
// c=Range(1,5);    a, b 不变，c 是新创建的实例

extend::T: 函数使用例子：

Range a=new Range(1,2);
Range c=a.extend(5);
// c=Range(1,5);    a, b 不变，c 是新创建的实例

clamp::T: 函数使用的例子：

Range a=new Range(1,5);
int b=a.clamp(0); //a=1
int c=a.clamp(3); //a=3
int d=a.clamp(6); //a=5
// 这个函数会把 Range 内的值直接返回，把 Range 外的值变成离它最近的边界值：mLower 或 mUpper

其它的函数不说了，一个道理。
T 类型要继承自 Comparable，于是我就查了一下 java.lang.Integer 类，果然它也继承自 Comparable，看来还是基础没有学好。
public final class Integer extends Number implements Comparable

android.util.Rational（分数的表示与操作）

public final class Rational extends Number implements Comparable
这个类表示了一个分数类型，并提供了下面的方法
在这里插入图片描述

简单解释一些函数：
compareTo::Rational:，与另一个分数比较大小
intValue:::，将分数变成整型
shortValue:::，将分数变成短整型
getNumerator::: ，获得分子
.getDenominator:::，获得分母

android.util.SparseArray<E>（Map<Integer, E> 的非哈希实现）

public class SparseArray<E> implements Cloneable
这个类其功能类似于 HashMap<Integer,E>，如果你用 AndroidStudio 开发安卓，当你声明一个 HashMap<Integer,E> 变量时，IDE 就会提醒你使用 SparseArray 来替代 HashMap ，为什么不直接使用 HashMap 呢，文档中的解释是这样的：
It is intended to be more memory efficient（省内存） than using a HashMap to map Integers to Objects, both because it avoids auto-boxing keys and its data structure doesn’t rely on an extra entry object for each mapping.
意思就是为了省内存，HashMap 被嫌弃了。SparseArray 的基本的数据结构是一个 private int[] mKeys 和一个 Object[] mValues，通过Key来获得 Value 的实现方式是：先用二分搜索在 mKeys 中找到 Key 的位置，然后在 mValues 的对应位置获得 Value。
因此这个数据结构必须保证： mKeys 的有序的，mKeys 与 mValues 的位置是一一对应的，这样键值的存取并没有使用哈希算法，因此在时间上不如 HashMap，但是你可以不把它看作一个键值的结构，而是看作是一个有序的数组，而且这个数组可以是稀疏的（相邻下标之间有间隔）。
它提供了下面的函数：

android.util.SparseArray.clone:::                    //  主要是复制了 mKeys 和  mValues
android.util.SparseArray.get::int:                    //通过键获取值
android.util.SparseArray.get::int,E:                 //通过键获取值，第二个参数是找不到键的时候返回的默认值
android.util.SparseArray.delete::int:                // 通过键删除键值对，其内部操作是将 Value 置为 null
android.util.SparseArray.removeReturnOld::int:
android.util.SparseArray.remove::int:
android.util.SparseArray.removeAt::int:
android.util.SparseArray.removeAtRange::int,int:
android.util.SparseArray.gc:::
android.util.SparseArray.put::int,E:
android.util.SparseArray.size:::
android.util.SparseArray.keyAt::int:                   // 通过下标获得键
android.util.SparseArray.valueAt::int:                // 通过下标获得值
android.util.SparseArray.setValueAt::int,E:
android.util.SparseArray.indexOfKey::int:         // 获得键的下标
android.util.SparseArray.indexOfValue::E:
android.util.SparseArray.clear:::
android.util.SparseArray.append::int,E:
android.util.SparseArray.toString:::

android.util.SparseIntArray（SparseArray<Integer>）

这个类实现的功能与 SparseArray<Integer> 相同，但并不是继承自 SparseArray<Integer>。

android.util.SparseLongArray（SparseArray<Long>）

这个类实现的功能与 SparseArray<Long> 相同，但并不是继承自 SparseArray<Long>。

android.util.ArrayMap<K, V>（Map<K, V> 的非哈希实现）

public final class ArrayMap<K, V> implements Map<K, V>
这个类的键值搜索仍是二分查找，基本数据结构中，对应于 SparseArray 中的 mKeys，它的有序数组是 mHashes，它将键对象的 HashCode 计算出来排序，存入 mHashes 中，其它的大致就与 SparseArray 一样了。它同样比 HashMap 省内存，费时间。

android.util.ArraySet<E>（Set<E> 的实现）

public final class ArraySet<E> implements Collection<E>, Set<E>
它的实现方式与 ArrayMap 类似，也是把对象的 HashCode 排序存放在数组 mHashes 中。

android.util.Base64（Base64 编码与解码）

关于 Base64 编码的理解可以看这篇文章：
https://blog.csdn.net/doubledong1994/article/details/106220568
这个类提供的方法有：

decode::String,int:
decode::byte,int:
decode::byte,int,int,int:
encodeToString::byte,int:
encodeToString::byte,int,int,int:
encode::byte,int:
encode::byte,int,int,int:

其功能就是用 Base64 编码与解码。

android.util.TimingLogger（记录操作的耗时）

这个类提供下面的函数：

android.util.TimingLogger.reset::String,String:
android.util.TimingLogger.reset:::
android.util.TimingLogger.addSplit::String:
android.util.TimingLogger.dumpToLog:::

下面是文档的中例子：

  TimingLogger timings = new TimingLogger(TAG, "methodA");
 *     // ... do some work A ...
 *     timings.addSplit("work A");
 *     // ... do some work B ...
 *     timings.addSplit("work B");
 *     // ... do some work C ...
 *     timings.addSplit("work C");
 *     timings.dumpToLog();
 * 
 调用 dumpToLog 函数会打印下面的日志:
 D/TAG     ( 3459): methodA: begin
 *     D/TAG     ( 3459): methodA:      9 ms, work A
 *     D/TAG     ( 3459): methodA:      1 ms, work B
 *     D/TAG     ( 3459): methodA:      6 ms, work C
 *     D/TAG     ( 3459): methodA: end, 16 ms

android.util.Spline（Spline 插值工具）

你有一组二维数据（x，y）：（1，2）（2，3）（3，4）（4，5）
如果你想知道 x=1.5 的时候 y 的值，可以使用这个类。它提供下面函数：

android.util.Spline.interpolate::float:  
android.util.Spline.createSpline::float,float:
android.util.Spline.createMonotoneCubicSpline::float,float:
android.util.Spline.createLinearSpline::float,float:
android.util.Spline.isStrictlyIncreasing::float:
android.util.Spline.isMonotonic::float:

其中 createMonotoneCubicSpline 会使用曲线来插值，createLinearSpline 会使用直线来插值
isStrictlyIncreasing 用来判断数组是不是严格递增的，isMonotonic 用来判断数组是不是单调的，严格递增与单调的区别：单调允许连续几个值相等，严格递增不允许。
例子：

float[] x=new float[]{1,2,3,4};
float[] y=new float[]{2,3,4,5};
// Spline s=Spline.createSpline(x,y);   //  x 必须严格递增
// Spline s=Spline.createMonotoneCubicSpline(x,y);   //  x 必须严格递增
Spline s=Spline.createLinearSpline(x,y);   //  x 必须严格递增
float y=s.interpolate(1.5);

android.util.TypedValue（有多种解释的 int 值、String 值）

这个类中存了一个 int 值和一个 String 值，对这个对象的解释有：

android.util.TypedValue.TYPE_NULL
android.util.TypedValue.TYPE_REFERENCE
android.util.TypedValue.TYPE_ATTRIBUTE
android.util.TypedValue.TYPE_STRING
android.util.TypedValue.TYPE_FLOAT
android.util.TypedValue.TYPE_DIMENSION
android.util.TypedValue.TYPE_FRACTION
android.util.TypedValue.TYPE_FIRST_INT
android.util.TypedValue.TYPE_INT_DEC
android.util.TypedValue.TYPE_INT_HEX
android.util.TypedValue.TYPE_INT_BOOLEAN
android.util.TypedValue.TYPE_FIRST_COLOR_INT
android.util.TypedValue.TYPE_INT_COLOR_ARGB8
android.util.TypedValue.TYPE_INT_COLOR_RGB8
android.util.TypedValue.TYPE_INT_COLOR_ARGB4
android.util.TypedValue.TYPE_INT_COLOR_RGB4
android.util.TypedValue.TYPE_LAST_COLOR_INT
android.util.TypedValue.TYPE_LAST_INT

这个类不可以直接复制，但这个操作方式可以复制。

android.util.Pools.SynchronizedPool（对象池工具）

这个类帮我们实现了一个对象池。
对象池的基本数据结构就是个对象数组（或者链表），用的时候记一下，还的时候记一下，对象不够用的时候 new 一下。它对应了设计模式中的亨元模式，应用于使用过于频繁的类，或者创建对象时开销大的类，类比于生活中：东西太贵，用完别扔，洗洗再用。

文档中的例子：

 * public class MyPooledClass {
 *
 *     private static final SynchronizedPool<MyPooledClass> sPool =
 *             new SynchronizedPool<MyPooledClass>(10);
 *
 *     public static MyPooledClass obtain() {
 *         MyPooledClass instance = sPool.acquire();        // 用的时候记一下
 *         return (instance != null) ? instance : new MyPooledClass();       // 对象不够用的时候 new 一下
 *     }
 *
 *     public void recycle() {
 *          // Clear state if needed.     //  洗洗
 *          sPool.release(this);          // 还的时候记一下
 *     }
 *
 *     . . .
 * }

android.util.Property<T, V>（读写类 T 中的 V 属性）

这是个抽象类，它的子类有
android.util.FloatProperty
android.util.IntProperty
在使用 FloatProperty 时有两个函数需要被重写：get 和 setValue。
下面是个例子：

    public static final Property<View, Float> ALPHA = new FloatProperty<View>("alpha") {
        @Override
        public void setValue(View object, float value) {
            object.setAlpha(value);
        }

        @Override
        public Float get(View object) {
            return object.getAlpha();
        }
    };

关于这个类的意义在文档中是这样说的：
A property is an abstraction that can be used to represent a mutable value that is held in a host object.
“A property” 指的是这个类的一个对象，这个对象代表了 host 中的一个属性值。目前我还不能体会它存在的意义，有懂的小伙伴请在评论区开金口吧。

android.util.JsonReader（简单的Json解析工具）

它提供了下面的方法：
在这里插入图片描述
从它提供的方法来看它没有随机访问功能，只有顺序遍历功能，而且用户得到自己判断字段的数据类型。
在遍历数组前需要调用函数 beginArray，结束数组遍历时需要调用 endArray。
文档中的例子：

 * Suppose we'd like to parse a stream of messages such as the following:
 * [
 *   {
 *     "id": 912345678901,
 *     "text": "How do I read JSON on Android?",
 *     "geo": null,
 *     "user": {
 *       "name": "android_newb",
 *       "followers_count": 41
 *      }
 *   },
 *   {
 *     "id": 912345678902,
 *     "text": "@android_newb just use android.util.JsonReader!",
 *     "geo": [50.454722, -104.606667],
 *     "user": {
 *       "name": "jesse",
 *       "followers_count": 2
 *     }
 *   }
 * ]
 *     JsonReader reader = new JsonReader(new InputStreamReader(in, "UTF-8"));
 *     reader.beginArray();
 *     while (reader.hasNext()) {
	 *     reader.beginObject();
	 *     while (reader.hasNext()) {
	 *       String name = reader.nextName();
	 *       if (name.equals("id")) {
	 *         id = reader.nextLong();
	 *       } else if (name.equals("text")) {
	 *         text = reader.nextString();
	 *       } else if (name.equals("geo") && reader.peek() != JsonToken.NULL) {
	 *         geo = readDoublesArray(reader);
	 *       } else if (name.equals("user")) {
	 *         user = readUser(reader);
	 *       } else {
	 *         reader.skipValue();
	 *       }
	 *     }
	 *     reader.endObject();
 *     }
 *     reader.endArray();

android.util.JsonWriter（简单的Json生成工具）

这个类的调用流程与 JsonReader 大致是一样的。
它提供函数：
在这里插入图片描述

doubledong1994

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
安卓百宝箱：android.util.*

安卓百宝箱：android.util.*android.util.Rangeandroid.util.Rational如果下面的类中有你需要实现的功能，请使用 ctr+c/v，安卓源码阅读地址：http://androidxref.com/9.0.0_r3/xref/frameworks/base/core/java/android/util/android.util.Rangepublic final class Range<T extends Comparable<? super T
复制链接

扫一扫