Java 基础知识的一些易错点

2020-03-14 16:05:22来源：博客园阅读 ()

Java 基础知识的一些易错点

1、正确使用 equals()

Object的equals方法容易抛空指针异常，应使用常量或确定有值的对象来调用 equals。

String str = null;
if (str.equals("abcd")) {
  ...
} else {
  ...
}

如果变量str为null，会抛出空指针异常，如果没有catch来捕获处理（我们一般不会在equals()上加try），程序直接就终止运行了。

abcd".equals(str)

把常量写在前面，“abcd”！=null，结果为false，不会抛出异常。

但2个都是变量呢？

最推荐下面的方式：使用工具类Objects（JDK7自带的）

Objects.equals(str,"abcd")

就算2个都是变量，2个都是null，都不会抛出异常。如果2个都是null，null==null，返回true。

Objects的部分源码如下：

public static boolean equals(Object a, Object b) {
        // 如果a==null的话此时a.equals(b)就不会得到执行，避免出现空指针异常。
        return (a == b) || (a != null && a.equals(b));
}

||、&&都是断路的，如果||前面为true，就不会执行后面的判断；如果&&前面为false，就不会执行后面的判断。

equals()的作用范围比==大。

==只能判断相同类型的数据，比如2个都是数值型（数值型归为一类）、都是字符串，都是User类型。如果2个的类型不同，比如 if(1==“1”），一个是数值型、一个是String，通不过编译。

equals()则无此要求，不管2个的数据类型相不相同都可以。

2、基本类型、包装类型值的比较

2个都是基本类型，或者2个都是基本类型的常量，

或者基本类型、包装类型（包装类型属于引用类型），或者基本类型、基本类型的常量，或者包装类型、基本类型的常量，

只要2个不全是包装类型，进行比较，不管是使用==、还是equals()，都是使用值进行比较，都可以。

如果2个都是包装类型，==比较的是2个对象的地址，肯定不相同。

有特例：如果2个都是Integer，当数值在-128 ~127时，会将创建的 Integer 对象缓存起来，当下次再出现该数值时，直接从缓存中取出对应的Integer对象。

Integer x = 3;  
Integer y = 3;  //2个都是Integer，值相同，且在-128~127之间，不会创建一个新的Integer对象，而是直接指向x指向的对象，即x、y都指向堆中的同一个Integer对象
System.out.println(x == y); // 都是引用类型，==根据地址进行比较，x、y的地址是相同的，返回true

包装类型都重写了equals()，都是使用值进行比较，2个都是包装类型应该使用equals()来比较。

3. BigDecimal的使用

计算机表示浮点数的方式，会造成浮点数精度的丢失，计算机不能精确地表示浮点数：

        float a = 1.0f - 0.9f;
        float b = 0.9f - 0.8f;
        System.out.println(a);// 0.100000024
        System.out.println(b);// 0.099999964
        System.out.println(a==b);// false

不管是单精度、双精度，不管是浮点数的基本类型、还是浮点数的包装类型，都存在这个问题。

当然，双精度能表示的小数位数更多，比单精度更加精确，但小数位数多了之后，依旧会丢失精度。

使用BigDecimal类来表示浮点数可解决浮点数精度丢失的问题，因为是以字符串的形式存储数值。

BigDecimal a = new BigDecimal("1.0");  //参数是字符串，传递数值会丢失精度
BigDecimal b = new BigDecimal("0.9");
BigDecimal c = new BigDecimal("0.8");
BigDecimal x = a.subtract(b);// 0.1
BigDecimal y = b.subtract(c);// 0.1
System.out.println(x.equals(y));// true

进行数学运算也要使用BigDecimal中提供的方法，确保精度不丢失。

BigDecimal类重写了equals()，是根据值进行比较2个BigDecimal对象。

大小比较：

BigDecimal a = new BigDecimal("1.0");
BigDecimal b = new BigDecimal("0.9");
System.out.println(a.compareTo(b));// 1

a.compareTo(b) : 返回 -1 表示前面一个小，0 表示相等， 1表示前面一个大。

保留几位小数：

BigDecimal m = new BigDecimal("1.255433");
BigDecimal n = m.setScale(3,BigDecimal.ROUND_HALF_DOWN); //第一个参数指定保留几位小数，第二个参数指定后面部分的处理方式，BigDecimal.ROUND_HALF_DOWN即四舍五入
System.out.println(n);// 1.255

BigDecimal的构造函数：

//推荐这种
BigDecimal a = new BigDecimal("1.6");
System.out.println(a); //1.6

//其次是这种，会先执行Double的toString()方法将1.6转换为字符串，再调用上面一种方式创建BigDecimal对象。相比第一种,开销大一些
BigDecimal b = BigDecimal.valueOf(1.6);
System.out.println(b); //1.6

//其它直接传入数值的都不推荐，因为会丢失精度
BigDecimal c=new BigDecimal(1.6);
System.out.println(c); //1.600000000000000088817841970012523233890533447265625

第二种的源码如下：

public static BigDecimal valueOf(double val) {
     return new BigDecimal(Double.toString(val));
}

BigDecimal 主要用来操作（大）浮点数，BigInteger 主要用来操作大整数（超过 long 型）。

BigDecimal 的实现利用到了 BigInteger, 所不同的是 BigDecimal 加入了小数位的概念

4. 基本数据类型与包装数据类型的使用标准

Reference:《阿里巴巴Java开发手册》

【强制】所有的 POJO 类属性必须使用包装数据类型。
【强制】RPC 方法的返回值和参数必须使用包装数据类型。
【推荐】所有的局部变量使用基本数据类型。

比如我们如果自定义了一个Student类,其中有一个属性是成绩score,如果用Integer而不用int定义,一次考试,学生可能没考,值是null,也可能考了,但考了0分,值是0,这两个表达的状态明显不一样.

说明 :POJO 类属性没有初值是提醒使用者在需要使用时，必须自己显式地进行赋值，任何 NPE 问题，或者入库检查，都由使用者来保证。

数据库的查询结果可能是 null，因为自动拆箱，用基本数据类型接收有 NPE 风险。

比如显示成交总额涨跌情况，即正负 x%，x 为基本数据类型，调用的 RPC 服务，调用不成功时，返回的是默认值，页面显示为 0%，这是不合理的，应该显示成中划线。所以包装数据类型的 null 值，能够表示额外的信息，如:远程调用失败，异常退出。

5. 数组转List

Arrays.asList()这个静态方法可以将数组转换为List：

String[] myArray = { "Apple", "Banana", "Orange" };

List<String> myList = Arrays.asList(myArray);

//也可以直接传入数组元素
List<String> myList = Arrays.asList("Apple","Banana", "Orange");

看一下这个方法的源码：

public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    }

    /**
     * @serial include
     */
    private static class ArrayList<E> extends AbstractList<E>
        implements RandomAccess, java.io.Serializable
    {
        private static final long serialVersionUID = -2764017481108945198L;
        private final E[] a;

        ArrayList(E[] array) {
            a = Objects.requireNonNull(array);
        }

        @Override
        public int size() {
            return a.length;
        }

        @Override
        public Object[] toArray() {
            return a.clone();
        }

        @Override
        @SuppressWarnings("unchecked")
        public <T> T[] toArray(T[] a) {
            int size = size();
            if (a.length < size)
                return Arrays.copyOf(this.a, size,
                                     (Class<? extends T[]>) a.getClass());
            System.arraycopy(this.a, 0, a, 0, size);
            if (a.length > size)
                a[size] = null;
            return a;
        }

        @Override
        public E get(int index) {
            return a[index];
        }

        @Override
        public E set(int index, E element) {
            E oldValue = a[index];
            a[index] = element;
            return oldValue;
        }

        @Override
        public int indexOf(Object o) {
            E[] a = this.a;
            if (o == null) {
                for (int i = 0; i < a.length; i++)
                    if (a[i] == null)
                        return i;
            } else {
                for (int i = 0; i < a.length; i++)
                    if (o.equals(a[i]))
                        return i;
            }
            return -1;
        }

        @Override
        public boolean contains(Object o) {
            return indexOf(o) != -1;
        }

        @Override
        public Spliterator<E> spliterator() {
            return Spliterators.spliterator(a, Spliterator.ORDERED);
        }

        @Override
        public void forEach(Consumer<? super E> action) {
            Objects.requireNonNull(action);
            for (E e : a) {
                action.accept(e);
            }
        }

        @Override
        public void replaceAll(UnaryOperator<E> operator) {
            Objects.requireNonNull(operator);
            E[] a = this.a;
            for (int i = 0; i < a.length; i++) {
                a[i] = operator.apply(a[i]);
            }
        }

        @Override
        public void sort(Comparator<? super E> c) {
            Arrays.sort(a, c);
        }
    }

