20175313 張黎仙《Java綜合講座》第十三週課堂測試總結

時間 2019-12-08

標籤 Java綜合講座第十三課堂測試總結欄目 Java 简体版

原文原文鏈接

目錄java

1、JAVA中兩大類型

基本類型（byte、short、int->(Integer)、long、float、double）
類類型
二者優缺點：使用基本類型效率高，可是類類型裏面能夠有一些屬性、方法

2、基本類型與類類型的相互轉化

例如：
int 與Integer類相互轉化
- public int intValue() Integer 轉化成int
- public static Integer valueOf(String s)throwsNumberFormatExcepton
  int轉化成Integer
其餘類型與之類似

3、int與Integer之間的區別

代碼驗證1：
int i1=1; int i2=2; System.out.println(i1==i2);//結果爲true
代碼驗證2：
Integer i1=Integer.valueOf(1); Integer i2=Integer.valueOf(1); System.out.println(i1==i2);//結果爲true
代碼驗證3:
Integer i1=Integer.new(1); Integer i2=Integer.new(1); System.out.println(i1==i2);//結果爲false
代碼驗證4:
Integer i1 =100; Integer i2 =100; if (i1 == i2){ System.out.println("i1 == i2"); } else { System.out.println("i1 != i2"); } //輸出i1==i2;
代碼驗證5:
Integer i1 =200; Integer i2 =200; if (i1 == i2){ System.out.println("i1 == i2"); } else { System.out.println("i1 != i2"); } //輸出i1!=i2;
部分運行結果截圖：git
理解狀況：

因爲Integer變量其實是對一個Integer對象的引用，因此兩個經過new生成的Integer變量永遠是不相等的。(由於引用不相同)
Integer變量和int變量比較時，只要兩個變量的值是相等的，則結果爲true。
- 緣由：由於包裝類Integer和基本數據類型int比較時，java會自動拆包裝爲int，而後進行比較，實際上就變爲兩個int變量的比較。
- 例如：Integet i1=100; 默認爲Integer i1=Integer.valueOf(100)。
對於兩個非new生成的Integer對象，進行比較時，若是兩個變量的值在區間-128到127之間，則比較結果爲true，若是兩個變量的值不在此區間，則比較結果爲false
- 由於Integer有個默認範圍-128-127。
- 但你也能夠經過以下指令修改範圍：java -Djava.lang.Integer.IntegerCache.high=300;//將範圍改成-128-300

4、String、StringBuffer、StringBuilder三者之間的區別

代碼驗證1:

String s1="hello"
    String s2="hello"
    System.out.println(s1 == s2);//輸出結果爲true

代碼驗證2:

String s1="hello";
    String s2=s1;
    System.out.println(s1 == s2);//輸出結果爲true

代碼驗證3:

String s1=new String("hello");
    String s2=s1;
    s1=s1+"world";
    System.out.printlns(s1==s2);//輸出結果爲false

代碼驗證4:

StringBuilder s1=new StringBuilder("hello");
    StringBuilder s2=s1;
    s1=s1,append("hello");
    System.out.printlns(s1==s2);//輸出結果爲true

代碼驗證5:

StringBuffer s1=new StringBuffer("hello");
    StringBufferr s2=s1;
    s1=s1,append("hello");
    System.out.printlns(s1==s2);//輸出結果爲true

部分運行結果截圖：數組
理解狀況：

String爲字符串常量，而StringBuilder和StringBuffer均爲字符串變量，即String對象一旦建立以後該對象是不可更改的，但後二者的對象是變量，是能夠更改的。（String後面一旦加上一個字符串就從新new）
StringBuilder類與StringBuffer類使用 append方法日後加字符串時不改變引用
StringBuilder：適用於單線程下在字符緩衝區進行大量操做的狀況
StringBuffer：適用多線程下在字符緩衝區進行大量操做的狀況，效率低

5、ArrayList類、Vector類、LinkedList類三者之間的區別

