您的位置：首页 > 编程语言 > Java开发

Java开发人员爱犯的10个错

2018-01-26 16:35 399 查看
翻译自：Top 10 Mistakes Java Developers Make

因为自己在开发过程中也有犯过其中的一些错误，觉得写的很好，所以翻译在此。

1.将数组转换为ArrayList

为了将一个数组对象转换为ArrayList对象，程序员经常是这样实现：

List<String> list = Arrays.asList(arr);


Arrays.asList()
方法返回一个ArrayList，但这个ArrayList是Arrays类中的一个私有静态类，它不是
java.util.ArrayList
类。
java.util.Arrays.ArrayList
类有set()，get()，contains()方法，但没有任何添加元素的方法，所以它的大小是固定的，源码：

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) {
}

@Override
public E get(int index) {
...
}

@Override
public E set(int index, E element) {
...
}

@Override
public int indexOf(Object o) {
...
}

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

@Override
public Spliterator<E> spliterator() {
...
}

@Override
public void forEach(Consumer<? super E> action) {
...
}

@Override
public void replaceAll(UnaryOperator<E> operator) {
...
}

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


可以看到这个ArrayList继承自AbstractList，自然也就实现了List接口，但是并没有重写add方法，所以不能往里面添加元素。
private final E[] a;
表明了数组不可变，也就是说ArrayList不可变。如果想要使用java.util.ArrayList实现可变的List，应该这样做：

ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(arr));


因为ArrayList的构造方法中可以接收一个Collection参数，Collection是java.util.Arrays.ArrayList的超类。

2.判断数组是否包含指定值

程序员经常是这样做的：

Set<String> set = new HashSet<String>(Arrays.asList(arr));
return set.contains(targetValue);


这样确实是可以实现，但是没有必要把List转换为Set，这需要消耗额外的资源，可以简化为：

Arrays.asList(arr).contains(targetValue);


（List和Set都提供了contains方法）

或者

for(String s: arr){
if(s.equals(targetValue))
return true;
}
return false;


3.从循环的列表中删除一个元素

考虑下面的代码在迭代期间删除元素：

ArrayList<String> list = new ArrayList<String>(Arrays.asList("a", "b", "c", "d"));
for (int i = 0; i < list.size(); i++) {
list.remove(i);
}
System.out.println(list);


输出的结果会是：

[b, d]


这就有一个问题，在删除一个元素之后，List的长度会减小，自然元素的序号也会改变，所以如果想通过索引去删除循环内的多个元素，是不可行的。也许你知道使用迭代器是删除循环内部元素的正确方法，而且你知道Java中的foreach循环就像一个迭代器，但事实上并不是这样，看下面的代码：

ArrayList<String> list = new ArrayList<String>(Arrays.asList("a", "b", "c", "d"));

for (String s : list) {
if (s.equals("a"))
list.remove(s);
}


它会抛异常：ConcurrentModificationException。如果是这样写是没有问题的：

ArrayList<String> list = new ArrayList<String>(Arrays.asList("a", "b", "c", "d"));
Iterator<String> iter = list.iterator();
while (iter.hasNext()) {
String s = iter.next();

if (s.equals("a")) {
iter.remove();
}
}


.next()
必须要在
.remove()
之前调用，在foreach循环中，编译器会在删除元素的操作之后调用.next()，就会导致ConcurrentModificationException异常发生，到这里你可能想去看看 ArrayList.iterator()的源码了。

4.Hashtable vs HashMap

按照算法中的约定，Hashtable是数据结构的名称。 但是在Java中，数据结构的名字是HashMap。 Hashtable和HashMap之间的一个主要区别是Hashtable是同步的。 所以很多时候你不需要Hashtable，而应该使用HashMap。在这里不一一列举，因为比较多，可以去看下面的内容

实用链接：https://www.programcreek.com/2013/09/top-9-questions-for-java-map/，

Map几个实现类的比较：https://www.programcreek.com/2013/03/hashmap-vs-treemap-vs-hashtable-vs-linkedhashmap/

对应国内翻译版本：http://www.importnew.com/8658.html

