Java第十六天（Map接口、File文件、文件的遍歷-遞歸）

78.Map接口

（1）概念和方法

一個映射不能包含重複的鍵；

每一個鍵最多隻能映射到一個值。

鍵只容許有一個空值，

值能夠有多個空值。

Map也是無序的

Map<K,V> ：K和V表示泛型，map的key和value能夠是任何類型（不能是基本數據類型），實際項目中K通常都是字符串類型。

import java.util.HashMap;
import java.util.Map;

public class MapTest1 {
    public static void main(String[] args) {
        Map<String,String> map=new HashMap<>();
        map.put("二狗子","趙衛國");
        map.put("狗剩子","劉全");
        map.put("翠花","李翠翠");
        System.out.println(map);
        map.put("小翠","李翠翠");
        map.put(null,null);
        //map.put(null,null);鍵惟一，只容許有一個null，值能夠容許有多個null
        System.out.println(map);//map是無序的
    }
}

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MapTest2 {
    public static void main(String[] args) {
        Map<String,String> map=new HashMap<>();
        map.put("二狗子","趙衛國");
        map.put("狗剩子","劉全");
        Map<String,String> map1=new HashMap<>();
        map1.put("翠花","李翠翠");
        map1.put("小翠","李翠翠");
        //putAll 添加另外一個map集合的內容
        map.putAll(map1);
        System.out.println(map);
        //根據key刪除對應的key=
        map.remove("小翠");
        System.out.println(map);
        //根據key得到
        System.out.println(map.get("二狗子"));
        System.out.println("------------利用keySet遍歷map集合-------------");
        //keySet()得到key的set集合
        Set<String> strings = map.keySet();
        //對key集合作遍歷
        for (String key : strings) {
            //根據遍歷獲得的每個key得到map中的
            String value=map.get(key);
            System.out.println(key+"---"+value);
        }
        //判斷是否包含
        System.out.println(map.containsKey("狗剩子"));
        System.out.println(map.containsValue("劉歡"));
        System.out.println(map.isEmpty());
        System.out.println("--------------entrySet()遍歷-----------------");
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            String key=entry.getKey();
            String value=entry.getValue();
            System.out.println(key+"="+value);
        }
    }
}

（2）HashMap類

一個映射不能包含重複的鍵；若是存在重複的key就會把以前的覆蓋掉其實鍵就是Set，元素惟一，只能有一個null，元素是無序的。不是線程安全的。

（3）TreeMap類

該映射根據其鍵的天然順序進行排序，或者根據建立映射時提供的 Comparator 進行排序，具體取決於使用的構造方法。

TreeMap特色：

能夠按着key來作排序，若是key的泛型是類，則該類需實現Comparable

Key不能null，key不能重複，值能夠有多個null

不是線程安全的

import java.util.Map;
import java.util.TreeMap;

public class TreeMapTest {
    public static void main(String[] args) {
        Map<Person,String> map=new TreeMap<>();
        map.put(new Person("賈寶玉",16),"寶哥兒");
        map.put(new Person("林黛玉",15),"林妹妹");
        map.put(new Person("薛寶釵",16),"寶姐姐");
        System.out.println(map);
        Map<String,String> map1=new TreeMap<>();
        map1.put("b","趙衛國");
        map1.put("c","劉全");
        map1.put("a","李翠翠");
        System.out.println(map1);
    }
}

(4)Hashtable類

HashTable的特色

1. HashTable是map的實現類

2.不容許任何null值和null鍵

3. HashTable中的元素沒有順序（跟添加的順序無關）

4. HashTable是線程安全的。

import java.util.Hashtable;
import java.util.Map;

public class HashTableTest {
    public static void main(String[] args) {
        Map<Person,String> map=new Hashtable<>();
        map.put(new Person("賈寶玉",16),"寶哥兒");
        map.put(new Person("林黛玉",15),"林妹妹");
        map.put(new Person("薛寶釵",16),"寶姐姐");
        System.out.println(map);
        Map<String,String> map1=new Hashtable<>();
        map1.put("b","趙衛國");
        map1.put("c","劉全");
        map1.put("a",null);
        System.out.println(map1);
    }
}

（5）LinkedHashMap類

LinkedHashMap的特色

1. LinkedHashMap是map的實現類

2.容許多個null值和一個null鍵

3. LinkedHashMap有順序（添加的順序）

4. LinkedHashMap不是線程安全的。

import java.util.LinkedHashMap;
import java.util.Map;

public class LinkedHashMapTest {
    public static void main(String[] args) {
        Map<Person,String> map=new LinkedHashMap<>();
        map.put(new Person("賈寶玉",16),"寶哥兒");
        map.put(new Person("林黛玉",15),"林妹妹");
        map.put(new Person("薛寶釵",16),"寶姐姐");
        System.out.println(map);
        Map<String,String> map1=new LinkedHashMap<>();
        map1.put("b","趙衛國");
        map1.put("c","劉全");
        map1.put(null,null);
        System.out.println(map1);
    }
}

79.文件File

import java.io.File;

public class FileTest {
    public static void main(String[] args) {
        //建立一個文件對象,能夠是目錄也能夠是文件
        File file = new File("D:\\aaa\\bbb\\ccc","tx.txt");
        System.out.println(file.getName());
        //絕對路徑建立文件對象
        File file1 = new File("D:\\aaa\\bbb\\ccc\\tx.txt");
        System.out.println(file1.getName());
    }
}