ArrayList類，動態，數組隨機訪問，訪問任何一個元素所用的時間都是一致的查找快
Vector類，多線程，併發時使用Vector
LinkedList鏈表，查找慢，插入刪除快
代碼驗證:

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.lang.Integer;
import java.util.Vector;
public class TestList {
    public static List list = CreatList.creatList();
    public static void main(String[] args) {
        if (args[0].equals("0")) {
            ArrayListTest();
        }
        if (args[0].equals("1")) {
            VectorTest();
        }
        if (args[0].equals("2")) {
            LinkListTest();
        }
    }
    public static void ArrayListTest() {
        ArrayList arrayList = new ArrayList(list);
        int index3 = arrayList.indexOf(Integer.valueOf(35));
        System.out.println(index3);
    }
    public static void VectorTest() {
        Vector vector = new Vector(list);
        int index3 = vector.indexOf(Integer.valueOf(35));
        System.out.println(index3);
    }
    public static void LinkListTest() {
        LinkedList linkedList = new LinkedList(list);
        int index3 = linkedList.indexOf(35);
        System.out.println(index3);
    }
}

運行結果截圖：微信

6、HashMap、HashTable、TreeMap三者之間的區別

HashMap具備很快的訪問速度。HashMap不支持線程的同步，即任一時刻能夠有多個線程同時寫HashMap，可能會致使數據的不一致。
Hashtable與HashMap相似，不一樣的是：它支持線程的同步，即任一時刻只有一個線程能寫Hashtable，然而，這也致使了Hashtable在寫入時會比較慢。
TreeMap可以把它保存的記錄根據鍵排序，默認是按升序排序，也能夠指定排序的比較器。當用Iteraor遍歷TreeMap時，獲得的記錄是排過序的。

代碼驗證：

代碼1:

import java.util.Iterator;
import java.util.Map;
public class HashMap {
public static void main(String[] args) {
    Map<String, String> map1= new java.util.HashMap<String, String>();
    map1.put("20175313","張黎仙");
    map1.put("20175314","薛勐");
    map1.put("20175312","陶光遠");
    map1.put("20175316","盛茂淞");
    map1.put("20175311","胡濟棟");
    map1.put("20175315","陳煜揚");
    long start1=System.currentTimeMillis();
    Iterator<Map.Entry<String, String>> it1 = map1.entrySet().iterator();
    while (it1.hasNext()) {
        Map.Entry<String, String> e = it1.next();
        System.out.println("Key: " + e.getKey() + ";   Value: " + e.getValue());
    }
}
}

代碼2：

import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
import java.util.TreeMap;
import java.util.Iterator;
public class HashTable {
public static void main(String[] args) {
    Map<String, String> map= new Hashtable<String, String>();
    map.put("20175313","張黎仙");
    map.put("20175314","薛勐");
    map.put("20175312","陶光遠");
    map.put("20175316","盛茂淞");
    map.put("20175311","胡濟棟");
    map.put("20175315","陳煜揚");
    long start=System.currentTimeMillis();
    Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
    while (it.hasNext()) {
        Map.Entry<String, String> e = it.next();
        System.out.println("Key: " + e.getKey() + ";   Value: " + e.getValue());
    }
    }
}

代碼3：

import java.util.Iterator;
import java.util.Map;
public class TreeMap {
public static void main(String[] args) {
    Map<String, String> map2= new java.util.TreeMap<String, String>();
    map2.put("20175313","張黎仙");
    map2.put("20175314","薛勐");
    map2.put("20175312","陶光遠");
    map2.put("20175316","盛茂淞");
    map2.put("20175311","胡濟棟");
    map2.put("20175315","陳煜揚");
    long start2=System.currentTimeMillis();
    Iterator<Map.Entry<String, String>> it2 = map2.entrySet().iterator();
    while (it2.hasNext()) {
        Map.Entry<String, String> e = it2.next();
        System.out.println("Key: " + e.getKey() + ";   Value: " + e.getValue());
    }
}
}