心得體會

• 有時候上課認真聽講效率勝過課后自己花費大量時間再去學習批糟，上課邊聽邊有意識的整理筆記勝過課后去整理自己雜亂的筆記要來的輕松格了。如果自己在課上寫代碼的時候有意識的將代碼模塊化，課后再去整理就會輕松很多徽鼎。一個好習慣的養(yǎng)成是長久的堅持盛末。

今日知識點

• 1.泛型

• 2.集合-Set(hashSet)

• 3.TreeSet進行排序的兩種辦法

• 4.HashMap的方法

• 5.鍵值對的兩種遍歷方式

• 6.異常處理

具體操作

1.泛型

• 1.什么是泛型

泛型就是指參數(shù)化類型，例如：List<String>就是參數(shù)化類型否淤，因此就是泛型悄但，而String就是該List<String>泛型的類型參數(shù)；

• 2.為什么要使用泛型

通過泛型可以定義類型安全的數(shù)據結構（類型安全）石抡，而無須使用實際的數(shù)據類型（可擴展）檐嚣。這能夠顯著提高性能并得到更高質量的代碼（高性能），因為您可以重用數(shù)據處理算法啰扛，而無須復制類型特定的代碼（可重用）

• 3.泛型基礎小demo

demo里面定義了一個泛型類GenericTest<T>,其中<T>里面的T表示參數(shù)類型嚎京，在main函數(shù)里面使用了該泛型類GenericTest<String> g1=new GenericTest<>(),此時數(shù)據類型被定義為String

public class Myclass {
    public static void main(String[] args){
        GenericTest<String> g1=new GenericTest<>();//尖括號里面一定是 對象類型
        g1.test("jack","jacker");
}
}
//定義了一個泛型類嗡贺，其中‘T’代表不確定的對象類型
class GenericTest<T>{
    int age;
    T a1;
    T a2;
  //這里寫了一個構造方法，構造方法里面參數(shù)的類型是不確定的
    public void test(T a1, T a2){
        this.a1=a1;
        this.a2=a2;

        System.out.println(a1.equals(a2));
    }
}

image.png

ps：

1.類型變量使用大寫形式鞍帝，比較短暑刃。在java庫中，變量E表示集合的元素膜眠，K和V分別表示表的關鍵字與值的類型岩臣。T表示“任意類型”。

2.<T>,泛型里面宵膨，的類型變量一定是對象類型 （例如：類型為整形時架谎，使用時T應該為Integer,而不是int

2.集合-Set(hashSet、TreeSet)

Collection--List--ArrayList
                  --Set---HashSet
                       ---LinkedHashSet
                       ---TreeSet

• 1. Set接口的特點

1.它是個不包含重復元素的集合辟躏。
2.Set集合取出元素的方式可以采用：迭代器谷扣、增強for。
3.Set集合有多個子類捎琐，這里我們介紹其中的HashSet会涎、TreeSet這兩個集合。

• 2.HashSet

• 2..HashSet方法的使用

        HashSet<String> names=new HashSet<>();
        names.add("jack");
        names.add("merry");
        System.out.println(names);

image.png

• 1. 集合里面對象不能重復 , 如果重復 ,就加不進去

HashSet<String> names=new HashSet<>();
        names.add("jack");
        names.add("jack");
        System.out.println(names);

image.png

• 2.集合是無序的, 添加的順序和存儲的順序無關, 里面使用了默認排序

      HashSet<String> names=new HashSet<>();
      names.add("jack");
      names.add("Merry");
      names.add("abc");
      System.out.println(names);

image.png

• 3.使用compareTo()方法進行比較篩選

 HashSet<String> names=new HashSet<>();
        names.add("jack");
        names.add("merry");
        names.add("abc");
        names.removeIf(ele->{
          return ele.compareTo("c")>0;
        });
        System.out.println(names);

image.png

• 通過CompareTo()方法將字符串組里面的“jack”“merry”移除
• 這里用了Lambda表達式瑞凑，由于"j"末秃、"m">"c",所以"jack","merry"被移除, 字符串的比較，是一個一個按順序從頭到尾輪流比的籽御，如果字符串前面的字符已經比較出結果了练慕，那么后面的也不需要比了