import java.io.File;
import java.io.IOException;

public class FileTest1 {
    public static void main(String[] args) throws IOException {
        //根據抽象路徑建立文件對象
        File file = new File("aa.txt");
        //判斷文件是否存在，new File建立的是文件對象
        boolean b=file.exists();
        System.out.println(b);
        //建立一個文件或者文件目錄
        boolean newFile = file.createNewFile();
        System.out.println(newFile);
        //得到文件的的絕對路徑
        String absolutePath = file.getAbsolutePath();
        System.out.println(absolutePath);
        //得到文件的相對路徑
        String path = file.getPath();
        System.out.println(path);

    }
}

import java.io.File;

public class FileTest2 {
    public static void main(String[] args) {
        File file1 = new File("D:\\bbb");
        File file2 = new File("D:\\aaa\\ggg\\ooo\\ppp\\qqq");
        //建立目錄，file1必須有上一層路徑且路徑必須正確
        boolean mkdir = file1.mkdir();
        System.out.println(mkdir);
        //建立多級目錄
        boolean mkdirs = file2.mkdirs();
        System.out.println(mkdirs);
    }
}

import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.Date;

public class FileTest3 {
    public static void main(String[] args) throws IOException {
        File file = new File("D:\\aaa\\ggg\\ooo\\ppp\\qqq");
        File file1 = new File("D:\\aaa");
        String absolutePath = file.getAbsolutePath();
        System.out.println("得到文件的絕對路徑是"+absolutePath);
        String path = file.getPath();
        System.out.println("得到文件的相對路徑是"+path);
        String name = file.getName();
        System.out.println("得到文件的名字是"+name);
        long length = file.length();
        System.out.println("得到文件的大小是（以字節爲單位）"+length);
        long l = file.lastModified();
        System.out.println("得到文件最後修改時間是"+new Date(l));
        File[] files = file.listRoots();
        File[] files1 = file1.listRoots();
        System.out.println("得到file的根目錄是"+ Arrays.toString(files));
        System.out.println("得到file1的根目錄是"+Arrays.toString(files1));
        File[] files2 = file1.listFiles();
        System.out.println("得到file1的子目錄是"+Arrays.toString(files2));//只有當文件或者文件目錄具備子目錄的時候能夠調用
        String[] list = file.list();
        System.out.println("得到file的名字是"+Arrays.toString(list));
    }
}

注意：建立目錄返回的布爾類型結果只有在上級目錄路徑存在且正確，而且須要建立的目錄原始不存在的狀況下，返回的是true，不然爲false

import java.io.File;

public class FileTest4 {
    public static void main(String[] args) {
        File file = new File("aa.txt");
        File file1 = new File("D:\\aaa");
        boolean file2 = file.isFile();
        System.out.println("判斷是不是文件"+file2);
        boolean directory = file1.isDirectory();
        System.out.println("判斷是不是目錄"+directory);
        boolean absolute = file.isAbsolute();
        System.out.println("判斷是不是絕對路徑"+directory);
        boolean b = file.canRead();
        System.out.println("判斷是否可讀"+b);
        boolean b1 = file.canWrite();
        System.out.println("判斷是否可寫"+b1);
    }
}

80.文件的遍歷----遞歸

public class RecursionTest {
    public static void main(String[] args) {
        int result=fn(5);
        System.out.println(result);
        System.out.println(fn(1));
    }
    //遞歸，階乘方法
    public static int fn(int num){
        //結果初值爲1，當num爲1的時候返回s=1
        int s=1;
        //限制必須是大於一
        if(num>1){
            s=num*fn(num-1);
        }
        return s;
    }
}

要求：遍歷一個文件下的全部

import java.io.File;

public class RecursionFileTest {
    static int level;
    public static void main(String[] args) {
        File file = new File("D:\\aaa");
        parse(file);
    }
    public static void parse(File file){
        //判斷文件存在且不爲null
        if(file==null||!file.exists()){
            return;
        }
        File[] files = file.listFiles();
        //定義在方法以外的層級屬性，每進一次方法層級加一
        level++;
        for (File file1 : files) {
            //根據層級打印空格區分父子文件
            for (int i = 0; i < level; i++) {
                System.out.print("\t");
            }
            //打印子文件的名稱
            System.out.println(file1.getName());
            //若是遍歷的子文件是目錄再次進入方法遍歷子文件
            if(file1.isDirectory()){
                parse(file1);
            }
        }
        //同級文件的子文件打印完成以後進行另外一個同級文件的操做層級要退出來
        level--;
    }
}

要求：刪除一個文件目錄（File中當文件不爲空的時候是沒有辦法刪除的，只有先刪除子文件把目錄變成空的能夠刪掉，採用遞歸方法一層一層遍歷刪除）

import java.io.File;

public class RecursionFileTest1 {
    public static void main(String[] args) {
        File file = new File("D:\\aaa");
        delfile(file);
    }
    public static void delfile(File file){
        //判斷文件存在且不爲null
        if(file==null||!file.exists()){
            return;
        }
        File[] files = file.listFiles();
        for (File file1 : files) {
            //判斷子文件是否爲目錄若是是目錄再進方法遍歷，若是不是目錄是文件就刪掉
            if(file1.isDirectory()){
                delfile(file1);
            }else{
                file1.delete();
            }
        }
        //被刪掉子文件的目錄就是空目錄能夠直接刪掉
        file.delete();
    }
}