Java工程师们最常犯的11个谬误

2019-10-07 20:12 来源:未知

Java程序员们最常犯的拾贰个错误(转),java程序猿

转自CSDN:

转自CSDN:

1.将数组转化为列表

将数组转化为三个列表时,程序猿们有时这么做:

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

Arrays.asList()会回去贰个ArrayList对象,ArrayList类是Arrays的一个个体静态类,实际不是java.util.ArrayList类,java.util.Arrays.ArrayList类有set()、get()、contains()方法,然则从未增比索素的法子,所以它的深浅是一定的,想要成立一个确实的ArrayList类,你应当如此做:

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

ArrayList的构造方法能够承受三个集中类型,刚好它也是java.util.Arrays.ArrayList的超类。

1.将数组转化为列表

将数组转化为一个列表时,程序猿们不经常那样做:

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

Arrays.asList()会回去三个ArrayList对象,ArrayList类是Arrays的二个个体静态类,实际不是java.util.ArrayList类,java.util.Arrays.ArrayList类有set()、get()、contains()方法,但是从未增美元素的不二等秘书技,所以它的轻重缓急是定点的,想要成立一个着实的ArrayList类,你应该那样做:

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

ArrayList的构造方法能够承受贰个汇集类型,刚好它也是java.util.Arrays.ArrayList的超类。

2.论断贰个数组是不是含有贰个值

程序猿们平日如此做:

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

这段代码起效果,不过从未须要把八个数组转化成列表,转化为列表需求特别的时光。它能够像下边那样轻便:

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

或者是:

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

第一种艺术比第二种更便于读

2.料定三个数组是不是带有一个值

技术员们平日这么做:

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

这段代码起效果,不过没有须要把一个数组转化成列表,转化为列表需求十分的年月。它能够像上面那样轻便:

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

或者是:

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]

在这么些艺术中有三个严重的错误。当三个因素被删去时,列表的分寸减少何况下标变化,所以当您想要在贰个巡回中用下标删除几个因素的时候,它并不会健康的见效。

您大概知道在循环中准确的去除八个要素的点子是选取迭代,而且你驾驭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()的源代码。

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]

在那些措施中有三个严重的荒唐。当三个因素被去除时,列表的大大小小降低何况下标变化,所以当您想要在叁个巡回中用下标删除八个成分的时候,它并不会健康的见效。

您或者知道在循环中准确的删除八个因素的艺术是选取迭代,何况你明白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与HashMap的对比

固然法来讲,哈希表是数据结构的一个名字。不过在java中,这一个数据结构的名字是HashMap。Hashtable与HashMap的二个重视不相同点是Hashtable是一起的。所以您时常无需Hashtable,相反HashMap日常会用到。

4.Hashtable与HashMap的对比

固然法来说,哈希表是数据结构的三个名字。可是在java中,那几个数据结构的名字是HashMap。Hashtable与HashMap的贰个主要不一致点是Hashtable是手拉手的。所以你经常不须求Hashtable,相反HashMap平时会用到。

5.在汇集中利用原始类型

在Java中华始类型与无界通配符类型很轻松混合在联合,拿Set来讲,Set是二个原始类型,而Set<?>是无界的通配符类型。 思虑上面采取原始类型List作为参数的代码:

public static void add(List list,Object o){
    list.add(o);
}
pulbic 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 ...

使用原生类型集合是危急的,那是因为原生类型集结跳过了泛型类型检查,并且不是安全的,在SetSet<?>和Set<Object>中有一点都不小的两样。

5.在联谊中选用原始类型

在Java中华始类型与无界通配符类型很轻便混合在联合,拿Set来讲,Set是贰个原始类型,而Set<?>是无界的通配符类型。 思索上面选用原始类型List作为参数的代码:

public static void add(List list,Object o){
    list.add(o);
}
pulbic 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 ...

运用原生类型集结是一发千钧的,那是因为原生类型集合跳过了泛型类型检查,并且不是安全的,在SetSet<?>和Set<Object>中有非常的大的两样。

6.探问品级

程序猿们一时选用public作为类字段的修饰符,能够很轻巧的通过引用获得值,但这是三个坏的设计,依照经验,分配给成员变量的访谈品级相应尽也许的低。

6.做客等级

技师们有的时候应用public作为类字段的修饰符,能够很简短的通过援引获得值,但那是一个坏的安顿,根据经验,分配给成员变量的访谈等第相应尽只怕的低。

7.ArrayList与LinkedList的对比

当程序猿们不亮堂ArrayList与LinkedList的分别时,他们临时选择ArrayList,因为它看起来相比熟谙。但是,它们此前有远大的属性差异。一句话来讲,假诺有大气的加码删除操作并且未有过多的随便寻访成分的操作,应该率先LinkedList。

7.ArrayList与LinkedList的对比

