Java中常见的坑整理

（一）关于Integer

 public static void main(String[] args) {
        Integer a = 1;
        Integer b = 1;
        Integer c = 2000;
        Integer d = 2000;
        System.out.println(a==b);
        System.out.println(c==d);
    }

输出结果为：true　false
原因是自动装箱时调用了Integer.valueOf()这个方法，当值在-128到127之间时从缓存里面拿出来的，超出后会new一个对象

比较Integer要用a.intValue()==b.intValue() 或者调用equals方法；

（二）关于Arrays.asList

public static void main(String[] args) {
		String[] strings = {"zhao","qian","sun"};
		List list = Arrays.asList(strings);
		list.add("li");
	}

程序运行时会抛出java.lang.UnsupportedOperationException异常；
是因为该方法返回的是java.util.Arrays.ArrayList;不是java.util.ArrayList；
该类是不能改变大小的，调用它的的add remove方法都会抛出上面的异常

（三）关于数组转换的

 public static void main(String[] args) {
        Object[] objects1 = {"1", "2", "3"};
        Object[] objects2 = new String[] {"4", "5", "6"};
        String[] strings1 = (String[])objects1;
        String[] strings2 = (String[])objects2;
    }

上面代码执行到strings1时会报类型转换错误，执行strings2时可以转换；
对于数组来讲，父类型数组可以指向子类型数组；
Object[] objects1 = {“1”, “2”, “3”}; 这种写法其实是生成一个Object类型的数组里面放的是字符串；
Object[] objects2 = new String[] {“4”, “5”, “6”};这种写法其实是指向了一个String类型的数组

（四）方法名一样，参数类型不一样 传入null的问题

public class Test {
    public  void doSomething(String param) {
        System.out.println("Param type is String");
    }

    public  void doSomething(Object param) {
        System.out.println("Param type is Object");
    }

    public static void main(String[] args) {
        Test test = new Test();
        test.doSomething(null);
    }
}

此时如果参数存在继承关系的话，走的是类型参数是子类的方法。上面程序运行结果：
Param type is String；
但是如果参数类型不存在继承关系的话，编译是通不过的，会报错，程序不知道要调哪一个方法。

（五）关于ArrayList.toArray()方法

 public static void main(String[] args) {
        List list = new ArrayList(1);
        list.add("abc");
        String[] array1 = (String[])list.toArray();//会报类型转换异常
        String[] array2 = list.toArray(new String[0]);//可以正常运行
    }

上面报错根本原因还是父类型数组引用可以指向子类型数组。
底下正常运行的是转成数组的方法；

（六）关于继承强转的问题

Java 子类强转父类
父类引用指向子类对象:
java中子类强转父类,实际上依然是子类，该引用只能调用父类中定义的方法和变量；
如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；
Java 父类强转子类
只有父类对象本身就是用子类new出来的时候, 才可以在将来被强制转换为子类对象.

（七）HashSet的问题

public class Person {
    public int age;
    public String name;

    //注意此处重写了hashCode方法
    @Override
    public int hashCode() {
        return Objects.hash(age, name);
    }

    @Override public String toString() {
        return "Person{" + "age=" + age + ", name='" + name + '\'' + '}';
    }

    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }
}
public class Test {
    public static void main(String[] args) {
        Person person1 = new Person(25, "xiaoming");
        Person person2 = new Person(32, "xiaohong");
        HashSet hashSet = new HashSet<>();
        hashSet.add(person1);
        hashSet.add(person2);
        person1.age = 18;
        hashSet.remove(person1);
        Iterator  iterator=  hashSet.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

控制台打印结果：
Person{age=18, name=‘xiaoming’}
Person{age=32, name=‘xiaohong’}
可发现 xiaoming 并没有被删除掉 是因为age改成18以后 hashcode值改变了。

（八）ArrayList遍历删除的问题

第一种方式是最普通的循环写法：

public static void main(String[] args) {
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        for (int i = 0; i < list.size(); i++) {
            if ("b".equals(list.get(i))) {
                list.remove(list.get(i));
            }
        }
    }

实际程序运行发现字符串b还存在一个。

private void fastRemove(int index) {
        modCount++;
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work
    }

查看源码，最终可以看到会执行System.arraycopy方法，导致删除元素时涉及到数组元素的移动。针对上面的写法，在遍历第一个字符串b时因为符合删除条件，所以将该元素从数组中删除，并且将后一个元素移动（也就是第二个字符串b）至当前位置，导致下一次循环遍历时后一个字符串b并没有遍历到，所以无法删除。针对这种情况可以倒序删除的方式来避免，数组倒序遍历时即使发生元素删除也不影响后序元素遍历。
倒序删除的写法：

public static void main(String[] args) {
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        for(int i=list.size()-1;i>=0;i--){
            if("b".equals(list.get(i))){
                list.remove(list.get(i));
            }
        }
    }

第二种方式是for-each写法

public static void main(String[] args) {
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        for (String item:list) {
            if ("b".equals(item)) {
                list.remove(item);
            }
        }
    }

上面的程序抛出了java.util.ConcurrentModificationException异常。
错误产生的原因却是foreach写法是对实际的Iterable、hasNext、next方法的简写，问题同样处在上文的fastRemove方法中，可以看到第一行把modCount变量的值加一，但在ArrayList返回的迭代器（该代码在其父类AbstractList中）
next方法最终会调

final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
}

这里会做迭代器内部修改次数检查，因为上面的remove(Object)方法修改了modCount的值，所以才会报出并发修改异常。要避免这种情况的出现则在使用迭代器迭代时（显示或for-each的隐式）不要使用ArrayList的remove，改为用Iterator的remove即可。
迭代器删除的写法：

   public static void main(String[] args) {
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            if ("b".equals(iterator.next())) {
                iterator.remove();
            }
        }
    }

------------------------后续想起啥再补吧 先记到这里------------------------