Java 基礎 -- 泛型、集合、IO、反射

1. 對於泛型類而言，你若沒有指明其類型，預設為Object； 2. 在繼承泛型類以及介面的時候可以指明泛型的類型，也可以不指明； 3. 泛型也資料庫中的應用：寫一個 DAO 類對資料庫中的數據進行增刪改查其類型聲明為 <T> 。每張表對應一個類，對應每一張表實現一個類繼承該 DAO 類並指明 D ...

計劃把 Java 基礎的有些部分再次看一遍，鞏固一下，下麵以及以後就會分享自己再次學習的一點筆記！不是有關標題的所有知識點，只是自己覺得模糊的一些知識點。

1.　　對於泛型類而言，你若沒有指明其類型，預設為Object；

2.　　在繼承泛型類以及介面的時候可以指明泛型的類型，也可以不指明；

3. 　　泛型也資料庫中的應用：

　　　　　　寫一個 DAO 類對資料庫中的數據進行增刪改查其類型聲明為 <T> 。每張表對應一個類，對應每一張表實現一個類繼承該 DAO 類並指明 DAO 泛型為該數據表對應的類，再實現一個與該表匹配的 DAO 操作類，這樣就不必在每一個數據表的操作實現類中去實現增刪改查的基本方法。例如（實際應用中大概就是這思想，下麵的舉例並不完整）：

 1 //數據表對應的類
 2 public class Customer{
 3     private int id;
 4     private String name;
 5     ...
 6 }
 7 
 8 //所有數據表的操作類都要實現的 DAO 基類
 9 public class DAO<T> {
10     //增
11     public void add(T t) {
12     …
13     ｝
14 }
15 
16 public T get(int index) {
17     //查
18     return null;
19 }
20 
21 public void delete() {
22     //刪
23     …
24 }
25 
26 public List<T> getForList(int index) {
27     //查
28     return null;
29 }
30 
31 //數據表操作對應的實現類
32 public class CustomerDao extends DAO<Customer> {
33                 
34 }
35 
36 //測試類
37 public class Test {
38     public static void mian(String[] args) {
39     CustomerDao cus = new CustomerDao;
40     Cus.add(new Customer);
41     }
42 }

View Code

4. 　　靜態方法中不可以使用泛型（static）

　　　　　　因為static 聲明的方法或者類以及變數都是在類初始化的時候初始化，而泛型是在運行的時候才回去初始化的，所以就出現了問題（後出現的調用了先出現的）。

public T t;
    //Error
    public static void show() {
        System.out.println(t);
}

View Code

5.　　通配符

　　　　　　可以讀取聲明為通配符的集合，但不可往裡寫入元素（讀的時候可以把元素都認為是 Object，但寫的時候其聲明為？，不是 Object，也就是說寫什麼類型都是錯的，但可以存 null），例如

Public void testList() {
    List<String> strList = new ArrayList<>();
    strList.add(“Hello”);
    strList.add(“World”);

    //correct
    List<?> list = strList;
    
    //error
    list.add(“hi”);
    list.add(123);
    //correct
    list.add(null);
}

View Code

6.　　集合Map 的遍歷

package com.java.map.test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class MapEntry {

    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "a");
        map.put(2, "b");
        map.put(3, "c");
        map.put(4, "d");
        map.put(5, "e");
        // 得到 map 所有鍵的集合
        Set<Integer> keys = map.keySet();

        for (Integer key : map.keySet()) {
            System.out.println(map.get(key));
        }

        // 利用迭代器 遍歷
        Iterator<Map.Entry<Integer, String>> it = map.entrySet().iterator();

        while (it.hasNext()) {
            Map.Entry<Integer, String> entry = it.next();
            System.out.println(entry.getKey() + " -> " + entry.getValue());
        }

        // 第三種
        for (Map.Entry<Integer, String> entry : map.entrySet()) {
            System.out.println(entry.getValue());
        }

        // 遍歷所有的 value 值
        Collection<String> values = map.values();

        for (String val : values) {
            System.out.println(val + ">>-");
        }

        Iterator<String> i = values.iterator();
        while (i.hasNext()) {
            System.out.println(i.next() + "-->");
        }

        List<String> lists = new ArrayList<>();
        lists.add("1");
        lists.add("2");
        lists.add("3");
        lists.add("4");

        Iterator<String> it2 = lists.iterator();

        while (it2.hasNext()) {
            System.out.println(it2.next());
        }
        
        Collections.reverse(lists);
        Iterator<String> it3 = lists.iterator();
//        Comparator comparator = new 
        
        
        while (it3.hasNext()) {
            System.out.println(it3.next() + "<->");
        }
    }
}

