找到
556
篇与
酷游
相关的结果
- 第 108 页
-
深度分析Java的枚举类型----枚举的线程安全性及序列化问题 写在前面：Java SE5提供了一种新的类型-Java的枚举类型，关键字enum可以将一组具名的值的有限集合创建为一种新的类型，而这些具名的值可以作为常规的程序组件使用，这是一种非常有用的功能。本文将深入分析枚举的源码，看一看枚举是怎么实现的，他是如何保证线程安全的，以及为什么用枚举实现的单例是最好的方式。 枚举是如何保证线程安全的 要想看源码，首先得有一个类吧，那么枚举类型到底是什么类呢？是enum吗？答案很明显不是，enum就和class一样，只是一个关键字，他并不是一个类，那么枚举是由什么类维护的呢，我们简单的写一个枚举： public enum t { SPRING,SUMMER,AUTUMN,WINTER; } 然后我们使用反编译，看看这段代码到底是怎么实现的，反编译（Java的反编译）后代码内容如下： public final class T extends Enum { private T(String s, int i) { super(s, i); } public static T[] values() { T at[]; int i; T at1[]; System.arraycopy(at = ENUM$VALUES, 0, at1 = new T[i = at.length], 0, i); return at1; } public static T valueOf(String s) { return (T)Enum.valueOf(demo/T, s); } public static final T SPRING; public static final T SUMMER; public static final T AUTUMN; public static final T WINTER; private static final T ENUM$VALUES[]; static { SPRING = new T("SPRING", 0); SUMMER = new T("SUMMER", 1); AUTUMN = new T("AUTUMN", 2); WINTER = new T("WINTER", 3); ENUM$VALUES = (new T[] { SPRING, SUMMER, AUTUMN, WINTER }); } } 通过反编译后代码我们可以看到，public final class T extends Enum，说明，该类是继承了Enum类的，同时final关键字告诉我们，这个类也是不能被继承的。当我们使用enmu来定义一个枚举类型的时候，编译器会自动帮我们创建一个final类型的类继承Enum类,所以枚举类型不能被继承，我们看到这个类中有几个属性和方法。 我们可以看到： public static final T SPRING; public static final T SUMMER; public static final T AUTUMN; public static final T WINTER; private static final T ENUM$VALUES[]; static { SPRING = new T("SPRING", 0); SUMMER = new T("SUMMER", 1); AUTUMN = new T("AUTUMN", 2); WINTER = new T("WINTER", 3); ENUM$VALUES = (new T[] { SPRING, SUMMER, AUTUMN, WINTER }); } 都是static类型的，因为static类型的属性会在类被加载之后被初始化，我们在深度分析Java的ClassLoader机制（源码级别）和Java类的加载、链接和初始化两个文章中分别介绍过，当一个Java类第一次被真正使用到的时候静态资源被初始化、Java类的加载和初始化过程都是线程安全的。所以，创建一个enum类型是线程安全的。 为什么用枚举实现的单例是最好的方式 在[转+注]单例模式的七种写法中，我们看到一共有七种实现单例的方式，其中，Effective Java作者Josh Bloch 提倡使用枚举的方式，既然大神说这种方式好，那我们就要知道它为什么好？ 1. 枚举写法简单 写法简单这个大家看看[转+注]单例模式的七种写法里面的实现就知道区别了。 public enum EasySingleton{ INSTANCE; } 你可以通过EasySingleton.INSTANCE来访问。 2. 枚举自己处理序列化 我们知道，以前的所有的单例模式都有一个比较大的问题，就是一旦实现了Serializable接口之后，就不再是单例得了，因为，每次调用 readObject()方法返回的都是一个新创建出来的对象，有一种解决办法就是使用readResolve()方法来避免此事发生。但是，为了保证枚举类型像Java规范中所说的那样，每一个枚举类型极其定义的枚举变量在JVM中都是唯一的，在枚举类型的序列化和反序列化上，Java做了特殊的规定。原文如下： Enum constants are serialized differently than ordinary serializable or externalizable objects. The serialized form of an enum constant consists solely of its name; field values of the constant are not present in the form. To serialize an enum constant, ObjectOutputStream writes the value returned by the enum constant’s name method. To deserialize an enum constant, ObjectInputStream reads the constant name from the stream; the deserialized constant is then obtained by calling the java.lang.Enum.valueOf method, passing the constant’s enum type along with the received constant name as arguments. Like other serializable or externalizable objects, enum constants can function as the targets of back references appearing subsequently in the serialization stream. The process by which enum constants are serialized cannot be customized: any class-specific writeObject, readObject, readObjectNoData, writeReplace, and readResolve methods defined by enum types are ignored during serialization and deserialization. Similarly, any serialPersistentFields or serialVersionUID field declarations are also ignored–all enum types have a fixedserialVersionUID of 0L. Documenting serializable fields and data for enum types is unnecessary, since there is no variation in the type of data sent. 大概意思就是说，在序列化的时候Java仅仅是将枚举对象的name属性输出到结果中，反序列化的时候则是通过java.lang.Enum的valueOf方法来根据名字查找枚举对象。同时，编译器是不允许任何对这种序列化机制的定制的，因此禁用了writeObject、readObject、readObjectNoData、writeReplace和readResolve等方法。 我们看一下这个valueOf方法： public static T valueOf(Class enumType,String name) { T result = enumType.enumConstantDirectory().get(name); if (result != null) return result; if (name == null) throw new NullPointerException("Name is null"); throw new IllegalArgumentException( "No enum const " + enumType +"." + name); } 从代码中可以看到，代码会尝试从调用enumType这个Class对象的enumConstantDirectory()方法返回的map中获取名字为name的枚举对象，如果不存在就会抛出异常。再进一步跟到enumConstantDirectory()方法，就会发现到最后会以反射的方式调用enumType这个类型的values()静态方法，也就是上面我们看到的编译器为我们创建的那个方法，然后用返回结果填充enumType这个Class对象中的enumConstantDirectory属性。 所以，JVM对序列化有保证。 3.枚举实例创建是thread-safe(线程安全的) 我们在深度分析Java的ClassLoader机制（源码级别）和Java类的加载、链接和初始化两个文章中分别介绍过，当一个Java类第一次被真正使用到的时候静态资源被初始化、Java类的加载和初始化过程都是线程安全的。所以，创建一个enum类型是线程安全的。
-
你以为用了BigDecimal后，计算结果就一定精确了？ BigDecimal，相信对于很多人来说都不陌生，很多人都知道他的用法，这是一种java.math包中提供的一种可以用来进行精确运算的类型。 很多人都知道，在进行金额表示、金额计算等场景，不能使用double、float等类型，而是要使用对精度支持的更好的BigDecimal。 所以，很多支付、电商、金融等业务中，BigDecimal的使用非常频繁。但是，如果误以为只要使用BigDecimal表示数字，结果就一定精确，那就大错特错了！ 在之前的一篇文章中，我们介绍过，使用BigDecimal的equals方法并不能验证两个数是否真的相等（为什么阿里巴巴禁止使用BigDecimal的equals方法做等值比较？）。 除了这个情况，BigDecimal的使用的第一步就是创建一个BigDecimal对象，如果这一步都有问题，那么后面怎么算都是错的！ 那到底应该如何正确的创建一个BigDecimal？ 关于这个问题，我Review过很多代码，也面试过很多一线开发，很多人都掉进坑里过。这是一个很容易被忽略，但是又影响重大的问题。 关于这个问题，在《阿里巴巴Java开发手册》中有一条建议，或者说是要求：  这是一条【强制】建议，那么，这背后的原理是什么呢？ 想要搞清楚这个问题，主要需要弄清楚以下几个问题： 1、为什么说double不精确？ 2、BigDecimal是如何保证精确的？ 在知道这两个问题的答案之后，我们也就大概知道为什么不能使用BigDecimal(double)来创建一个BigDecimal了。 double为什么不精确 首先，计算机是只认识二进制的，即0和1，这个大家一定都知道。 那么，所有数字，包括整数和小数，想要在计算机中存储和展示，都需要转成二进制。 十进制整数转成二进制很简单，通常采用”除2取余，逆序排列”即可，如10的二进制为1010。 但是，小数的二进制如何表示呢？ 十进制小数转成二进制，一般采用”乘2取整，顺序排列”方法，如0.625转成二进制的表示为0.101。 但是，并不是所有小数都能转成二进制，如0.1就不能直接用二进制表示，他的二进制是0.000110011001100… 这是一个无限循环小数。 所以，计算机是没办法用二进制精确的表示0.1的。也就是说，在计算机中，很多小数没办法精确的使用二进制表示出来。 那么，这个问题总要解决吧。那么，人们想出了一种采用一定的精度，使用近似值表示一个小数的办法。这就是IEEE 754（IEEE二进制浮点数算术标准）规范的主要思想。 IEEE 754规定了多种表示浮点数值的方式，其中最常用的就是32位单精度浮点数和64位双精度浮点数。 在Java中，使用float和double分别用来表示单精度浮点数和双精度浮点数。 所谓精度不同，可以简单的理解为保留有效位数不同。采用保留有效位数的方式近似的表示小数。 所以，大家也就知道为什么double表示的小数不精确了。 接下来，再回到BigDecimal的介绍，我们接下来看看是如何表示一个数的，他如何保证精确呢？ BigDecimal如何精确计数？ 如果大家看过BigDecimal的源码，其实可以发现，实际上一个BigDecimal是通过一个”无标度值”和一个”标度”来表示一个数的。 在BigDecimal中，标度是通过scale字段来表示的。 而无标度值的表示比较复杂。当unscaled value超过阈值(默认为Long.MAX_VALUE)时采用intVal字段存储unscaled value，intCompact字段存储Long.MIN_VALUE，否则对unscaled value进行压缩存储到long型的intCompact字段用于后续计算，intVal为空。 涉及到的字段就是这几个： public class BigDecimal extends Number implements Comparable { private final BigInteger intVal; private final int scale; private final transient long intCompact; } 关于无标度值的压缩机制大家了解即可，不是本文的重点，大家只需要知道BigDecimal主要是通过一个无标度值和标度来表示的就行了。 那么标度到底是什么呢？ 除了scale这个字段，在BigDecimal中还提供了scale()方法，用来返回这个BigDecimal的标度。 /** * Returns the scale of this {@code BigDecimal}. If zero * or positive, the scale is the number of digits to the right of * the decimal point. If negative, the unscaled value of the * number is multiplied by ten to the power of the negation of the * scale. For example, a scale of {@code -3} means the unscaled * value is multiplied by 1000. * * @return the scale of this {@code BigDecimal}. */ public int scale() { return scale; } 那么，scale到底表示的是什么，其实上面的注释已经说的很清楚了： 如果scale为零或正值，则该值表示这个数字小数点右侧的位数。如果scale为负数，则该数字的真实值需要乘以10的该负数的绝对值的幂。例如，scale为-3，则这个数需要乘1000，即在末尾有3个0。 如123.123，那么如果使用BigDecimal表示，那么他的无标度值为123123，他的标度为3。 而二进制无法表示的0.1，使用BigDecimal就可以表示了，及通过无标度值1和标度1来表示。 我们都知道，想要创建一个对象，需要使用该类的构造方法，在BigDecimal中一共有以下4个构造方法： BigDecimal(int) BigDecimal(double) BigDecimal(long) BigDecimal(String) 以上四个方法，创建出来的的BigDecimal的标度（scale）是不同的。 其中 BigDecimal(int)和BigDecimal(long) 比较简单，因为都是整数，所以他们的标度都是0。 而BigDecimal(double) 和BigDecimal(String)的标度就有很多学问了。 BigDecimal(double)有什么问题 BigDecimal中提供了一个通过double创建BigDecimal的方法——BigDecimal(double) ，但是，同时也给我们留了一个坑！ 因为我们知道，double表示的小数是不精确的，如0.1这个数字，double只能表示他的近似值。 所以，当我们使用new BigDecimal(0.1)创建一个BigDecimal 的时候，其实创建出来的值并不是正好等于0.1的。 而是0.1000000000000000055511151231257827021181583404541015625。这是因为doule自身表示的只是一个近似值。  所以，如果我们在代码中，使用BigDecimal(double) 来创建一个BigDecimal的话，那么是损失了精度的，这是极其严重的。 使用BigDecimal(String)创建 那么，该如何创建一个精确的BigDecimal来表示小数呢，答案是使用String创建。 而对于BigDecimal(String) ，当我们使用new BigDecimal(“0.1”)创建一个BigDecimal 的时候，其实创建出来的值正好就是等于0.1的。 那么他的标度也就是1。 但是需要注意的是，new BigDecimal(“0.10000”)和new BigDecimal(“0.1”)这两个数的标度分别是5和1，如果使用BigDecimal的equals方法比较，得到的结果是false，具体原因和解决办法参考为什么阿里巴巴禁止使用BigDecimal的equals方法做等值比较？ 那么，想要创建一个能精确的表示0.1的BigDecimal，请使用以下两种方式： BigDecimal recommend1 = new BigDecimal("0.1"); BigDecimal recommend2 = BigDecimal.valueOf(0.1); 这里，留一个思考题，BigDecimal.valueOf()是调用Double.toString方法实现的，那么，既然double都是不精确的，BigDecimal.valueOf(0.1)怎么保证精确呢？ 总结 因为计算机采用二进制处理数据，但是很多小数，如0.1的二进制是一个无线循环小数，而这种数字在计算机中是无法精确表示的。 所以，人们采用了一种通过近似值的方式在计算机中表示，于是就有了单精度浮点数和双精度浮点数等。 所以，作为单精度浮点数的float和双精度浮点数的double，在表示小数的时候只是近似值，并不是真实值。 所以，当使用BigDecimal(Double)创建一个的时候，得到的BigDecimal是损失了精度的。 而使用一个损失了精度的数字进行计算，得到的结果也是不精确的。 想要避免这个问题，可以通过BigDecimal(String)的方式创建BigDecimal，这样的情况下，0.1就会被精确的表示出来。 其表现形式是一个无标度数值1，和一个标度1的组合。
-
Intellij IDEA快捷键for mac 10.5+ 图标如下： ⇧ Shift ⌃ Control ⌥ Option ⌘ Command IntelliJ IDEA ⌘ , Preferences… ⌘ Q Quit IntelliJ IDEA File ⌘ ; Project Structure… ⌘ S Save All ⌥⌘ Y Synchronize Edit ⌘ Z 撤销 ⌘ X 剪切 ⌘ C 复制 ⇧⌘ C 复制当前行（ JSONArray dataArray = jsonObject.getJSONArray(“data”); ） ⌥⇧⌘ C 复制引用（com/alibaba/intl/batch/label/marking/VipMarker.java:75） ⌘ V 粘贴 ⇧⌘ V 从历史中粘贴 ⌘ F 查找 ⌘ R 替换 ⌘ G 和查找配合使用，寻找下一个 ⇧⌘ G 和查找配合使用，寻找上一个 ⌃⌘ G 选中所有相同的内容 ⇧⌘ F 从path中找 ⌥F7 查找在哪被引用 ⌘F7 跳转到引用的地方（当前文件） ⌥ ↑ 扩展选中 ⌥ ↓ 收缩选中 ⌥ 向左箭头 向左前进一个单词 ⌥ 向右箭头 向右前进一个单词 ⌘ D 复制当前行，并在下一行粘贴出来 ⌘ Backspace 删除当前行 ⌘ 向左箭头 到当前行首 ⌘ 向右箭头 到当前行尾 View 未完待续。。。
-
-
Java中的增强for循环（for each）的实现原理与坑 在JAVA中，遍历集合和数组一般有以下三种形式： for (int i = 0; i < list.size(); i++) { System.out.print(list.get(i) + ","); } Iterator iterator = list.iterator(); while (iterator.hasNext()) { System.out.print(iterator.next() + ","); } for (Integer i : list) { System.out.print(i + ","); } 第一种是普通的for循环遍历、第二种是使用迭代器进行遍历，第三种我们一般称之为增强for循环（for each）。 实现原理 可以看到，第三种形式是JAVA提供的语法糖，这里我们剖洗一下，这种增强for循环底层是如何实现的。 我们对以下代码进行反编译： for (Integer i : list) { System.out.println(i); } 反编译后： Integer i; for(Iterator iterator = list.iterator(); iterator.hasNext(); System.out.println(i)){ i = (Integer)iterator.next(); } 反编译后的代码其实比较复杂，我们按照执行顺序拆解一下： Integer i; 定义一个临时变量i Iterator iterator = list.iterator(); 获取List的迭代器 iterator.hasNext(); 判断迭代器中是否有未遍历过的元素 i = (Integer)iterator.next(); 获取第一个未遍历的元素，赋值给临时变量i System.out.println(i) 输出临时变量i的值 如此循环往复，直到遍历完List中的所有元素。 通过反编译，我们看到，其实JAVA中的增强for循环底层是通过迭代器模式来实现的。 坑 既然增强for循环通过迭代器实现，那么必然有迭代器的特性。在Java中的fail-fast机制中有介绍过。在使用迭代器遍历元素的时候，在对集合进行删除的时候一定要注意，使用不当有可能发生ConcurrentModificationException，如以下代码： for (Student stu : students) { if (stu.getId() == 2) students.remove(stu); } 会抛出ConcurrentModificationException异常。 Iterator是工作在一个独立的线程中，并且拥有一个 mutex 锁。 Iterator被创建之后会建立一个指向原来对象的单链索引表，当原来的对象数量发生变化时，这个索引表的内容不会同步改变，所以当索引指针往后移动的时候就找不到要迭代的对象，所以按照 fail-fast 原则 Iterator 会马上抛出java.util.ConcurrentModificationException异常。 所以 Iterator 在工作的时候是不允许被迭代的对象被改变的。但你可以使用 Iterator 本身的方法 remove() 来删除对象，Iterator.remove() 方法会在删除当前迭代对象的同时维护索引的一致性。 正确的在遍历的同时删除元素的姿势： Iterator stuIter = students.iterator(); while (stuIter.hasNext()) { Student student = stuIter.next(); if (student.getId() == 2) stuIter.remove();//这里要使用Iterator的remove方法移除当前对象，如果使用List的remove方法，则同样会出现ConcurrentModificationException }
