java程序员常犯的10个错误

package com.zrc.test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;


import org.junit.Test;


public class Demo1 {

/**
* 1.数组转ArrayList
*/
@Test
public void test1(){
int[] arr = new int[3];
String[] arr2 = new String[]{"a","b"};
arr[0] = 44;
arr[1] = 45;
arr[2] = 46;
for(int i = 0;i < arr.length;i++){
System.out.println(arr[i]);
}
for (int i = 0; i < arr2.length; i++) {
System.out.println(arr2[i]);
}
/**
* Arrays.asList确实会返回一个 ArrayList对象，但是该类是 Arrays类 中一个私有静态内部类，
* 而不是常见的 java.util.ArrayList类。
* 这个 java.util.Arrays.ArrayList 类具有 set()，get()，contains()等方法，
* 但是不具有任何添加或移除元素的任何方法。因为该类的大小(size)是固定的
*/
List<String> list = Arrays.asList(arr2);
for(String str : list){
System.out.println(str);
}
/**
* 为了创建出一个真正的 java.util.ArrayList,代码应该如下所示：
*/
ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(arr2));
arrayList.add("ddd");
for(String str : arrayList){
System.out.println(str);
}
/**
* 我们知道，ArrayList的构造方法可以接受一个 Collection 类型的对象，
* 而我们的 java.util.Arrays.ArrayList 正好也是它的一个子类。
* 实际上，更加高效的代码示例是：
*/
ArrayList<String> arrayList2 = new ArrayList<String>(arr2.length);
Collections.addAll(arrayList2, arr2);
arrayList2.add("deeee");
for(String str : arrayList2){
System.out.println(str);
}
}
/**
* 2. 数组是否包含特定值
*/
@Test
public void test2(){
String[] arr = new String[]{"aa","bb"};
//为了检查数组中是否包含某个特定值，很多Java程序员会使用如下的代码：
Set<String> set = new HashSet<>(Arrays.asList(arr));
if(set.contains("aa")){
System.out.println("包含");
}else{
System.out.println("不包含");
}
/**
* 就功能而言，该代码是正确无误的，但在数组转List,List再转Set的过程中消耗了大量的性能。
* 我们可以优化成如下形式：
*/
boolean c = Arrays.asList(arr).contains("aa");
System.out.println(c);
//或者，进一步优化成如下所示最高效的代码：
for(String s : arr){
if(s.contains("aad")){
System.out.println("t");//return  true;
}
}
//return  false;
}
/**
* 3. 在迭代时移除List中的元素
*/
@Test
public void test3(){
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的大小(size)就会缩减，
* 同时也改变了索引的指向。所以，在迭代的过程中使用索引，
* 将无法从List中正确地删除多个指定的元素。
*/
}
/**
* 4. Hashtable vs HashMap
* 学习过数据结构的读者都知道一种非常重要的数据结构叫做 哈希表。
* 在Java中，对应哈希表的的类是 HashMap 而不是 Hashtable。
* HashMap与Hashtable之间的最核心区别就是：HashMap是非同步的，Hashtable是同步的。
*/

/**
* 5. 在Collection中使用原始类型
* 在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 string = list.get(0);
}
/**
* 这个示例代码会抛出来一个异常：
* Exception in thread "main" java.lang.ClassCastException: 
* java.lang.Integer cannot be cast to java.lang.String at com.zrc.test.Demo1.main(Demo1.java:122)
* 在Collection使用原始类型是具有很多的类型错误风险的，因为原始类型没有静态类型检查。
* 实际上，Set、Set<?>和Set之间具有非常大的差异，
*/

/**
* 6. 访问权限
* 很多的Java初学者喜欢使用 public 来修饰类的成员。这样可以很方便地直接访问和存取该成员。
* 但是，这是一种非常糟糕的编程风格，正确的设计风格应该是尽可能降低类成员的访问权限。
* 具体细节，建议参看本站的这篇文章。
* 
* 
* 7. ArrayList vs LinkedList
* 很多的Java初学者不明白ArrayList与LinkedList之间的区别，
* 所以，他们完全只用相对简单的ArrayList，甚至不知道JDK中还存在LinkedList。
* 但是，在某些具体场景下，这两种List的选择会导致程序性能的巨大差异。
* 简单而言：当应用场景中有很多的 add/remove 操作，只有少量的随机访问操作时，
* 应该选择LinkedList;在其他的场景下，考虑使用ArrayList。
*/
/**
* 8. 可变 vs 不可变
* 不可变的对象具有非常多的优势，比如简单，安全等。但是，对于每一个不同的值，都需要该类的一个对象。
* 而且，生成很多对象带来的问题就是可能导致频繁的垃圾回收。
* 所以，在选择可变类还是不可变类时，应该综合考虑后再做抉择。
* 通常而言，可变对象可以避免创建大量的中间对象。一个非常经典的例子就是链接大量的短String对象为一个长的String对象。
* 如果使用不可变String类，链接的过程将产生大量的，适合立即被垃圾回收的中间String对象，这将消耗大量的CPU性能和内存空间。
* 此时，使用一个可变的StringBuilder或StringBuffer才是正确的。
* String result = "";
* for(String s : arr){
* result = result + s;
* }
* 除了上述情况，可变对象在其他场景下可能由于不可变对象。
* 比如，传递一个可变的对象到方法内部，利用该对象可以收集多个结果，而不用在多个循环层次中跳进跳出。
*/

/**
* 9. 继承中的构造函数
* 上图中出现的两个编译时错误是因为：父类中没有定义默认构造函数，而子类中又调用了父类的默认构造函数。
* 在Java中，如果一个类不定义任何构造函数，编译期将自动插入一个默认构造函数到给类中。
* 一旦一个类定义了任何一个构造函数，编译期就不会插入任何构造函数到类中。
* 在上面的示例中，Super类定义了一个参数类型为String的构造函数，所以该类中只有一个构造函数，不会有默认构造函数了。
* &emps;在我们的子类 Sub 中，我们定义了两个构造函数：一个参数类型为String的构造函数，另一个为午餐的默认函数。
* 由于它们都没有在函数体的第一行指定调用父类的哪一个构造函数，所以它们都需要调用父类 Super 的默认构造函数。
* 但是，父类 Super 的默认构造函数是不存在的，所以编译器报告了这两个错误信息。
*/

}