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();
}
}
扫一扫
910
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