3.TreeSet進行排序的兩種辦法

• 1.TreeSet的性質

• TreeSet是可以排序的集合，有序的集合

1.TreeSet的第一種排序方法----自然排序

1.這種方法需要一個新的類實現(xiàn)Comparator<T>接口

2.重寫其中的Compare 方法

  TreeSet<Person> score=new TreeSet<>(new Comparator<Person>() {
            @Override
            public int compare(Person person, Person t1) {
              return person.compareTo(t1);
                }
        });
}
}
class Person implements Comparable {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }


    //
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

   @Override
    public int compareTo(Object o) {
        //1.判斷o對象是不是person的一個對象
        if(o instanceof Person){
            Person o1=(Person)o;
          //自己規(guī)定比較的策略
            if(this.age!=o1.age){
                return this.age-o1.age;
            }else{
                //年齡相同的情況下 再比姓名的字母
                return this.name .compareTo(o1.name);
            }
        }else{
            return -1;
        }
    }
}

2.TreeSet的第二種排序方法----自然排序
1, 需要被排序的類實現(xiàn)Comparable<T>接口(參與比較的對象必須實現(xiàn)Comparable接口的compareTo方法)

2, 重寫其中的 comparato

 TreeSet<Person> score=new TreeSet<>((Person p1,Person p2)->p1.compareTo(p2)) ;
        Person p1=new Person("jack",20);
        Person p2=new Person("jack",30);
        Person p3=new Person("rose",20);

        score.add(p1);
        score.add(p2);
        score.add(p3);
        System.out.println(score);
}
}
class Person implements Comparable {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
  //參與?比較的對象必須實現(xiàn)Comparable接?口的compareTo?方法
   @Override
    public int compareTo(Object o) {
        //1.判斷o對象是不是person的一個對象
        if(o instanceof Person){
            Person o1=(Person)o;
          //自己規(guī)定比較的策略
            if(this.age!=o1.age){
                return this.age-o1.age;
            }else{
                //年齡相同的情況下 再比姓名的字母
                return this.name .compareTo(o1.name);
            }
        }else{
            return -1;
        }
    }
}

4.HashMap

image.png

• HashMap是一種集合
  存儲數(shù)據的特點：key->value
  key（鍵）：不能重復 可以是任意的對象類型 通常使用字符串String

• HashMap的方法

 HashMap<String, Integer> score=new HashMap<>();//鍵的類型是String ,值的類型是Integer

        //添加對象 鍵值對
        score.put("Chinese",89);
        score.put("Math",94);
        score.put("English",92);
        System.out.println(score);
        System.out.println();

        //更改某個鍵對應的值
        score.put("Chinese",91);//如果已經有同樣的鍵铃将，就會默認更改該鍵對應的值
        System.out.println(score);
        System.out.println();

        //獲取鍵的個數(shù)
        score.size();
        System.out.println();

        //獲取所有的key
        System.out.println(score.keySet());
        System.out.println();

        //獲取所有的值
        System.out.println(score.values());
        System.out.println();

        //獲取Entry:key-value
        System.out.println(score.entrySet());//獲取每一個鍵值對
        System.out.println();


        //獲取一個鍵key對應的值
        System.out.println(score.get("English"));

image.png

5.鍵值對的兩種遍歷方式

1.鍵值對的第一種遍歷方式--- 通過遍歷key來得到每一個key對應的值

 HashMap<String, Integer> score=new HashMap<>();//鍵的類型是String ,值的類型是Integer
        //添加對象 鍵值對
        score.put("Chinese",89);
        score.put("Math",94);
        score.put("English",92);

        for(String key:score.keySet()){
            //通過key得到值
            int s=score.get(key);
            System.out.println("key:"+key+" value :"+s);
        }

