Top 10 Mistakes Java Developers Make--reference

This list summarizes the top 10 mistakes that Java developers frequently
make.

#1. Convert Array to ArrayList

To convert an array to an ArrayList, developers often do
this:




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

Arrays.asList() will return
an ArrayList which is a private static class
inside Arrays, it is not
the java.util.ArrayList class.
The java.util.Arrays.ArrayList class
has set(),get()contains() methods,
but does not have any methods for adding elements, so its size is fixed. To
create a real ArrayList, you should do:




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

The constructor of ArrayList can accept a Collection
type, which is also a super type forjava.util.Arrays.ArrayList.

#2. Check If an Array Contains a Value

Developers often do:




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

The code works, but there is no need to convert a list to set first.
Converting a list to a set requires extra time. It can as simple as:




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

or




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

The first one is more readable than the second one.

#3. Remove an Element from a List Inside a Loop

Consider the following code which removes elements during iteration:




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);

The output is:

[b, d]

There is a serious problem in this method. When an element is removed, the
size of the list shrinks and the index changes. So if you want to delete
multiple elements inside a loop by using the index, that will not work
properly.

You may know that using iterator is the right way to delete elements inside
loops, and you know foreach loop in Java works like an iterator, but actually it
is not. Consider the following code:




ArrayList<String> list = new ArrayList<String>(Arrays.asList("a", "b", "c", "d"));
 
for (String s : list) {
if (s.equals("a"))
list.remove(s);
}

It will throw out ConcurrentModificationException.

Instead the following is OK:




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() must be called before .remove().
In the foreach loop, compiler will make the .next()called
after the operation of removing element, which caused
theConcurrentModificationException. You may want to take a look at
the source code ofArrayList.iterator().

#4. Hashtable vs HashMap

By conventions in algorithm, Hashtable is the name of the data structure. But
in Java, the data structure‘s name is HashMap. One of the key
differences
between Hashtable and HashMap is
thatHashtable is synchronized. So very often you don‘t
need Hashtable, instead HashMap should
be used.

HashMap
vs. TreeMap vs. Hashtable vs. LinkedHashMap

Top
10 questions about Map

#5. Use Raw Type of Collection

In Java, raw type and unbounded wildcard
type
 are easy to mixed together. Take Set for
example, Setis raw type,
while Set<?> is unbounded wildcard type.

Consider the following code which uses a raw
type List as a parameter:




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

This code will throw an exception:

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

Using raw type collection is dangerous as the raw type collections skip the
generic type checking and not safe. There are huge differences
between SetSet<?>,
and Set<Object>. Check out
Raw
type vs. Unbounded wildcard
 and Type
Erasure
.

#6. Access Level

Very often developers use public for class field. It is easy to get the field
value by directly referencing, but this is a very bad design. The rule of thumb
is giving access level for members as low as possible.

public,
default, protected, and private

#7. ArrayList vs. LinkedList

When developers do not know the difference
between ArrayList and LinkedList, they
often useArrayList, because it looks familiar. However, there is a
huge performance difference between them. In
brief, LinkedList should be preferred if there are a
large number of add/remove operations and there are not a lot of random access
operations. Check out ArrayList vs. LinkedList to
get more information about their performance if this is new to you.

#8. Mutable vs. Immutable

Immutable objects have many advantages such simplicity, safety, etc. But it
requires a separate object for each distinct value, and too many objects might
cause high cost of garbage collection. There should be a balance when choosing
between mutable and immutable.

In general, mutable objects are used to avoid producing too many intermediate
objects. One classic example is concatenating a large number of strings. If you
use an immutable string, you would produce a lot of objects that are eligible
for garbage collection immediately. This wastes time and energy on the CPU,
using a mutable object the right solution
(e.g. StringBuilder).




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

There are other situations when mutable objects are desirable. For example
passing mutable objects into methods lets you collect multiple results without
jumping through too many syntactic hoops. Another example is sorting and
filtering: of course, you could make a method that takes the original
collection, and returns a sorted one, but that would become extremely wasteful
for larger collections. (From dasblinkenlight‘s
answer
 on Stack Overflow)

Why
String is Immutable?

#9. Constructor of Super and Sub

This compilation error occurs because the default super constructor is
undefined. In Java, if a class does not define a constructor, compiler will
insert a default no-argument constructor for the class by default. If a
constructor is defined in Super class, in this case Super(String s), compiler
will not insert the default no-argument constructor. This is the situation for
the Super class above.