当程序员们不知情ArrayList与LinkedList的分化时,他们平常利用ArrayList,因为它看起来相比熟知。可是,它们此前有光辉的性质差距。简单来说,若是有大量的增添删除操作并且未有过多的随意访谈成分的操作,应该率先LinkedList。

8.可变与不可变

不可变对象有不菲的独到之处,举例轻易,安全等等。不过对于每多个例外的值都急需四个独门的目的,太多的靶子恐怕会变成大气的废物回收。当选取可变与不可变时应该有三个平衡。 平日的,可变对象用来幸免发出多量的中游对象。多个典型的事例是接连多量的字符串。假设你用八个不可变的字符串,你会发生众多要求进行垃圾回收的对象。那很浪费CPU的时刻,使用可变对象是没有错的缓慢解决方案(比方StringBuilder)。

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

奇迹在某个情状下也是亟需可变对象的,举个例子将可变对象作为参数字传送入方法,你不要采纳过多语句便能够获得七个结实。别的二个例子是排序和过滤:当然,你能够写一个主意来接受原始的汇聚,况兼再次来到二个排好序的聚集,可是这样对于大的聚焦就太浪费了。

8.可变与不可变

不可变对象有相当多的亮点,比如轻松,安全等等。可是对于每三个两样的值都急需一个独自的目的,太多的靶子或者会产生大气的废物回收。当选择可变与不可变时应该有三个平衡。 平日的,可变对象用来防止发出多量的中游对象。二个压倒一切的事例是接连多量的字符串。如果你用七个不可变的字符串,你会发出比很多内需张开垃圾回收的对象。那很浪费CPU的光阴,使用可变对象是道理当然是那样的的减轻方案(例如StringBuilder)。

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

神跡在某个情况下也是亟需可变对象的,比方将可变对象作为参数字传送入方法,你不要选取过多语句便能够收获三个结果。其余一个例子是排序和过滤:当然,你能够写多少个主意来收纳原始的联谊,并且重回多个排好序的聚众,但是那样对于大的聚众就太浪费了。

9.父类与子类的构造函数

图片 1

其一编译期错误的出现是父类默许的构造方法未定义,在java中,假设一个类未有概念构造方法,编译器会暗中同意的为这些类加多三个无参的构造方法。借使在父类中定义了构造方法,在这一个例子中是Super(String s),编写翻译器就不会增添暗许的无参构造方法,那正是地点这一个父类的情景。 子类的构造器,不管是无参还会有有参,都会调用父类的无参构造器。因为编写翻译器试图在子类的三个构造方法中增添super()方法。可是父类默许的构造方法未定义,编写翻译器就能够报出那几个错误音信。 想要修复这些难点,能够总结的经过1)在父类中增添一个Super()构造方法,像下边那样:

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

要么2)移除父类自定义的构造方法,恐怕3)在子类的构造方法中调用父类的super(value)方法。

9.父类与子类的构造函数

图片 2

以此编写翻译期错误的出现是父类暗中认可的构造方法未定义,在java中,如若叁个类未有定义构造方法,编写翻译器会默许的为那几个类增加三个无参的构造方法。倘诺在父类中定义了构造方法,在那么些例子中是Super(String s),编写翻译器就不会增加暗许的无参构造方法,那正是上边那一个父类的场馆。 子类的构造器,不管是无参还应该有有参,都会调用父类的无参构造器。因为编写翻译器试图在子类的多个构造方法中增加super()方法。不过父类默许的构造方法未定义,编写翻译器就能够报出这么些错误音信。 想要修复这么些难点,能够省略的通过1)在父类中增添二个Super()构造方法,像下边那样:

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

抑或2)移除父类自定义的构造方法,也许3)在子类的构造方法中调用父类的super(value)方法。

10.”"依然构造器

有两种格局能够创制字符串

//1.使用字符串
String x = "abc";
//2.使用构造器
String y = new String("abc");

有啥差距?

上面包车型大巴例证会提交二个快速的答案:

String a = "abc";
String b = "abc";
System.out.println(a==b);//true
System.out.println(a.equals(b));//true

String c = new String("abc");
String d = new String("abc");
System.out.println(c==d);//false
System.out.println(c.equals(d));//true

 

原文:

转自CSDN: 1.将数组转化为列表 将数组转化为五个列表时,技术员们陆续这么做: List String l...

10.”"照旧构造器

有三种办法能够创设字符串

//1.使用字符串
String x = "abc";
//2.使用构造器
String y = new String("abc");

有如何界别?

上边包车型大巴例子会交到一个便捷的答案:

String a = "abc";
String b = "abc";
System.out.println(a==b);//true
System.out.println(a.equals(b));//true

String c = new String("abc");
String d = new String("abc");
System.out.println(c==d);//false
System.out.println(c.equals(d));//true

 

原文:

TAG标签:
版权声明:本文由990888藏宝阁发布于关于计算机,转载请注明出处:Java工程师们最常犯的11个谬误