2.鍵值對的第二種遍歷方式--- 通過entrySet 得到Entry對象的集合

 HashMap<String, Integer> score=new HashMap<>();//鍵的類型是String ,值的類型是Integer
        //添加對象 鍵值對
        score.put("Chinese",89);
        score.put("Math",94);
        score.put("English",92);

 Set<Map.Entry<String, Integer>> entrys = score.entrySet();//先接受每一個鍵值對的對象
        for (Map.Entry entry : entrys) {
            //得到Entry對應的key
            String key = (String) entry.getKey();
            //獲取Entry對應的值
            Integer value = (Integer) entry.getValue();
            System.out.println("key:" + key + " value :" + value);

        }
    }
}

運行結果

image.png

6.異常處理

1.異常處理：處理運行過程中出現(xiàn)的不可控的錯誤，使程序更健壯

1.在我們編寫異常處理代碼的時候哑梳，主要就是使用前面介紹到的try-catch-finally這三種代碼塊。

try{
      執(zhí)行可能出現(xiàn)異常的代碼
     一旦出現(xiàn)異常 系統(tǒng)自動為我們創(chuàng)建一個異常對象 并拋出
  }catch(NullPointerException e){
      如果需要 自己處理異常就catch
  }catch(IOException e){
      如果有多個異常 可以使用多個catch來捕獲
  }catch(Exception e){
 
  }finally{
     處理資源回收( 網絡鏈接 數(shù)據庫連接 IO流)
      1.不管有沒有異常finally都會被執(zhí)行
  }

  public static void main(String[] args) {
        int a = 0;
        int b = 20;
        FileReader fr = null;
        try {
            int c = b / a;

            fr = new FileReader("");
//          System.out.println("hello");//不會打印
        } catch (ArithmeticException e) {
            System.out.println(e.getMessage());
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                fr.close();
            } catch (IOException i) {

            }
        }
    }
}

• 如果有多個異常 catch的順序是從小到大

try{
     
  }catch(NullPointerException e){
     
  }catch(IOException e){
      
  }catch(Exception e){
 
  }

• 如果異常出現(xiàn) 后面的代碼將不會執(zhí)行（try代碼塊不是越多越好 不要抓太多代碼)
• 看下面一段代碼：

public class Exception1 {
    public static void main(String[] args) {
        int a = 0;
        int b = 20;
        try {
            int c = b / a;
  } catch (ArithmeticException e) {
            System.out.println(e.getMessage());
        }
    }
}

image.png

• 如果在try里面在加上一行代碼：

public class Exception1 {
    public static void main(String[] args) {
        int a = 0;
        int b = 20;
        try {
            int c = b / a;
           System.out.println("hello");//不會打印
  } catch (ArithmeticException e) {
            System.out.println(e.getMessage());
        }
    }
}

image.png

輸出結果是一樣的

2.使用throws拋出異常 給外部處理

 public static void test() throws FileNotFoundException, NullPointerException {//如果有多個異常悯仙，用逗號隔開
        FileReader fr = new FileReader("");
    }

3.使用throw拋出?一個自己創(chuàng)建的異常對象

當特殊情況出現(xiàn)了 自己可以選擇拋出異常
throw new IllegalAccessException();

 public static void test2() throws IllegalAccessException {
        if (2 > 1) {
            throw new IllegalAccessException();
}

4.自定義異常類: 能夠自己定義輸出內容 更快地找到出現(xiàn)問題的位置

class PXDException extends Exception{
    //1.提供一個無參構造方法
    public PXDException(){

    }
    //2.提供一個有參構造方法 參數(shù)是一個字符串
    public PXDException(String desc){
        super(desc);
    }
}

 public static void test3() throws PXDException{

        StackTraceElement[] stackTrace=Thread.currentThread().getStackTrace();
        StackTraceElement e=stackTrace[2];
        String detail=" "+e.getFileName()+"->"+e.getMethodName()+"->"+e.getLineNumber();
        throw new PXDException("自己的異常類：無所作為"+detail);
    }
}

• 使用

     }
        try {
            TException.test3();
        }catch(PXDException e){
            System.out.println(e.getMessage());
        }

image.png