1、虽然是new ArrayList()，但方法返回值声明是List，所以此方法的结果是List，要声明为List：

List<String> myList = Arrays.asList(myArray);

不能换为ArrayList

2、它new的这个ArrayList，不是集合中ArrayList，而是Arrays的内部类ArrayList。

虽然表面上是List，但底层仍是数组：

private final E[] a;  //E是泛型

3、再看一下这个内部类的构造函数：

ArrayList(E[] array) {
   a = Objects.requireNonNull(array);
}

直接传的数组，java只有值传递（浅拷贝），传递引用类型时传的是地址，操作的其实就是实际的数组（传入的那个数组）。

内部类ArrayList中的数组只有一个元素，这个元素就是传入的数组，所以调用size()，返回值是1；get(0)返回的是传入的数组；get(1)报错，显示下标超出范围，因为下标只有0。

4、看一下这个内部类的继承关系图：

private static class ArrayList<E> extends AbstractList<E>  //这个内部类继承了AbstractList

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E>  //AbstractList又implements List

就是说内部类ArrayList implements List，这个List就是集合中的那个List接口，定义了add()、remove()、set()、get()等一些列操作List集合的方法。

我们看看上面内部类ArrayList的源码，只实现了set()、get()等方法，并没有实现add()、remove()、clear()之类的方法，

