JAVA SE01 Unit05
- PM2.5监控程序——统计各点PM2.5最大值
- hashCode方法的重写
- PM2.5监控程序——遍历各点PM2.5最大值
- PM2.5监控程序—统计并遍历各点PM2.5最大值（要求顺序）
- 查看一个文件的大小
- 创建一个空文件
- 删除一个文件
- 创建一个目录
- 创建一个多级目录
- 删除一个目录
1 PM2.5监控程序——统计各点PM2.5最大值
1.1 问题
北京某日空气质量PM2.5监测站点全程检测的数据如下表所示，一个监测站点有可能在一天内多次采集，因此同一个站点可能有多个数据，如表-1所示;
表-1 PM2.5监测数据
请统计各空气质量监测站点PM2.5的最高值。
1.2 方案
分析问题中提出的要求为统计各空气质量监测站点PM2.5的最高值，再结合提供的PM2.5浓度数据，可以发现，站点名可以作为Map的key，对应的PM2.浓度的浓度数据可以作为Map的value，利用Map接口提供的put方法，该方法可以根据key去更新value来实现统计各个空气监测站点PM2.5的最高值。
1.3 步骤
实现此案例需要按照如下步骤进行。
步骤一：新建TestHashMap类，添加测试方法test1方法
首先，在工程JavaSE下新建包day05，在该包下新建类TestHashMap；然后，在该类中添加方法test1，代码如下所示：
package day05;
import org.junit.Test;
public class TestHashMap{
/**
*统计各空气质量监测站点PM2.5的最高值
*/
@Test
public void test1() {
}
}
步骤二：将数据拼接成字符串
将问题中的表格数据拼接成字符串，形式如："农展馆=423,东四=378“；然后，使用String类的split方法，将拼接后字符串使用正则[,=]进行拆分，代码如下所示：
package day05;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import org.junit.Test;
public class TestHashMap {
/**
* 统计各空气质量监测站点PM2.5的最高值
*/
@Test
public void test1() {
#cold_bold String pm25 = "农展馆=423,东四=378,丰台花园=406,天坛=322,海淀区万柳=398,"
#cold_bold + "官园=406,通州=366,昌平镇=248,怀柔镇=306,定陵=231,前门=422,"
#cold_bold + "永乐店=368,古城=268,昌平镇=423,怀柔镇=267,定陵=377,前门=299,"
#cold_bold + "永乐店=285,秀水街=277,农展馆=348,东四=356,丰台花园=179,天坛=277,"
#cold_bold + "海淀区万柳=270,官园=268,通州=315";
#cold_bold String[] arr = pm25.split("[,=]");
}
}
上述代码中，拆分后的数组数据如下所示：
[农展馆, 423, 东四, 378, 丰台花园, 406, 天坛, 322, 海淀区万柳, 398, 官园, 406, 通州, 366, 昌平镇, 248, 怀柔镇, 306, 定陵, 231, 前门, 422, 永乐店, 368, 古城, 268, 昌平镇, 423, 怀柔镇, 267, 定陵, 377, 前门, 299, 永乐店, 285, 秀水街, 277, 农展馆, 348, 东四, 356, 丰台花园, 179, 天坛, 277, 海淀区万柳, 270, 官园, 268, 通州, 315]
观察上述数组会发现，如果农展馆的索引为0，其对应的数据的索引为1，并且每隔一个就是下一个站点的名字，如果循环取各个站点名，那么代码如下：
for (int i = 0; i < arr.length; i += 2) {}
其中arr[i]为站点名，arr[i+1]为对应的PM2.5数据。
步骤三：利用Map的特点，获取各个站点的PM2.5最大值
首先，构建map对象，该map对象的key存储站点名，value存储对应的浓度。
然后，构建循环，循环的次数为arr数组的长度；在循环中，获取各个站点的PM2.5最大值。
最后，输出map对象，可以看到字符串中各个字符的个数，代码如下所示：
package day05;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import org.junit.Test;
public class TestHashMap {
/**
* 统计各空气质量监测站点PM2.5的最高值
*/
@Test
public void test1() {
String pm25 = "农展馆=423,东四=378,丰台花园=406,天坛=322,海淀区万柳=398,"
+ "官园=406,通州=366,昌平镇=248,怀柔镇=306,定陵=231,前门=422,"
+ "永乐店=368,古城=268,昌平镇=423,怀柔镇=267,定陵=377,前门=299,"
+ "永乐店=285,秀水街=277,农展馆=348,东四=356,丰台花园=179,天坛=277,"
+ "海淀区万柳=270,官园=268,通州=315";
String[] arr = pm25.split("[,=]");
#cold_bold Map<String, Integer> map = new HashMap<String, Integer>();
#cold_bold for (int i = 0; i < arr.length; i += 2) {
#cold_bold if (!map.containsKey(arr[i])
#cold_bold || Integer.parseInt(arr[i + 1]) > map.get(arr[i])) {
#cold_bold map.put(arr[i], Integer.parseInt(arr[i + 1]));
#cold_bold }
#cold_bold }
#cold_bold System.out.println(map);
}
}
1.4 完整代码
本案例的完整代码如下所示：
package day05;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import org.junit.Test;
public class TestHashMap {
/**
* 统计各空气质量监测站点PM2.5的最高值
*/
@Test
public void test1() {
String pm25 = "农展馆=423,东四=378,丰台花园=406,天坛=322,海淀区万柳=398,"
+ "官园=406,通州=366,昌平镇=248,怀柔镇=306,定陵=231,前门=422,"
+ "永乐店=368,古城=268,昌平镇=423,怀柔镇=267,定陵=377,前门=299,"
+ "永乐店=285,秀水街=277,农展馆=348,东四=356,丰台花园=179,天坛=277,"
+ "海淀区万柳=270,官园=268,通州=315";
Map<String, Integer> map = new HashMap<String, Integer>();
String[] arr = pm25.split("[,=]");
for (int i = 0; i < arr.length; i += 2) {
if (!map.containsKey(arr[i])
|| Integer.parseInt(arr[i + 1]) > map.get(arr[i])) {
map.put(arr[i], Integer.parseInt(arr[i + 1]));
}
}
System.out.println(map);
}
}
2 hashCode方法的重写
2.1 问题
测试hashCode的作用，详细要求如下：
1） 将没有重写hashCode方法的Emp类存入Map进行中，进行测试。
2） 将重写了hashCode方法的Emp类存入Map进行中，再次进行测试，并说明两次不同结果的原因。
2.2 步骤
实现此案例需要按照如下步骤进行。
步骤一：新建Emp类
在JavaSE工程的day05包下，新建Emp类，该类的代码如下所示：
package day05;
public class Emp {
private String name;
private int age;
private String gender;
private double salary;
public Emp(String name, int age, String gender, double salary) {
this.name = name;
this.age = age;
this.gender = gender;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
@Override
public String toString() {
return "Emp [name=" + name + ", age=" + age + ", gender=" + gender
+ ", salary=" + salary + "]";
}
}
步骤二：在Emp类中重写equals方法
在Emp类中重写equals方法，使得两个Emp引用变量的name值相等，则两个Emp对象的equals方法返回true，代码如下所示：
package day05;
public class Emp {
private String name;
private int age;
private String gender;
private double salary;
public Emp(String name, int age, String gender, double salary) {
this.name = name;
this.age = age;
this.gender = gender;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
@Override
public String toString() {
return "Emp [name=" + name + ", age=" + age + ", gender=" + gender
+ ", salary=" + salary + "]";
}
#cold_bold @Override
#cold_bold public boolean equals(Object obj) {
#cold_bold if (this == obj)
#cold_bold return true;
#cold_bold if (obj == null)
#cold_bold return false;
#cold_bold if (getClass() != obj.getClass())
#cold_bold return false;
#cold_bold Emp other = (Emp) obj;
#cold_bold if (name == null) {
#cold_bold if (other.name != null)
#cold_bold return false;
#cold_bold } else if (!name.equals(other.name))
#cold_bold return false;
#cold_bold return true;
#cold_bold }
}
步骤三： 使用Map存储Emp类的对象
在JavaSE工程的day05包下新建类TestMap，在该类中，首先，新建testPut方法，在方法中将Emp对象作为key、名字作为value存储Map对象employees中；然后，新建testGet方法，该方法用于从Map中根据key获取value；最后，新建testContainsKey方法，该方法用于判断Map对象employees中是否包含某个Emp对象，代码如下所示：
package day05;
import java.util.HashMap;
import java.util.Map;
import org.junit.Before;
import org.junit.Test;
public class TestMap {
private Map<Emp,String> employees = new HashMap<Emp,String>();
@Before
public void testPut(){
//向map中添加元素
employees.put(new Emp("张三",25,"男",5000),"张三");
employees.put(new Emp("李四",21,"女",6000),"李四");
}
@Test
public void testGet(){
Emp zhangsan=new Emp("张三",25,"男",5000);
String name = employees.get(zhangsan);
System.out.println(name);
}
@Test
public void testContainsKey(){
Emp zhangsan=new Emp("张三",25,"男",5000);
boolean has = employees.containsKey(zhangsan);
System.out.println("是否有员工李四:" + has);
}
}
在上述代码中的testPut方法之前，使用了@Before注解，在JUnit中该注解表示每个测试方法（@Test修饰的方法）执行时都会执行一次有其修饰方法，用于数据的初始化。
运行TestMap类，控制台输出结果如下：
null 是否有员工李四:false
从输出结果可以看出，并没有从map对象employees中，获取到名字为“张三”的Emp对象。这是因为，比较两个对象的时候，首先根据他们的hashCode去hash表中找它的对象,当两个对象的hashCode相同,也就是说这两个对象放在Hash表中的同一个key上,则他们一定在这个key上的链表上。那么，此时就只能根据Object的equals方法来比较这个对象是否相等。当两个对象的hashCode不同时，则这两个对象一定不能相等。
步骤四：在Emp类中重写hashCode方法
在Emp类中重写hashCode方法。重写hashCode方法是需注意两点：其一、与equals方法的一致性，即equals比较返回true的两个对象其hashCode方法返回值应该相同；其二、hashCode返回的数值应符合hash算法的要求，试想如果有很多对象的hashCode方法返回值都相同，则会大大降低hash表的效率，一般情况下可以使用IDE（如Eclipse）提供的工具自动生成hashCode方法。代码如下所示：
package day05;
public class Emp {
private String name;
private int age;
private String gender;
private double salary;
public Emp(String name, int age, String gender, double salary) {
this.name = name;
this.age = age;
this.gender = gender;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
@Override
public String toString() {
return "Emp [name=" + name + ", age=" + age + ", gender=" + gender
+ ", salary=" + salary + "]";
}
#cold_bold @Override
#cold_bold public int hashCode() {
#cold_bold final int prime = 31;
#cold_bold int result = 1;
#cold_bold result = prime * result + ((name == null) ? 0 : name.hashCode());
#cold_bold return result;
#cold_bold }
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Emp other = (Emp) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
步骤五： 运行
运行TestMap类，控制台输出结果如下：
是否有员工李四:true 张三
从输出结果可以看出，Emp重写hashCode方法后，可以在Map对象employees中查找到名称“张三”的对象了。
2.3 完整代码
本案例中，类Emp的完整代码如下所示：
package day05;
public class Emp {
private String name;
private int age;
private String gender;
private double salary;
public Emp(String name, int age, String gender, double salary) {
this.name = name;
this.age = age;
this.gender = gender;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
@Override
public String toString() {
return "Emp [name=" + name + ", age=" + age + ", gender=" + gender
+ ", salary=" + salary + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
}
类TestMap的完整代码如下所示：
package day05;
import java.util.HashMap;
import java.util.Map;
import org.junit.Before;
import org.junit.Test;
public class TestMap {
private Map<Emp,String> employees = new HashMap<Emp,String>();
@Before
public void testPut(){
//向map中添加元素
employees.put( new Emp("张三",25,"男",5000),"张三");
employees.put(new Emp("李四",21,"女",6000),"李四");
}
@Test
public void testGet(){
Emp zhangsan=new Emp("张三",25,"男",5000);
String name = employees.get(zhangsan);
System.out.println(name);
}
@Test
public void testContainsKey(){
Emp zhangsan=new Emp("张三",25,"男",5000);
boolean has = employees.containsKey(zhangsan);
System.out.println("是否有员工李四:" + has);
}
}
3 PM2.5监控程序——遍历各点PM2.5最大值
3.1 问题
在“PM2.5监控程序——统计各点PM2.5最大值”案例的基础上，分别使用迭代Key的方式和迭代Entry的方式遍历集合map。
3.2 步骤
实现此案例需要按照如下步骤进行。
步骤一：构建测试方法
在TestHashMap类中添加测试方法test2，使test2中的代码和test1中的代码保持一致，代码如下所示：
package day05;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import org.junit.Test;
public class TestHashMap {
#cold_bold /**
#cold_bold * 使用迭代key的方式遍历map集合
#cold_bold */
#cold_bold @Test
#cold_bold public void test2() {
#cold_bold String pm25 = "农展馆=423,东四=378,丰台花园=406,天坛=322,海淀区万柳=398,"
#cold_bold + "官园=406,通州=366,昌平镇=248,怀柔镇=306,定陵=231,前门=422,"
#cold_bold + "永乐店=368,古城=268,昌平镇=423,怀柔镇=267,定陵=377,前门=299,"
#cold_bold + "永乐店=285,秀水街=277,农展馆=348,东四=356,丰台花园=179,天坛=277,"
#cold_bold + "海淀区万柳=270,官园=268,通州=315";
#cold_bold Map<String, Integer> map = new HashMap<String, Integer>();
#cold_bold String[] arr = pm25.split("[,=]");
#cold_bold for (int i = 0; i < arr.length; i += 2) {
#cold_bold if (!map.containsKey(arr[i])
#cold_bold || Integer.parseInt(arr[i + 1]) > map.get(arr[i])) {
#cold_bold map.put(arr[i], Integer.parseInt(arr[i + 1]));
#cold_bold }
#cold_bold }
#cold_boldSystem.out.println(map);
#cold_bold }
}
步骤二：使用迭代key的方式遍历集合map
使用迭代key的方式遍历集合map，代码如下所示：
package day05;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import org.junit.Test;
public class TestHashMap {
/**
* 使用迭代key的方式遍历map集合
*/
@Test
public void test2() {
String pm25 = "农展馆=423,东四=378,丰台花园=406,天坛=322,海淀区万柳=398,"
+ "官园=406,通州=366,昌平镇=248,怀柔镇=306,定陵=231,前门=422,"
+ "永乐店=368,古城=268,昌平镇=423,怀柔镇=267,定陵=377,前门=299,"
+ "永乐店=285,秀水街=277,农展馆=348,东四=356,丰台花园=179,天坛=277,"
+ "海淀区万柳=270,官园=268,通州=315";
Map<String, Integer> map = new HashMap<String, Integer>();
String[] arr = pm25.split("[,=]");
for (int i = 0; i < arr.length; i += 2) {
if (!map.containsKey(arr[i])
|| Integer.parseInt(arr[i + 1]) > map.get(arr[i])) {
map.put(arr[i], Integer.parseInt(arr[i + 1]));
}
}
System.out.println(map);
#cold_bold Set<String> keys = map.keySet();
#cold_bold for (String key : keys) {
#cold_bold System.out.println(key + ":" + map.get(key));
#cold_bold }
}
}
步骤三：构建测试方法
在TestHashMap类中添加测试方法test3，使test3中的代码和test1中的代码保持一致，代码如下所示：
package day05;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import org.junit.Test;
public class TestHashMap {
/**
* 使用迭代key的方式遍历map集合
*/
@Test
public void test2() {
String pm25 = "农展馆=423,东四=378,丰台花园=406,天坛=322,海淀区万柳=398,"
+ "官园=406,通州=366,昌平镇=248,怀柔镇=306,定陵=231,前门=422,"
+ "永乐店=368,古城=268,昌平镇=423,怀柔镇=267,定陵=377,前门=299,"
+ "永乐店=285,秀水街=277,农展馆=348,东四=356,丰台花园=179,天坛=277,"
+ "海淀区万柳=270,官园=268,通州=315";
Map<String, Integer> map = new HashMap<String, Integer>();
String[] arr = pm25.split("[,=]");
for (int i = 0; i < arr.length; i += 2) {
if (!map.containsKey(arr[i])
|| Integer.parseInt(arr[i + 1]) > map.get(arr[i])) {
map.put(arr[i], Integer.parseInt(arr[i + 1]));
}
}
Set<String> keys = map.keySet();
for (String key : keys) {
System.out.println(key + ":" + map.get(key));
}
}
#cold_bold /**
#cold_bold * 使用迭代Entry的方式遍历map集合
#cold_bold */
#cold_bold @Test
#cold_bold public void test3() {
#cold_bold String pm25 = "农展馆=423,东四=378,丰台花园=406,天坛=322,海淀区万柳=398,"
#cold_bold + "官园=406,通州=366,昌平镇=248,怀柔镇=306,定陵=231,前门=422,"
#cold_bold + "永乐店=368,古城=268,昌平镇=423,怀柔镇=267,定陵=377,前门=299,"
#cold_bold + "永乐店=285,秀水街=277,农展馆=348,东四=356,丰台花园=179,天坛=277,"
#cold_bold + "海淀区万柳=270,官园=268,通州=315";
#cold_bold Map<String, Integer> map = new HashMap<String, Integer>();
#cold_bold String[] arr = pm25.split("[,=]");
#cold_bold for (int i = 0; i < arr.length; i += 2) {
#cold_bold if (!map.containsKey(arr[i])
#cold_bold || Integer.parseInt(arr[i + 1]) > map.get(arr[i])) {
#cold_bold map.put(arr[i], Integer.parseInt(arr[i + 1]));
#cold_bold }
#cold_bold }
#cold_bold System.out.println(map);
#cold_bold }
}
步骤四：使用迭代Entry的方式迭代集合map
使用迭代Entry的方式迭代集合map，代码如下所示：
package day05;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import org.junit.Test;
public class TestHashMap {
/**
* 使用迭代key的方式遍历map集合
*/
@Test
public void test2() {
String pm25 = "农展馆=423,东四=378,丰台花园=406,天坛=322,海淀区万柳=398,"
+ "官园=406,通州=366,昌平镇=248,怀柔镇=306,定陵=231,前门=422,"
+ "永乐店=368,古城=268,昌平镇=423,怀柔镇=267,定陵=377,前门=299,"
+ "永乐店=285,秀水街=277,农展馆=348,东四=356,丰台花园=179,天坛=277,"
+ "海淀区万柳=270,官园=268,通州=315";
Map<String, Integer> map = new HashMap<String, Integer>();
String[] arr = pm25.split("[,=]");
for (int i = 0; i < arr.length; i += 2) {
if (!map.containsKey(arr[i])
|| Integer.parseInt(arr[i + 1]) > map.get(arr[i])) {
map.put(arr[i], Integer.parseInt(arr[i + 1]));
}
}
Set<String> keys = map.keySet();
for (String key : keys) {
System.out.println(key + ":" + map.get(key));
}
}
/**
* 使用迭代Entry的方式遍历map集合
*/
@Test
public void test3() {
String pm25 = "农展馆=423,东四=378,丰台花园=406,天坛=322,海淀区万柳=398,"
+ "官园=406,通州=366,昌平镇=248,怀柔镇=306,定陵=231,前门=422,"
+ "永乐店=368,古城=268,昌平镇=423,怀柔镇=267,定陵=377,前门=299,"
+ "永乐店=285,秀水街=277,农展馆=348,东四=356,丰台花园=179,天坛=277,"
+ "海淀区万柳=270,官园=268,通州=315";
Map<String, Integer> map = new HashMap<String, Integer>();
String[] arr = pm25.split("[,=]");
for (int i = 0; i < arr.length; i += 2) {
if (!map.containsKey(arr[i])
|| Integer.parseInt(arr[i + 1]) > map.get(arr[i])) {
map.put(arr[i], Integer.parseInt(arr[i + 1]));
}
}
System.out.println(map);
#cold_bold Set<Map.Entry<String, Integer>> entrys = map.entrySet();
#cold_bold for (Map.Entry<String, Integer> entry : entrys) {
#cold_bold System.out.println(entry.getKey() + ":" + entry.getValue());
#cold_bold }
}
}
3.3 完整代码
本案例的完整代码如下所示：
package day05;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import org.junit.Test;
public class TestHashMap {
//...（之前案例的代码，略）
/**
* 使用迭代key的方式遍历map集合
*/
@Test
public void test2() {
String pm25 = "农展馆=423,东四=378,丰台花园=406,天坛=322,海淀区万柳=398,"
+ "官园=406,通州=366,昌平镇=248,怀柔镇=306,定陵=231,前门=422,"
+ "永乐店=368,古城=268,昌平镇=423,怀柔镇=267,定陵=377,前门=299,"
+ "永乐店=285,秀水街=277,农展馆=348,东四=356,丰台花园=179,天坛=277,"
+ "海淀区万柳=270,官园=268,通州=315";
Map<String, Integer> map = new HashMap<String, Integer>();
String[] arr = pm25.split("[,=]");
for (int i = 0; i < arr.length; i += 2) {
if (!map.containsKey(arr[i])
|| Integer.parseInt(arr[i + 1]) > map.get(arr[i])) {
map.put(arr[i], Integer.parseInt(arr[i + 1]));
}
}
Set<String> keys = map.keySet();
for (String key : keys) {
System.out.println(key + ":" + map.get(key));
}
}
/**
* 使用迭代Entry的方式遍历map集合
*/
@Test
public void test3() {
String pm25 = "农展馆=423,东四=378,丰台花园=406,天坛=322,海淀区万柳=398,"
+ "官园=406,通州=366,昌平镇=248,怀柔镇=306,定陵=231,前门=422,"
+ "永乐店=368,古城=268,昌平镇=423,怀柔镇=267,定陵=377,前门=299,"
+ "永乐店=285,秀水街=277,农展馆=348,东四=356,丰台花园=179,天坛=277,"
+ "海淀区万柳=270,官园=268,通州=315";
Map<String, Integer> map = new HashMap<String, Integer>();
String[] arr = pm25.split("[,=]");
for (int i = 0; i < arr.length; i += 2) {
if (!map.containsKey(arr[i])
|| Integer.parseInt(arr[i + 1]) > map.get(arr[i])) {
map.put(arr[i], Integer.parseInt(arr[i + 1]));
}
}
Set<Map.Entry<String, Integer>> entrys = map.entrySet();
for (Map.Entry<String, Integer> entry : entrys) {
System.out.println(entry.getKey() + ":" + entry.getValue());
}
}
}
4 PM2.5监控程序—统计并遍历各点PM2.5最大值（要求顺序）
4.1 问题
在“PM2.5监控程序——遍历各点PM2.5最大值”练习的基础上，按照放入map中的站点名的顺序遍历出来。
4.2 步骤
实现此案例需要按照如下步骤进行。
步骤一：将HashMap改成LinkedHashMap
首先，构建测试方法test4、test5；然后，复制test2的代码到test4中，复制test3的代码到test5中； 最后， 将test4、test5中构建map对象的实现类改成LinkedHashMap，代码如下所示：
package day05;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import org.junit.Test;
public class TestHashMap {
/**
* 按照key放入的顺序遍历集合
*/
@Test
public void test4() {
String pm25 = "农展馆=423,东四=378,丰台花园=406,天坛=322,海淀区万柳=398,"
+ "官园=406,通州=366,昌平镇=248,怀柔镇=306,定陵=231,前门=422,"
+ "永乐店=368,古城=268,昌平镇=423,怀柔镇=267,定陵=377,前门=299,"
+ "永乐店=285,秀水街=277,农展馆=348,东四=356,丰台花园=179,天坛=277,"
+ "海淀区万柳=270,官园=268,通州=315";
Map<String, Integer> map = new LinkedHashMap<String, Integer>();
String[] arr = pm25.split("[,=]");
for (int i = 0; i < arr.length; i += 2) {
if (!map.containsKey(arr[i])
|| Integer.parseInt(arr[i + 1]) > map.get(arr[i])) {
map.put(arr[i], Integer.parseInt(arr[i + 1]));
}
}
Set<String> keys = map.keySet();
for (String key : keys) {
System.out.println(key + ":" + map.get(key));
}
}
/**
* 按照key放入的顺序遍历集合
*/
@Test
public void test5() {
String pm25 = "农展馆=423,东四=378,丰台花园=406,天坛=322,海淀区万柳=398,"
+ "官园=406,通州=366,昌平镇=248,怀柔镇=306,定陵=231,前门=422,"
+ "永乐店=368,古城=268,昌平镇=423,怀柔镇=267,定陵=377,前门=299,"
+ "永乐店=285,秀水街=277,农展馆=348,东四=356,丰台花园=179,天坛=277,"
+ "海淀区万柳=270,官园=268,通州=315";
Map<String, Integer> map = new LinkedHashMap<String, Integer>();
String[] arr = pm25.split("[,=]");
for (int i = 0; i < arr.length; i += 2) {
if (!map.containsKey(arr[i])
|| Integer.parseInt(arr[i + 1]) > map.get(arr[i])) {
map.put(arr[i], Integer.parseInt(arr[i + 1]));
}
}
Set<Map.Entry<String, Integer>> entrys = map.entrySet();
for (Map.Entry<String, Integer> entry : entrys) {
System.out.println(entry.getKey() + ":" + entry.getValue());
}
}
}
上述代码中的LinkedHashMap是Map 接口的哈希表和链表实现，具有可预知的迭代顺序。此实现与 HashMap 的不同之处在于，LinkedHashMap维护着一个双向循环链表。此链表定义了迭代顺序，该迭代顺序通常就是存放元素的顺序。
4.3 完整代码
本案例的完整代码如下所示：
package day05;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import org.junit.Test;
public class TestHashMap {
//...（之前案例的代码，略）
/**
* 按照key放入的顺序遍历集合
*/
@Test
public void test4() {
String pm25 = "农展馆=423,东四=378,丰台花园=406,天坛=322,海淀区万柳=398,"
+ "官园=406,通州=366,昌平镇=248,怀柔镇=306,定陵=231,前门=422,"
+ "永乐店=368,古城=268,昌平镇=423,怀柔镇=267,定陵=377,前门=299,"
+ "永乐店=285,秀水街=277,农展馆=348,东四=356,丰台花园=179,天坛=277,"
+ "海淀区万柳=270,官园=268,通州=315";
Map<String, Integer> map = new LinkedHashMap<String, Integer>();
String[] arr = pm25.split("[,=]");
for (int i = 0; i < arr.length; i += 2) {
if (!map.containsKey(arr[i])
|| Integer.parseInt(arr[i + 1]) > map.get(arr[i])) {
map.put(arr[i], Integer.parseInt(arr[i + 1]));
}
}
Set<String> keys = map.keySet();
for (String key : keys) {
System.out.println(key + ":" + map.get(key));
}
}
/**
* 按照key放入的顺序遍历集合
*/
@Test
public void test5() {
String pm25 = "农展馆=423,东四=378,丰台花园=406,天坛=322,海淀区万柳=398,"
+ "官园=406,通州=366,昌平镇=248,怀柔镇=306,定陵=231,前门=422,"
+ "永乐店=368,古城=268,昌平镇=423,怀柔镇=267,定陵=377,前门=299,"
+ "永乐店=285,秀水街=277,农展馆=348,东四=356,丰台花园=179,天坛=277,"
+ "海淀区万柳=270,官园=268,通州=315";
Map<String, Integer> map = new LinkedHashMap<String, Integer>();
String[] arr = pm25.split("[,=]");
for (int i = 0; i < arr.length; i += 2) {
if (!map.containsKey(arr[i])
|| Integer.parseInt(arr[i + 1]) > map.get(arr[i])) {
map.put(arr[i], Integer.parseInt(arr[i + 1]));
}
}
Set<Map.Entry<String, Integer>> entrys = map.entrySet();
for (Map.Entry<String, Integer> entry : entrys) {
System.out.println(entry.getKey() + ":" + entry.getValue());
}
}
}
5 查看一个文件的大小
5.1 问题
查看当前工程下demo文件夹下HelloWorld.txt文件的大小。
5.2 步骤
实现此案例需要按照如下步骤进行。
步骤一：新建类及测试方法
首先，新建类TestFile，并在该类中新建测试方法testLength，代码如下所示：
package day05;
import java.io.File;
import org.junit.Test;
public class TestFile {
@Test
public void testLength() {
}
}
步骤二：获取HelloWorld.txt文件大小
首先，使用File类构建表示当前工程下的demo文件夹下的HelloWorld.txt文件的对象file；然后，使用File类的length方法获取该文件的大小并输出，代码如下所示：
package day05;
import java.io.File;
import org.junit.Test;
public class TestFile {
@Test
public void testLength() {
#cold_bold File file = new File("demo" + File.separator + "HelloWorld.txt");
#cold_bold System.out.println(file + "占用字节量:" + file.length());
}
}
步骤三：运行
运行testLength方法，控制台输出结果如下所示：
demo\HelloWorld.txt占用字节量:0
如果当前工程下并不存在demo文件夹，那就更没有HelloWorld.txt文件的存在了，因此占用字节长度为0。现在，在当前工程下创建demo文件夹，然后，在该文件夹下创建文件HelloWorld.txt并将该文件内容改为“hello”，再次运行testLength方法，控制台输出结果如下所示：
demo\HelloWorld.txt占用字节量:5
5.3 完整代码
本案例的完整代码如下所示：
package day05;
import java.io.File;
import org.junit.Test;
public class TestFile {
@Test
public void testLength() {
File file = new File("demo" + File.separator + "HelloWorld.txt");
System.out.println(file + "占用字节量:" + file.length());
}
}
6 创建一个空文件
6.1 问题
在上一案例的基础上，在demo文件夹下创建文件Hello.txt。
6.2 步骤
实现此案例需要按照如下步骤进行。
步骤一：构建测试方法
首先，在TestFile类中新建测试方法testCreateNewFile，代码如下所示：
package day05;
import java.io.File;
import java.io.IOException;
import org.junit.Test;
public class TestFile {
#cold_bold @Test
#cold_bold public void testCreateNewFile() throws IOException {
#cold_bold
#cold_bold }
}
步骤二：创建文件
首先，使用File类构建表示当前工程下的demo文件夹下的Hello.txt文件的对象file；然后，使用File类的exists方法判断文件是否存在，如果不存在，使用File类的createNewFile方法创建该文件，代码如下所示：
package day05;
import java.io.File;
import java.io.IOException;
import org.junit.Test;
public class TestFile {
@Test
public void testCreateNewFile() throws IOException {
#cold_bold File file = new File("demo" + File.separator + "Hello.txt");
#cold_bold // 若不存在，就创建该文件
#cold_bold if (!file.exists()) {
#cold_bold file.createNewFile();
#cold_bold }
}
}
步骤三：运行
运行testCreateNewFile方法，会发现在当前工程的demo文件夹下多了一个文件Hello.txt。
6.3 完整代码
本案例中，类TestFile的完整代码如下所示：
package day05;
import java.io.File;
import java.io.IOException;
import org.junit.Test;
public class TestFile {
//...（之前案例的代码，略）
@Test
public void testCreateNewFile() throws IOException {
File file = new File("demo" + File.separator + "Hello.txt");
// 若不存在，就创建该文件
if (!file.exists()) {
file.createNewFile();
}
}
}
7 删除一个文件
7.1 问题
将上一案例中创建的Hello.txt文件删除。
7.2 步骤
实现此案例需要按照如下步骤进行。
步骤一：构建测试方法
首先，在TestFile类中新建测试方法testDeleteFile，代码如下所示：
package day05;
import java.io.File;
import org.junit.Test;
import java.io.IOException;
public class TestFile {
#cold_bold @Test
#cold_bold public void testDeleteFile() {
#cold_bold
#cold_bold }
}
步骤二：删除文件
首先，使用File类构建表示当前工程下的demo文件夹下的Hello.txt文件的对象file；然后，使用File类的delete方法删除该文件，代码如下所示：
package day05;
import java.io.File;
import java.io.IOException;
import org.junit.Test;
public class TestFile {
@Test
public void testDeleteFile() {
#cold_bold File file = new File("demo" + File.separator + "Hello.txt");
#cold_bold file.delete();
}
}
步骤三：运行
运行testDeleteFile方法，会发现在当前工程的demo文件夹Hello.txt文件已经不存在了。
7.3 完整代码
本案例中，类TestFile的完整代码如下所示：
package day05;
import java.io.File;
import java.io.IOException;
import org.junit.Test;
public class TestFile {
//...（之前案例的代码，略）
@Test
public void testDeleteFile() {
File file = new File("demo" + File.separator + "Hello.txt");
file.delete();
}
}
8 创建一个目录
8.1 问题
在当前工程下创建myDir目录。
8.2 步骤
实现此案例需要按照如下步骤进行。
步骤一：构建测试方法
首先，在TestFile类中新建测试方法testMkDir，代码如下所示：
package day05;
import java.io.File;
import java.io.IOException;
import org.junit.Test;
public class TestFile {
#cold_bold @Test
#cold_bold public void testMkDir() {
#cold_bold
#cold_bold }
}
步骤二：创建目录
首先，使用File类构建表示当前工程下的myDir目录的对象file；然后，使用File类的mkdir方法创建目录，代码如下所示：
package day05;
import java.io.File;
import java.io.IOException;
import org.junit.Test;
public class TestFile {
@Test
public void testMkDir() {
#cold_bold File dir = new File("myDir");
#cold_bold dir.mkdir();
}
}
步骤三：运行
运行testMkDir方法，会发现工程下多了一个myDir文件夹。
8.3 完整代码
本案例中，类TestFile的完整代码如下所示：
package day05;
import java.io.File;
import java.io.IOException;
import org.junit.Test;
public class TestFile {
//...（之前案例的代码，略）
@Test
public void testMkDir() {
File dir = new File("myDir");
dir.mkdir();
}
}
9 创建一个多级目录
9.1 问题
在当前工程下，创建a目录，然后在a目录下创建b目录，最后在b目录下创建c目录。
9.2 步骤
实现此案例需要按照如下步骤进行。
步骤一：构建测试方法
首先，在TestFile类中新建测试方法testMkDirs，代码如下所示：
package day05;
import java.io.File;
import java.io.IOException;
import org.junit.Test;
public class TestFile {
#cold_bold @Test
#cold_bold public void testMkDirs() {
#cold_bold
#cold_bold }
}
步骤二：创建多级目录
首先，使用File类构建表示当前工程下的多级目录a，b，c；然后，使用File类的mkdirs方法创建多级目录，代码如下所示：
package day05;
import java.io.File;
import java.io.IOException;
import org.junit.Test;
public class TestFile {
@Test
public void testMkDirs() {
#cold_bold File dir = new File("a" + File.separator + "b" + File.separator + "c");
#cold_bold dir.mkdirs();
}
}
步骤三：运行
运行testMkDirs方法，会发现工程下多了一个a文件夹，并且a文件夹下有b文件夹，b文件夹下有c文件夹。
9.3 完整代码
本案例中，类TestFile的完整代码如下所示：
package day05;
import java.io.File;
import java.io.IOException;
import org.junit.Test;
public class TestFile {
//...（之前案例的代码，略）
@Test
public void testMkDirs() {
File dir = new File("a" + File.separator + "b" + File.separator + "c");
dir.mkdirs();
}
}
10 删除一个目录
10.1 问题
删除一个空目录。
10.2 步骤
实现此案例需要按照如下步骤进行。
步骤一：构建测试方法
首先，在TestFile类中新建测试方法testDeleteDir，代码如下所示：
package day05;
import java.io.File;
import java.io.IOException;
import org.junit.Test;
public class TestFile {
#cold_bold @Test
#cold_bold public void testDeleteDir() {
#cold_bold
#cold_bold }
}
步骤二：删除目录
首先，使用File类构建表示当前工程下的demo目录的对象file；然后，使用File类的delete方法删除该目录，代码如下所示：
package day05;
import java.io.File;
import java.io.IOException;
import org.junit.Test;
public class TestFile {
@Test
public void testDeleteDir() {
#cold_bold File file = new File("demo");
#cold_bold file.delete();
}
}
步骤三：运行
运行testDeleteDir方法，会发现demo文件夹不存在了。此处注意：demo文件夹要为一个空目录。
10.3 完整代码
本案例的完整代码如下所示：
package day05;
import java.io.File;
import java.io.IOException;
import org.junit.Test;
public class TestFile {
//...（之前案例的代码，略）
@Test
public void testDeleteDir() {
File file = new File("demo");
file.delete();
}
}