The constructors of the Sub class, either with-argument or no-argument, will
call the no-argument Super constructor. Since compiler tries to insert super()
to the 2 constructors in the Sub class, but the Super‘s default constructor is
not defined, compiler reports the error message.

To fix this problem, simply 1) add a Super() constructor to the Super class
like




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

, or 2) remove the self-defined Super constructor, or 3)
add super(value) to sub constructors.

Constructor
of Super and Sub

#10. "" or Constructor?

String can be created by two ways:




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

What is the difference?

The following examples can provide a quick answer:




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

For more details about how they are allocated in memory, check out Create
Java String Using ” ” or Constructor?
.

Future Work

The list is based on my analysis of a large number of open source projects on
GitHub, Stack Overflow questions, and popular Google queries. There is no
evaluation to prove that they are precisely the top 10, but definitely they are
very common. Please leave your comment, if you don’t agree with any part. I
would really appreciate it if you could point out some other mistakes that are
more common.

reference
from:http://www.programcreek.com/2014/05/top-10-mistakes-java-developers-make/

Top 10 Mistakes Java Developers Make--reference,布布扣,bubuko.com

时间: 2024-10-05 05:00:20

Top 10 Mistakes Java Developers Make--reference的相关文章

Top 10 Mistakes Java Developers Make(转)

文章列出了Java开发者最常犯的是个错误. 1.将数组转换为ArrayList 为了将数组转换为ArrayList,开发者经常会这样做: ? 1 List<String> list = Arrays.asList(arr); Arrays.asList()会返回一个ArrayList,但这个ArrayList是Arrays的私有静态类,不是java.util.ArrayList.java.util.Arrays.ArrayList有set(), get(), contains()方法,但没有任

Yet Another 10 Common Mistakes Java Developers Make When Writing SQL (You Won’t BELIEVE the Last One)--reference

(Sorry for that click-bait heading. Couldn't resist ;-) ) We're on a mission. To teach you SQL. But mostly, we want to teach you how to appreciate SQL. You'll love it! Getting SQL right or wrong shouldn't be about that You're-Doing-It-Wrong? attitude

【转】【翻译】The Top 10 Mistakes That KnockoutJS Developers Make

Introduction Knockout is a popular JavaScript framework that offers convenient data binding functionality without the complexity of similar frameworks such as Angular. It's a great choice for prototyping small applications or introducing data binding

100 high quality blogs from java developers

This list collects 100 high quality blogs from Java developers from all over the world. Some of these blogs may not be written by Java developers, but at least Java developers should find it useful or interesting. Reading those blogs should be fun an

2016 年排名 Top 100 的 Java 类库

我们分析了GitHub中47,251个依赖,从中找出了排名前一百的Java类库,让我们看看谁在前面,谁在后面. 我们在漫长的周末的消遣方式就是浏览GitHub并且搜索流行的Java类库.我们决定把其中的乐趣与结果分享给你. 我们分析了GitHub中排名前3,862个项目中的47,251个导入语句,其中有12,059个Java类库被依赖.我们从这个列表中提取出前一百并把结果分享给你. 最受欢迎的前20个Java类库 和上次分析结果一致,junit依旧是GitHub中最受欢迎的类库.Java中的日志

Top 10 questions about Java Collections--reference

reference from:http://www.programcreek.com/2013/09/top-10-questions-for-java-collections/ The following are the most popular questions of Java collections asked and discussed on Stackoverflow. Before you look at those questions, it's a good idea to s

Top 10 Questions about Java Exceptions--reference

reference from:http://www.programcreek.com/2013/10/top-10-questions-about-java-exceptions/ This article summarizes the top 10 frequently asked questions about Java exceptions. 1. Checked vs. Unchecked In brief, checked exceptions must be explicitly c

Top 10 Methods for Java Arrays

作者:X Wang 出处:http://www.programcreek.com/2013/09/top-10-methods-for-java-arrays/ 转载文章,转载请注明作者和出处 The following are top 10 methods for Java Array. They are the most voted questions from stackoverflow. 0. Declare an array String[] aArray = new String[5

Watch out for these 10 common pitfalls of experienced Java developers &amp; architects--转

原文地址:http://zeroturnaround.com/rebellabs/watch-out-for-these-10-common-pitfalls-of-experienced-java-developers-architects/ Can we start by asking a serious question? How easy is it to find advice for novice Java programmers on the web? Whenever I loo