所以这个内部类的对象可以使用add()、remove()这些方法，有代码提示、也可以通过编译，因为implments List，这些方法定义都有；但一运行会报运行时异常，因为这些方法都是抽象的，内部类ArrayList没有提供实现。

5、内部类ArrayList显然很鸡肋，如何转换为集合中的ArrayList类？

方法很多，下面这种是最简单的：

ArrayList list = new ArrayList<>( Arrays.asList("a", "b", "c") )  //使用集合中ArrayList类的构造函数，传入内部类ArrayList对象即可

怎么知道ArrayList是内部类还是集合中的那个？我们看一下内部类的声明：

private static class ArrayList<E>

private，内部类ArrayList只能在Arrays中使用，所以上面的ArrayList是集合中的那个。

也正是因为private，List<String> myList = Arrays.asList(myArray); 这个方法的返回值要声明为List，不能声明为内部类ArrayList（Arrays类外不能使用此内部类）。

数组转List集合的完整方式：

String[] myArray = { "Apple", "Banana", "Orange" };  //数组

List<String> myList = Arrays.asList(myArray);  //内部类ArraysList，中间人，桥梁

//以上2句代码也可以写为  List<String> myList = Arrays.asList( "Apple", "Banana", "Orange" );

ArrayList list = new ArrayList<>( mylist );  //集合中的ArrayList

数组反转：

        String[] arr= {"gailun", "huangzi", "zhaoxin"};
        List<String> list = Arrays.asList(arr); //将数组转换为内部类ArrayList
        Collections.reverse(list); //调用Collections工具类的静态方法实现数组反转，数组已被修改

        System.out.println(list); //[zhaoxin, huangzi, gailun]

        for (String s1:arr)
            System.out.println(s1);
        
        // zhaoxin
        // huangzi
        // gailun

上面已经说过，创建内部类ArrayList对象时，传的是数组地址，操作的就是数组本身，对ArrayList的反转就是对数组的反转。

不管是使用增强for循环、还是使用while+iterator遍历集合|数组，都不能在循环中增、删集合|数组元素，因为：

1、操作的是临时变量，并不是原本的数组元素，只能进行读操作

2、增、删元素后，迭代次数发生改变，与原本的迭代次数不一致，会导致迭代出错

6、枚举的使用

在java5中引入了枚举，枚举是一种特殊的类，与其它类不同，枚举使用关键字enum，不使用关键字class。

枚举常用来代替一组常量，比如4个季节：

public enum Season {
        SPRING,  //逗号，一般全大写
        SUMMER, 
        AUTUMN,
        WINTER;  //分号
}

把enum当做class即可。enum其实就是一种特殊的class，使用enum修饰会自动继承java.lang.Enum类。

用户的状态（在线、离线、忙碌、Q我吧）、

用户的身份（普通用户、VIP、SVIP）、

订单状态（已付款、已发货、待取件、待收货、待退款）、

商品库存状态（库存充足、即将售罄、缺货）、

后台管理的角色（普通管理员、最高级别管理员）、

登录角色（教职工、学生、游客）.......

等等，需要用一组常量来表示的，都可以使用枚举。

枚举可以单独存在（就像类一样，单独写成一个文件），也可以内嵌在某个类中（相当于内部类）：

public class Test {
    private Season season; //声明为枚举类型
    // season=Season.SPRING;  //赋值

    public enum Season { //相当于内部类的形式
        SPRING,
        SUMMER,
        AUTUMN,
        WINTER;
    }

    public void getSeason1(Season season){
        //实用==与枚举值进行比较
        if (season==Season.SPRING)
            System.out.println("now is spring");
    }

    public void getSeason2(Season season){
        //在switch中使用枚举
        switch (season){
            case SPRING:
                System.out.println("now is spring");
                break;
            case SUMMER:
                System.out.println("now is summer");
                break;
            case AUTUMN:
                System.out.println("now is autumn");
                break;
            case WINTER:
                System.out.println("now is winter");
                break;
        }

    }

}