5.使用原始类型的集合

在Java中，原始类型和无界通配符类型很容易混合在一起。 以Set为例，Set是原始类型，而Set <？>是无界通配符类型。考虑使用原始类型List作为参数的以下代码：

public static void add(List list, Object o){
list.add(o);
}
public static void main(String[] args){
List<String> list = new ArrayList<String>();
add(list, 10);
String s = list.get(0);
}


这段代码执行会抛异常：

Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String   at ...


使用原始类型集合是危险的，因为原始类型集合跳过了通用类型检查而不安全。 Set，Set <？>和Set 有很大的不同，可以参考：

Raw type vs. Unbounded wildcard, Type Erasure。

6.访问权限

很多开发人员通常都用public修饰类的属性，通过直接引用很容易获得字段值，但这是一个非常糟糕的设计， 经验法则是给成员的访问级别尽可能低。参考：

public, default, protected, and private

7.ArrayList vs. LinkedList

当开发人员不知道ArrayList和LinkedList之间的区别时，他们经常使用ArrayList，因为它看起来很熟悉。 但是，它们之间有着巨大的性能差异。 简单的说，如果有大量的添加/删除操作，并且没有大量的随机访问操作，则应该首选LinkedList。参考：

ArrayList
vs. 
LinkedList


8.可变与不可变

不可变对象具有简单性，安全性等诸多优点，但是对于每一个不同的值都需要一个独立的对象，过多的对象可能会导致垃圾回收成本高。 在可变和不可变之间进行选择时应该有一个平衡。通常来说，可变对象用于避免产生太多的中间对象。 一个典型的例子是连接大量的字符串， 如果你使用一个不可变的字符串，你会产生很多符合垃圾收集条件的对象，这浪费了时间和精力在CPU上，使用可变对象的正确解决方案（例如StringBuilder）。

String result="";
for(String s: arr){
result = result + s;
}


还有其他的情况下，可变的对象是可取的。 例如，将可变对象传递给方法可让您收集多个结果，而不会跳过太多的语法环。 另一个例子是排序和过滤：当然，你可以创建一个方法来获取原始的集合，并返回一个已排序的集合，但是对于大集合来说，这将变得非常浪费。 （来自dasblinkenlight关于Stack Overflow的回答）

参考：Why String is Immutable?

9. 子类和父类的构造器

public class Super {
String s;

public Super(String s) {
this.s = s;
}

}

public class Sub extends Super {
int x = 200;

public Sub(String s) {   // 编译错误
}

public Sub() {           // 编译错误
System.out.println("sub");
}

public static void main(String[] args) {
Sub s = new Sub();
}
}


出现此编译错误是因为默认的超类构造函数未定义。 在Java中，如果一个类没有定义一个构造函数，那么编译器默认会为这个类插入一个默认的无参构造函数。 如果在超类中定义了一个构造函数，在这种情况下，说super（String s），编译器将不插入默认的无参数构造函数。 以上是超类的情况。

Sub类的构造函数，无论是参数还是无参数，都会调用无参数的Super构造函数，由于编译器试图向Sub类中的2个构造函数中插入super（），但Super的默认构造函数未定义，所以编译会报错。

要解决这些错误有三个方法：

(1).在Super中添加一个默认的构造方法：

public Super(){
System.out.println("Super");
}


(2).删除Super中自定义的构造方法

(3).添加一个super(value)。

public Sub(String s) {   // 编译错误
super(s);
}


10.”” or Constructor?

一个String对象可以通过两种方式创建：

//1. use double quotes
String x = "abc";
//2. use constructor
String y = new String("abc");


有什么不一样呢？下面的例子会给出答案：

String a = "abcd";
String b = "abcd";
System.out.println(a == b);  // True
System.out.println(a.equals(b)); // True

String c = new String("abcd");
String d = new String("abcd");
System.out.println(c == d);  // False
System.out.println(c.equals(d)); // True


有关如何在内存中分配的更多细节，参考Create Java String Using ” ” or Constructor?.
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息
标签： 
相关文章推荐
新的分享
章节导航