View Code

7.　　利用反射獲取方法名和屬性名，利用反射還可以獲取構造器等其他信息

package com.java.reflct.test;

//實體類
public class Person {

    private String id;
    
    private String name;
    
    public int phone;
    
    public void setId(String id) {
        this.id = id;
    }
    
    public String getId() {
        return id;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public String getName() {
        return name;
    }
    
    public void setPhone(int phone) {
        this.phone = phone;
    }
    
    public int getPhone() {
        return phone;
    }
    
    private void print() {
        System.out.println("your id is " + id + ", your name is " + name + ", your phone is " + phone + "!");
    }

    @Override
    public String toString() {
        return "Person [id=" + id + ", name=" + name + ", phone=" + phone + "]";
    }
}

package com.java.reflct.test;
//測試類

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class TestReflect {

    public static void main(String[] args) {
        try {
//            通過 Class.forName("全類名"); 獲取 Class，還以利用  對象名.getClass()  類名.class(); 獲取Class
            Class cla = Class.forName("com.java.reflct.test.Person");
            Class cla2 = Person.class;
            
//            獲取所有的 變數，返回數組，包括私有變數
            Field[] fields = cla2.getDeclaredFields();
//            遍歷變數數組
            for (Field fie : fields) {
                System.out.println(fie+"-..-");
            }
            
//            獲取所有的方法，返回數組，包括私有方法
            Method[] methods = cla.getDeclaredMethods();
            
            for (Method met : methods) {
                System.out.println(met);
            }
            
            try {
//                獲取單個私有屬性
                Field field = cla.getDeclaredField("id");
//                打破封裝
                field.setAccessible(true);
                System.out.println(field + "<<>>");
            } catch (NoSuchFieldException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (SecurityException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
            Method method = null;
            
            try {
//                獲取單個私有方法
                method = cla.getDeclaredMethod("print");
//                打破封裝
                method.setAccessible(true);
                System.out.println(method + ">><<");
            } catch (NoSuchMethodException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (SecurityException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            
            try {
//                通過cla.newInstance(); 獲取類的對象
                Person person = (Person) cla.newInstance();
                person.setId("1");
                person.setName("yinyin");
                person.setPhone(110);
                
                System.out.println(person + "__>>__");
                try {
//                    執行 person 對象的中 method 所對應的方法
                    method.invoke(person);
                } catch (IllegalArgumentException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            } catch (InstantiationException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            } catch (IllegalAccessException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
            }
            
            
        } catch(ClassNotFoundException e) {
            System.out.println("There is no class " + e);
        }
    }
}

View Code

8.　　Comparator 類的使用（利用 Comparator 實現集合的自定義排序）

　　　　　　註意區分 Collections （集合的處理類）和 Collection （集合基類）

package com.java.collection.test;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

/*
 * Collections 是 Collection 的操作類
 */

public class CollectionComparator {
    
    public static void main(String[] args) {
        
        Comparator<Customer> com = new Comparator<Customer>(){

            @Override
            public int compare(Customer o1, Customer o2) {
//                將 id 的比較值放入參數中，使得 id 相等時有其他的處理方法
                int i = o1.getId().compareTo(o2.getId());
                
//                當 Id 相等的時候比較名字的順序
                if (i == 0) {
//                    給 return 添加一個 - 號可以實現 “從大到小”
                    return o1.getName().compareTo(o2.getName());
                }
//                                    Id 不相等時返回其值        
                                   return i;
            }
        };
        
        List<Customer> lists = new ArrayList<>();
        lists.add(new Customer("yinyin", "110", 1001));
        lists.add(new Customer("zhao", "10086", 1002));
        lists.add(new Customer("ls", "10010", 1001));;
        
        Collections.sort(lists, com);
        
//        利用匿名類實現自定義排序
        /*
        Collections.sort(lists, new Comparator<Customer>(){

            @Override
            public int compare(Customer o1, Customer o2) {
//                將 id 的比較值放入參數中，避免 id 相等沒有其值
                int i = o1.getId().compareTo(o2.getId());
                
//                當 Id 相等的時候比較名字的順序
                if (i == 0) {
                    return o1.getName().compareTo(o2.getName());
                }
                return i;
            }
        });
        */
 //利用迭代器遍歷集合
        Iterator<Customer> it = lists.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());
        }
        
    }
}

View Code

9.　　IO

　　　　　　讀取目標文本文件的位元組數

package com.java.io.file.test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;

public class MyIoTest {

    public static void main(String[] args) {
        
//        在 IO 中出現的異常最好都使用 try-catch 包裹起來，不要 throw，因為這樣可以保證流的關閉在任何時候都可以正常執行
        InputStream fileStream = null;
        int count = 0;
        try {
            fileStream = new FileInputStream(new File("hello.txt"));
//            讀取文件的下一個位元組
            while (fileStream.read() != -1) {
                count++;
            }
//            列印目標文件的位元組數
            System.out.println(count);
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                fileStream.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

View Code

　　　　　　實現文件的複製（InputStream 、OutputStream 和 Reader 、Writer）。文本文件的操作使用 Reader Writer（字元流）去實現，效率高。但是不可以去操作媒體文件；媒體文件使用 InputStream OutputStream 去實現，也可以對文本文件進行操作，但是沒有字元流高效。

package com.java.io.file.test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class CopyFile {

    public static void main(String[] args) {
//        設置一次從目標文件中讀取多少位元組
        byte[] buffer = new byte[1024];

        int len = 0;
        File file = new File("C:/Users/lenovo/Desktop/123.wmv");
        InputStream fileInput = null;
        OutputStream fileOut = null;

        try {
            fileInput = new FileInputStream(file);
            fileOut = new FileOutputStream(new File("C:/Users/lenovo/Desktop/trave2.wmv"));

//            len 的作用是防止讀取文件時最後一次其長度不夠讀取被置為零，read() 返回讀入緩衝區的位元組總數
            while ((len = fileInput.read(buffer)) != -1) {
                fileOut.write(buffer, 0, len);
            }
            System.out.println("SUCC");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                fileOut.close();
                fileInput.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

}





//利用 Reader Writer 實現
package com.java.io.file.test;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

public class ReaderWriter {

    public static void main(String[] args) {
        File file = new File("hello.txt");
        int len = 0;
        Reader fileReader = null;
        Writer fileWriter = null;
        char[] ch = new char[125];
        
        try {
            fileReader = new FileReader(file);
            fileWriter = new FileWriter(new File("world.txt"));
            
            while((len = fileReader.read(ch)) != -1) {
                fileWriter.write(ch, 0, len);
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
                fileWriter.close();
                fileReader.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

View Code

10.　　利用緩衝流實現文件的複製操作，效率更高

package com.java.io.file.test;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class TestBufferedCopy {
// 使用緩衝流實現文件的複製
    public static void main(String[] args)  {
        
        int len = 0;
        byte[] buffer = new byte[2048];
        
        File file = new File("C:/Users/lenovo/Desktop/123.rmvb");
        InputStream inputFile = null;
        OutputStream outputFile = null;

        BufferedInputStream bufferedInput = null;
        BufferedOutputStream bufferedOutput = null;
        
        try {
            inputFile = new FileInputStream(file);
            outputFile = new FileOutputStream("C:/Users/lenovo/Desktop/456.rmvb");
            
            bufferedInput = new BufferedInputStream(inputFile);
            bufferedOutput = new BufferedOutputStream(outputFile);
            
            while((len = bufferedInput.read(buffer)) != -1) {
                bufferedOutput.write(buffer, 0, len);
            }
            
            System.out.println("SUCC");
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            try {
//                只需關閉複製文件用到的就可以，即最後兩個
                bufferedOutput.close();
                bufferedInput.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

View Code

上面的代碼總結啥的都是自己平常練習過程中的代碼和心得，對於知識點講解覆蓋的並不全面，還望諒解。初來乍到不知道該如何去寫！