android日记
Posted 是个写代码的
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了android日记相关的知识,希望对你有一定的参考价值。
上一篇:android日记(二)
1.alibaba Java开发规范
- 简洁、有美感,是一个有情怀的程序员应该写出的代码。
- 阿里出品,必属精品。github地址,定期更新,免费下载https://github.com/alibaba/p3c/blob/master/%E9%98%BF%E9%87%8C%E5%B7%B4%E5%B7%B4Java%E5%BC%80%E5%8F%91%E6%89%8B%E5%86%8C%EF%BC%88%E6%B3%B0%E5%B1%B1%E7%89%88%EF%BC%89.pdf
2.善用Objects工具类
- JDK#java.util.Objects类中包含了一些static工具方法,主要用于对Object对象的一些常用处理。Objects没有public构造方法,也不允许反射创建实例,否则报“No java.util.Objects instance for you”。
- Objects类中的方法,相比Object类,在安全性上升级。以下分别是Object和Objects类中的equals()方法,可以看出,Objects.equasl(a,b)相比a.equals(b),就不用担心a的空指针问题。同样安全性升级还包括Objects.hashCode()、Objects.toString()等方法。
Object:
public boolean equals(Object obj) { return (this == obj); }Objects:
public static boolean equals(Object a, Object b) { return (a == b) || (a != null && a.equals(b)); }
- Objects类中的方法,相比Object类,在功能上扩展。Objects.deepEquals()深度比较方法,可以根据内容比较两个数组对象。
public static boolean deepEquals(Object a, Object b) { if (a == b) return true; else if (a == null || b == null) return false; else return Arrays.deepEquals0(a, b); }
static boolean deepEquals0(Object e1, Object e2) { assert e1 != null; boolean eq; if (e1 instanceof Object[] && e2 instanceof Object[]) eq = deepEquals ((Object[]) e1, (Object[]) e2); else if (e1 instanceof byte[] && e2 instanceof byte[]) eq = equals((byte[]) e1, (byte[]) e2); else if (e1 instanceof short[] && e2 instanceof short[]) eq = equals((short[]) e1, (short[]) e2); else if (e1 instanceof int[] && e2 instanceof int[]) eq = equals((int[]) e1, (int[]) e2); else if (e1 instanceof long[] && e2 instanceof long[]) eq = equals((long[]) e1, (long[]) e2); else if (e1 instanceof char[] && e2 instanceof char[]) eq = equals((char[]) e1, (char[]) e2); else if (e1 instanceof float[] && e2 instanceof float[]) eq = equals((float[]) e1, (float[]) e2); else if (e1 instanceof double[] && e2 instanceof double[]) eq = equals((double[]) e1, (double[]) e2); else if (e1 instanceof boolean[] && e2 instanceof boolean[]) eq = equals((boolean[]) e1, (boolean[]) e2); else eq = e1.equals(e2); return eq; }
- JDK有个习惯,用复数类表示对应类的工具,与Objects类似的还有Arrays、Collections等。
3.Java的浅拷贝与深拷贝
- 不同于赋值(复制了一个引用变量,与原引用指向同一对象),对象拷贝的结果是生成一个新对象,与原对象是两个不同的对象。因此,a\'==a 的结果是false。
- 浅拷贝:拷贝出的新对象,其内部的对象成员,与原对象中的内部成员,具有相同引用(指向同一内存地址)。
- 深拷贝:拷贝出的新对象,其内部的对象成员,也是新生成的,与原对象中的内部成员,不是同一引用。只不过拷贝完,会给新对象的成员赋上与原对象成员一样的值。
- Object.clone()方法用于实现拷贝,但是clone方法是protected访问限制的,因此使用时,需要重写clone()方法,并修改访问权限为public。尤其要注意,需要用到clone的类一定要实现Clonable接口。否则,将throw CloneNotSupportException。
protected Object clone() throws CloneNotSupportedException { if (!(this instanceof Cloneable)) { throw new CloneNotSupportedException("Class " + getClass().getName() + " doesn\'t implement Cloneable"); } return internalClone(); }
- Object.clone()实现的是浅拷贝,下面的方法给予了验证。在TestModel中有成员thing为SomeThing对象。在clone()完成后,原对象thing成员的变更,会使拷贝对象发生联动变更。
public class TestModel implements Cloneable { private String name; private Integer number; private Something thing; @NonNull @Override public TestModel clone() throws CloneNotSupportedException { return (TestModel) super.clone();//浅拷贝 } ... }
//验证demo:
private void testClone() { Something something = new Something(); something.setThing("shallow copy"); String name = "clone object"; TestModel model = new TestModel(); model.setName(name); model.setNumber(123456); model.setThing(something); try { TestModel cloneModel = model.clone(); boolean b = cloneModel == model; boolean b1 = cloneModel.getName().equals(model.getName()); model.getThing().setThing("after clone");//modify original object will interact cloned object String st1 = model.getThing().getThing();//st1: after clone String st2 = cloneModel.getThing().getThing();//st2: after clone } catch (CloneNotSupportedException e) { e.printStackTrace(); } } - 如何实现深拷贝?自己在重写的clone()方法中new新对象,然后对新对象遍历式拷贝赋值。
public class TestModel implements Cloneable { private String name; private Integer number; private Something thing; @NonNull @Override public TestModel clone() throws CloneNotSupportedException {
//实现深拷贝 TestModel copy = new TestModel(); copy.setNumber(this.number); copy.setName(this.name); Something st = new Something(); st.setThing(this.thing.getThing()); copy.setThing(st); return copy; } ... }
4.equals()和==有什么区别
- equals()方法与“==”有什么区别?比较两个非基本类型的数据,“==”比较引用是否相等,equals()默认情况下也是比较引用。不信的话,看Object.equals()的实现。
public boolean equals(Object obj) { return (this == obj); }
- 那为什么江湖人常说“==”内存地址,equals()是比较内容呢?“==”比较引用(也就是,引用所指向的对象内存地址)是没问题的。但是说equals()是比较内容就不科学了。默认情况下,equals()效果与“==”一样,都是比较引用。那造成equals()比较内容的这种固有映像的原因在哪呢?
- 原因是有一些类重写了Object.equals()方法,拿String来说,重写后,equals()体内进行逐一比较字符串的字符,也就是再比较字符串的内容。这样干的还有Integer、Double、Long、Boolean等类。
public boolean equals(Object anObject) { if (this == anObject) { return true; } if (anObject instanceof String) { String anotherString = (String)anObject; int n = length(); if (n == anotherString.length()) { int i = 0; while (n-- != 0) { if (charAt(i) != anotherString.charAt(i)) return false; i++; } return true; } } return false; }
5.为什么重写equals()就一定需要重写hashCode()
- JAVA API文档关于hashCode有以下几点规定:
- 在应用某次执行期间,如果equals()方法比较的信息的不变,那么同一对象多次调用hashCode必须得到相同的结果。多次执行应用,不要求结果相同。
- 如果两个对象通过equals()方法比较是相等的,那么他们的hashCode也一定要相同。
- 如果两个对象通过equals()方法比较是不相等的,不要求他们的hashCode必须不同。但是程序员应该意识到,不同的对象具有不同的hashCode有助于哈希表的性能。
- hashCode()是一个native方法,返回的根据对象的内存地址计算出来的一个int值。
- 一切还要从键值对集合(HashMap,HashSet、HashTable)的存储原理说起,拿HashMap的put方法来看下,put一个对象进table时,是拿(n-1)&hash做的key,而hash实际就是(Key,Value)键值中键的hashCode()。
public V put(K key, V value) { return putVal(hash(key), key, value, false, true); }
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node<K,V>[] tab; Node<K,V> p; int n, i; if ((tab = table) == null || (n = tab.length) == 0) //数组为空,则进行初始化 n = (tab = resize()).length; if ((p = tab[i = (n - 1) & hash]) == null) //如果tab[i]不存在,就在i位置存储这个对象,其中i=(n-1)&h。 tab[i] = newNode(hash, key, value, null); else { //更新oldValue ... return oldValue; } return null; }
static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); }
- 从而,如果键对象Key被重写过equals()方法,改变了相等判断规则,使得两个不同的对象变得相等。然而,当这个对象做为Key键用于HashMap时,就会出现equals()判断相等的两个对象,其hashCode()结果却不等,造成两次put相同的Key时,结果增加了一条数据,而不是更新这个Key对应的Value。看下面这个例子,就是Key对象的equals()方法得到了重写,却忽视了hashCode()方法。
private void testHashMap() { CustomKey customKey1 = new CustomKey(1, "是个写代码的"); CustomKey customKey2 = new CustomKey(1, "是个写代码的"); Map<CustomKey, String> map = new HashMap<>(); String result1 = map.put(customKey1, "value1"); String result2 = map.put(customKey2, "value2");//同一个key,添加了两条数据,而不是更新 } private class CustomKey { private int number; private String name; CustomKey(int number, String name) { this.number = number; this.name = name; } @Override public boolean equals(@Nullable Object obj) { if (this == obj) { return true; } if (obj instanceof CustomKey) { CustomKey objKey = (CustomKey) obj; return objKey.number == this.number && objKey.name.equals(this.name); } return false; } }
- 比如String重写equals()后,根据字符串的内容判断对象是否相等,这时候,相应的hashCode()也重写为以内容组装的结果。
private void testHashMap() {
String key1 = new String("key");
String key2 = new String("key"); Map<String, String> map = new HashMap<>(); String result1 = map.put(key1, "value1"); String result2 = map.put(key2, "value2");//将key对应的值由value1改成value2 }//String重写了equals()方法
public boolean equals(Object anObject) { if (this == anObject) { return true; } if (anObject instanceof String) { String anotherString = (String)anObject; int n = length(); if (n == anotherString.length()) { int i = 0; while (n-- != 0) { if (charAt(i) != anotherString.charAt(i)) return false; i++; } return true; } } return false; }//String重写了equals()方法
public int hashCode() {
int h = hash;
final int len = length();if (h == 0 && len > 0) { for (int i = 0; i < len; i++) { h = 31 * h + charAt(i); } hash = h; } return h; }
- 于是乎,可以参考String类的重写方式,对CustomKey类也重写以下hashCode()方法,使得两个对象equasl()相等时,他们的hashCode()值也相等。
@Override public int hashCode() { return Integer.valueOf(this.number).hashCode() + this.name.hashCode();//与String类似,Integer类也重写了hashCode() }
- 总结:如果只重写equals()方法,使得两个不同的对象相等时,而不重写hashCode()使他们的hashCode也相等,那么在散列表集合中,他们计算key值将不同,将无法正常存取数据了。
6.Byte能表示的整数范围到底是[-127,127]还是[-128,127]
- Byte是8位二进制,最高位用于符号位,正数符号位为1,负数符号数为0。
- 负数的二进制表示:计算机以补码进行存储和运算,正数的补码=反码=原码,负数的补码等于原码取反后加1。
+4(Byte) 原码:0000 0100 反码:0000 0100 补码:0000 0100 -5(Byte) 原码:1000 0101 反码:1111 1010 补码:1111 1011 计算4-5,实际是计算4+(-5): 0000 0100 + 1111 1011 ————————— =1111 1111 (补) = 1111 1110(反) = 1000 0001(原)= -1(真值) 备注: 1.计算反码时,符号位不参与取反; 2.计算补码时,符号位也不参与计算(其实除了-128,[-127,0]的反码最高位之后总会出现0,+1运算时,都不会发生最高位的进位); 3.加减乘除运算时,符号位也参与计算,计算结果是补码,然后减1取反得到原码。
- 那是不是就表示,byte最小位1111 1111,最大位01111 111,即[-127,127]呢?其实也差不多,主要是还可以表示-128,也就是一个byte能表示的整数范围是[-128,127]。
- 首先搞懂为什么要有补码,因为计算器不像人脑,能够很好的把最高位符号位与真值位区分开来,机器更希望把符号位也带入运算。然后人们探索后发现,如果把负数取反加1后,就可以让符合位也参与到计算,得到正确的计算结果。
- 这时候,1-1这样的运算结果永远是0000 0000,而不会出现1000 0000(所谓的负0)。而恰好-127-1的计算结果是1000 0000,就定义用1000 0000来表示-128。
-1(Byte) 原码:1000 0001 反码:1111 1110 补码:1111 1111 计算1-1,实际是计算1+(-1): 0000 0001 + 1111 1111 ————————— =0000 0000 (补) = 1111 1111(反) = 0000 0000(原)= 0(真值) 计算-127-1,实际是计算-127+(-1): 1000 0001 + 1111 1111 ————————— = 1000 0000 (补) = 0111 1111(反) = 1000 0000(原)= -128(真值)
- 总结:本来1000 0000谁也表示不了,相当于浪费了一种表示。那用它来表达谁合适呢,恰好-127-1等于1000 0000,那就用它来表示-128吧。
7.Byte无符号右移>>>的坑
- >>与<<分别是带符号的位右移和左移运算符,>>>是无符号的右移运算,不存在<<<运算。
- 至于>>与>>>的区别在于,>>右移的时候符号位跟着一起移动,高位补符号位,即正数补0,负数补1;>>>右移的时候,是不带符号位一起移动的,不论正数负数,高位都是补0。
- 正数没啥好说的,主要看负数。看下面的表达式,明明定义的byte是个负数,但实际结果怎么就成了正数呢?原因在于超出[-128,127]范围后,会向上转型为int。
byte b = (byte) -129;
实际结果=127;下面给出计算过程:
int型-129,
原码:1000 0000 0000 0000 0000 0000 1000 0001
反码:1111 1111 1111 1111 1111 1111 0111 1110
补码:1111 1111 1111 1111 1111 1111 0111 1111
截断为byte:0111 1111
转为原码:0111 1111 - 再来看负数的右移动,带符号的右移动也没什么好说的,主要是无符号右移动>>>,对于byte b = -5,无符号右移时高位补0,那你就以为会移成一个正数吗?下面的结果显示-5>>>2=-2。原因同样是发生了int强转,丢失了精度。
Byte -5: 原码:1000 0101 反码:1111 1010 补码:1111 1011 >>2 带符号右移两位,高位补1, 结果:1111 1110 转为原码:1000 0010 = -2
>>>2 无符号右移两位,高位补0, 过程:1 0011 1110 超出[-128,127]的范围,会向上转型为int,即-5的补码为,
byte强转为int:1111 1111 1111 1111 1111 1111 1111 1011
再右移2位:0011 1111 1111 1111 1111 1111 1111 1110
int强转回byte: 1111 1110 转为原码:1000 0101 = -2
8.使用位运算设置View状态
- 位运算,就是直接对整数在内存中的二进制位进行操作。 因此,位运算最直接的好处就是节省内存空间,提高运算效率。
- 假设现在有一自定义CustomView,其显示内容或者布局样式根据外部4种状态设定。
CustomView <-- {FLAH_A、FLAG_B、FLAG_C、FLAG_D}
- 使用状态变量实现,通常需要定义4种状态对应的boolean值,然后做相应条件下的ui处理。
class CustomView { public boolean FLAG_A = false; public boolean FLAG_B = false; public boolean FLAG_C = false; public boolean FLAG_D = false; public CustomView(boolean a, boolean b, boolean c, boolean d) { this.FLAG_A = a; this.FLAG_B = b; this.FLAG_C = c; this.FLAG_D = d; initView(); } private void initView() { if (FLAG_A) { //view handle state for FLAG_A } if (FLAG_B) { //view handle state for FLAG_B } if (FLAG_C) { //view handle state for FLAG_C } if (FLAG_D) { //view handle state for FLAG_D } }
- 使用位运算,使用&位运算的结果来判断各种状态。CustomView构造时传入一个int状态值,需要添加的状态就|位运算添加状态。例如,需要添加A、C两种状态,int status = FLAG_A | FLAG_C;
class CustomView { public final int FLAG_A = 1; public final int FLAG_B = 1 << 1; public final int FLAG_C = 1 << 2; public final int FLAG_D = 1 << 3; public CustomView(int status) { initView(status); } private void initView(int status) { if ((status & FLAG_A) == FLAG_A) { //view handle state for FLAG_A } if ((status & FLAG_B) == FLAG_B) { //view handle state for FLAG_B } if ((status & FLAG_C) == FLAG_C) { //view handle state for FLAG_C } if ((status & FLAG_D) == FLAG_D) { //view handle state for FLAG_D } } }
- 利用位操作实现状态增删检查。
private int mState = 0; //添加状态 private void addState(int flag) { mState &= flag; } //移除状态 private void removeState(int flag) { mState &= ~flag; } //检查状态 private boolean checkState(int flag) { return flag == (mState | flag); }
- 如果你觉得位运算不易阅读,也可以借助java.util.EnumSet实现状态管理,其内部已经帮你完成了位运算,但是枚举带来的内存开销也是不得不考虑的问题。
private EnumSet<Flags> enumSet = EnumSet.noneOf(Flags.class); private enum Flags { FLAG_A, FLAG_B, FLAG_C, FLAG_D } private void addState(Flags flag) { enumSet.add(flag); } private void removeState(Flags flag) { enumSet.remove(flag); } private boolean checkState(Flags flag) { return enumSet.contains(flag); }
9.HashMap中的hash扰动函数
- HashMap本质是一个链表数组,以键值对Key-Value方式进行存取。计算数组index时,是以Key对象的hashCode()作为基础,然后进行一些扰动计算后得到。
//JDK1.8中hashMap#put()源码
public V put(K key, V value) { return putVal(hash(key), key, value, false, true); } final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node<K,V>[] tab; Node<K,V> p; int n, i; if ((tab = table) == null || (n = tab.length) == 0) n = (tab = resize()).length; if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); ... } static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); } - 首先,tab[i=(n-1)&hash]这句显示,index = (n-1) & h,这句话表示h对n的取模,也就是计算余数,关于这个结论的推导过程在看本文下节中有说明。这里n是当前hashMap数组的长度,那为什么要对n取模呢?原因在于,hashCode()本身是个int值(32位),从-2147483648到2147483648,前后共40亿的空间,然而内存是放不下一个长度为40亿的数组的,所以是不可能直接用hashCode()值用作index的。而HashMap的初始长度是16,而后随着存储数据的增加到扩容阈值时,进行2倍扩容。因此,用对n的取模结果作为index是非常有必要的。
对于长度为16的hashMap,现有一个hash值的低16位掩码为 hash: 10100101 11100101 & n-1: 0000000 00001111 ---------------------
index: 0000000 00000101 //高位全部清零,只保留末4位 index = 5 - 其次,h = hash(key),hash(key)方法不是直接返回key的hashCode()就完事了,而是当key不为空时,返回(h = key.hashCode()) ^ (h >>> 16),也就是key对象的hashCode()值与它右移16位后异或的结果,这个操作过程就叫做对hashCode的扰动。
- 要弄懂扰动函数的意义,还要从扰动的计算过程入手。hash = h^(h>>>16)相当于让h的高位和低位进行了异或,成为hash的低位,hash的高位与原h的高位一样。
h=hashCode(): 1100 1001 0011 1010 1110 0110 0111 0101 __________________________________________________ h: 1100 1001 0011 1010 1110 0110 0111 0101 h>>>16: 0000 0000 0000 0000 1100 1001 0011 1010 ---------------------------------------------------- h^(h>>>16): 1100 1001 0011 1010 0010 1111 0100 1111 //高半区不变,低半区混合了原始哈希码的高位和低位。
这样的好处在于,在随后计算index时,要对hash取模,由于hashMap的长度一般不会超过16位(2^16),从而大概率会丢弃hash的高位,只留下了hash低位。而扰动后的hash低位部分,混合了原始哈希码的高位和低位信息。
- 试想一下,如果不进行扰动,两个原本不同的hash值,他们高位不相同,但恰好取模留下来的低位部分相同,那么他们将得到相同的index,从而发生碰撞。而当扰动后,低位部分也保留了高位信息,再取模后,相等的概率就大大降低,这对减少hash碰撞是非常有意义的。
10.证明h = (n-1)&h是h对n的取模运算
- 当n=2k时,证明h%n = h&(n-1)。
- 设h的二进制表示式为h=xmxm-1xm-2...x1x0,则h=xm*2m+xm-1*2m-1+xm-2*2m-2+...+x1*21+x0*20。当h表示hashCode为int型时,m=30;
- 从而h%n = h%2m =(xm*2m+xm-1*2m-1+xm-2*2m-2+...+x1*21+x0*20)% 2k。
- 由于n=2k,则n-1的二进制表达是000 0111,末尾有k个1,前面全是0,记做(000...111)k。
- 当k>m时,h的每一项都比2k小,从而h%n = h,结果是h本身。
- 当k>m时,h&(n-1) = (xmxm-1xm-2...x1x0) & (000...111)k = (xmxm-1xm-2...x1x0) = h,结果也是h本身。
- 因此,当k>m时,h&(n-1) = h = h%n。
- 当k<=m时,余数h%2k = xk*2k+xk-1*2k-1+xk-2*2k-2+...+x1*21+x0*20。余数长度为k,记做xkxk-1xk-2...x1x0。
- 当k<=m时,h&(n-1) = (xmxm-1xm-2...xkxk-1xk-2...x1x0) & (000...111)k = xkxk-1xk-2...x1x0。
- 因此,当k<=m时,h&(n-1) = xkxk-1xk-2...x1x0 = h%n。
- 综合两种情况,都满足h&(n-1) = h%n。所以说,在n是2的幂时,h&(n-1)就是h对n的取模运算。
下一篇:android日记(四)
以上是关于android日记的主要内容,如果未能解决你的问题,请参考以下文章