javaSE（八）

1.HashSet

在父类AbstractCollection中重写了toString方法。

原理：

当HashSet使用add()方法存储对象的时候，先调用对象的hashCode()方法得到一个哈希值，然后在集合中查找是否有哈希值相同的对象，如果没有就直接存入集合，如果有就调用equals()方法进行比较，如果是true，就不存入，false就存入集合中。

自定义对象存入集合中如何去重？

自定义对象必须重写hashCode和equals方法。

hashCode：属性相同的对象返回值必须相同，属性值不同的对象返回值尽量不同。

equals：返回值是true就不存储，返回值是false再存储。

一般自动生成hashCode和toString方法。

主要需要重写：

@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Person other = (Person) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}

为什么prime给的值是31？

1.是质数，除了1只能被自己整除。

2.不大不小，太大会超过int取值范围，太小会容易被重复。

3.好算，2的五次方减一。

2.LinkedHashSet

底层是链表实现的，是Set集合中唯一一个能保证存取顺序一致的对象。同时因为是hashSet的子类，所以也是保证元素唯一的。

但是效率相比其他会略低一点。

3.TreeSet

TreeSet主要用于排序，按照规定的顺序进行排序，同时还能保证元素的唯一性。

javabean中需要实现comparable接口，重写compareTo方法。

返回值为0，只有一个元素，返回值为正数，输入输出顺序相同，返回值为负数，倒序输出。

compareTo返回结果产生影响的原因？

二叉树结构，左小右大。在存储的时候，正数是大于，在右边存储，从小取到大就是依次取出。0是等于，不存，所以只有一个。

负数是小于，存储的数越来越小，从小到大取就是倒序。

4.TreeSet的两种排序

TreeSet自然排序，依赖于javabean中的compareTo方法，首先javabean实现了compareable接口，所以需要重写compareTo方法，compareTo重写如下：

@Override
	public int compareTo(Person o) {
		int length = this.name.length() - o.name.length();// 姓名长度为主
		int num = length == 0 ? this.name.compareTo(o.name) : length;// 姓名为主
		return num == 0 ? this.age - o.age : num;// 年龄为主
	}

	// @Override
	// public int compareTo(Person o) {
	// int to = this.name.compareTo(o.name); // 姓名为主
	// return to == 0 ? this.age - o.age : to; // 年龄为主
	// }

	// @Override
	// public int compareTo(Person o) {
	// int num = this.age - o.age; //年龄为主
	// return num == 0 ? this.name.compareTo(o.name) : num; //姓名为主
	// }

分别是依照不同标准，多次使用三元运算符进行比较。

TreeSet比较器排序,实现按照字符串长度排序。

public class Demo3_TreeSet {

	public static void main(String[] args) {
		// demo1();
		// demo2();
		// demo3();
		TreeSet<String> treeSet = new TreeSet<>(new compareByLen());
		treeSet.add("aaaaa");
		treeSet.add("kfc");
		treeSet.add("cba");
		treeSet.add("nba");
		treeSet.add("z");
		System.out.println(treeSet);
	}

	public static void demo3() {
		TreeSet<Person> treeSet = new TreeSet<>();
		treeSet.add(new Person("aaaa", 15));
		treeSet.add(new Person("adid", 15));
		treeSet.add(new Person("aaaaa", 15));
		treeSet.add(new Person("aaaaaa", 25));
		treeSet.add(new Person("aaaaaa", 18));
		System.out.println(treeSet);
	}

	public static void demo2() {
		// 测试比较姓名和年龄
		TreeSet<Person> treeSet = new TreeSet<>();
		treeSet.add(new Person("张三", 12));
		treeSet.add(new Person("李四", 16));
		treeSet.add(new Person("王五", 16));
		treeSet.add(new Person("赵六", 15));
		treeSet.add(new Person("胡七", 17));
		System.out.println(treeSet);
	}

	public static void demo1() {
		TreeSet<String> treeSet = new TreeSet<>();
		treeSet.add("a");
		treeSet.add("a");
		treeSet.add("b");
		treeSet.add("c");
		treeSet.add("d");
		System.out.println(treeSet);
	}

}

class compareByLen implements Comparator<String> {
	@Override
	public int compare(String s1, String s2) {
		int num = s1.length() - s2.length();
		return num == 0 ? s1.compareTo(s2) : num;
	}

}

最下方的类实现了comparator接口，需要重写里面的两个方法，但是以为compareByLen是Object的子类，Object中已经有了equals方法，所以相当于重写过了一个，只用重写另一个。用comparator实现只需要在新建treeset的时候将实现comparator接口的子类传入就可以了。

TreeSet的自然排序和比较器排序，有比较器排序优先比较器排序。

5.Set在实际需求中的应用

一般要求中有去处重复就使用HashSet.

留下重复但是排序的就是用TreeSet，实现代码如下：

	public static void sort(List<String> list) {
		//1,创建TreeSet集合对象,因为String本身就具备比较功能,但是重复不会保留,所以我们用比较器
		TreeSet<String> ts = new TreeSet<>(new Comparator<String>() {

			@Override
			public int compare(String s1, String s2) {
				int num = s1.compareTo(s2);					//比较内容为主要条件
				return num == 0 ? 1 : num;					//保留重复
			}
		});

确保其相等的时候也不返回0即可

程序启动后, 可以从键盘输入接收多个整数, 直到输入quit时结束输入. 把所有输入的整数倒序排列打印.

案例代码：

public class Test6 {

	/**
	 * 程序启动后, 可以从键盘输入接收多个整数, 直到输入quit时结束输入. 把所有输入的整数倒序排列打印.
	 * 
	 * 1,创建Scanner对象,键盘录入
	 * 2,创建TreeSet集合对象,TreeSet集合中传入比较器
	 * 3,无限循环不断接收整数,遇到quit退出,因为退出是quit,所以键盘录入的时候应该都以字符串的形式录入
	 * 4,判断是quit就退出,不是将其转换为Integer,并添加到集合中
	 * 5,遍历TreeSet集合并打印每一个元素
	 */
	public static void main(String[] args) {
		//1,创建Scanner对象,键盘录入
		Scanner sc = new Scanner(System.in);
		//2,创建TreeSet集合对象,TreeSet集合中传入比较器
		TreeSet<Integer> ts = new TreeSet<>(new Comparator<Integer>() {

			@Override
			public int compare(Integer i1, Integer i2) {
				//int num = i2 - i1;					//自动拆箱
				int num = i2.compareTo(i1);
				return num == 0 ? 1 : num;
			}
		});
		//3,无限循环不断接收整数,遇到quit退出,因为退出是quit,所以键盘录入的时候应该都以字符串的形式录入
		while(true) {
			String line = sc.nextLine();				//将键盘录入的字符串存储在line中
			if("quit".equals(line)) {
				break;
			}
			//4,判断是quit就退出,不是将其转换为Integer,并添加到集合中
			Integer i = Integer.parseInt(line);
			ts.add(i);
		}
		
		// 5,遍历TreeSet集合并打印每一个元素
		for (Integer integer : ts) {
			System.out.println(integer);
		}
	}

}

需求：键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低输出到控制台。

javabean代码：

package com.heima.bean;

public class Student {
	private String name;
	private int math;
	private int chinese;
	private int english;
	private int num;

	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Student(String name, int math, int chinese, int english) {
		super();
		this.name = name;
		this.math = math;
		this.chinese = chinese;
		this.english = english;
		this.num = english + math + chinese;
	}

	public int getNum() {
		return num;
	}

	@Override
	public String toString() {
		return " [学生姓名为：" + name + ", 数学成绩为：" + math + ", 语文成绩为：" + chinese + ", 英语成绩为：" + english + ", 总成绩为：" + num
				+ "]";
	}

}

功能实现代码：

package com.heima.test;

import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;

import com.heima.bean.Student;

public class Test7 {
	/**
	 * * A:案例演示
	 * 需求：键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低输出到控制台。
	 * 
	 * 分析:
	 * 1,定义一个学生类
	 * 成员变量:姓名,语文成绩,数学成绩,英语成绩,总成绩
	 * 成员方法:空参,有参构造,有参构造的参数分别是姓名,语文成绩,数学成绩,英语成绩
	 * toString方法,在遍历集合中的Student对象打印对象引用的时候会显示属性值
	 * 2,键盘录入需要Scanner,创建键盘录入对象
	 * 3,创建TreeSet集合对象,在TreeSet的构造函数中传入比较器,按照总分比较
	 * 4,录入五个学生,所以以集合中的学生个数为判断条件,如果size是小于5就进行存储
	 * 5,将录入的字符串切割,用逗号切割,会返回一个字符串数组,将字符串数组中从二个元素转换成int数,
	 * 6,将转换后的结果封装成Student对象,将Student添加到TreeSet集合中
	 * 7,遍历TreeSet集合打印每一个Student对象
	 */
	@SuppressWarnings("resource")
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请按照如下格式(姓名,语文成绩,数学成绩,英语成绩)录入学生信息：");
		TreeSet<Student> set = new TreeSet<>(new Comparator<Student>() {

			@Override
			public int compare(Student s1, Student s2) {
				int a = s2.getNum() - s1.getNum();
				return a == 0 ? 1 : a;
			}
		});
		while (set.size() < 5) {
			String line = sc.nextLine();
			String[] split = line.split(",");
			int chinese = Integer.parseInt(split[1]);
			int math = Integer.parseInt(split[2]);
			int english = Integer.parseInt(split[3]);
			set.add(new Student(split[0], chinese, math, english));
		}
		for (Student student : set) {
			System.out.println(student);
		}
	}

}

6.Map类

特点：

1.map是将键映射到值的对象。

2.一个映射不能包含重复的键。

3.每个键最多只能映射到一个值。

Map和Collection接口有什么区别？

Map是双列的，Collection是单列的。（set底层是map，set相当于把value数字隐藏掉。）

Map的键唯一，Collection的子体系set是唯一的

Map集合的数据结构针对键有效，跟值无关。Collection集合的数据结构仅针对元素有效。

Map集合的功能概述

map的常用方法中，put如果以前的键没有值，返回的是null，如果以前的键有值，那么返回以前的值。

map集合的遍历

第一种是先取键后遍历

案例代码：

// Set<String> set = map.keySet();
		// Iterator<String> iterator = set.iterator();
		// while (iterator.hasNext()) {
		// String next = iterator.next();
		// Integer integer = map.get(next);
		// System.out.println(next + "=" + integer);
		// }
		System.out.println(map);

		for (String key : map.keySet()) {
			System.out.println(key + "=" + map.get(key));
		}

keySet取出所有的键放在Set中，然后通过迭代器或者foreach遍历每个键，再取出对应的值。

第二种是取出键值对，依次遍历

案例代码：

	for (Entry<String, Integer> entry : map.entrySet()) {
			System.out.println(entry.getKey() + "=" + entry.getValue());
		}
	}

	public static void demo1(HashMap<String, Integer> map) {
		Set<Entry<String, Integer>> entrySet = map.entrySet();
		Iterator<Entry<String, Integer>> iterator = entrySet.iterator();
		while (iterator.hasNext()) {
			Entry<String, Integer> next = iterator.next();
			System.out.println(next.getKey() + "=" + next.getValue());
		}

先调用entrySet()取出键值对，再通过方法取出键值对中的键或者值

7.LinkedHashMap

因为是list所以有序。

8.TreeMap

不使用比较方法，直接输出，会报如下错误：

Exception in thread "main" java.lang.ClassCastException: com.heima.bean.Student cannot be cast to java.lang.Comparable

也是两种比较方法。

一个是javabean实现比较接口，一个是构造时候传入比较器

9.嵌套HashMap

案例代码如下：

public static void main(String[] args) {
		HashMap<Student, String> c1 = new HashMap<>();
		c1.put(new Student("张三", 18), "北京");
		c1.put(new Student("李四", 19), "上海");
		c1.put(new Student("王五", 20), "广州");
		c1.put(new Student("赵六", 21), "深圳");
		HashMap<Student, String> c2 = new HashMap<>();
		c2.put(new Student("张三子", 31), "北京");
		c2.put(new Student("李四儿", 41), "上海");
		c2.put(new Student("王五环", 51), "广州");
		c2.put(new Student("赵六六", 61), "深圳");
		HashMap<HashMap<Student, String>, String> hm = new HashMap<>();
		hm.put(c1, "少年组");
		hm.put(c2, "老年组");
		for (HashMap<Student, String> group : hm.keySet()) {
			String name = hm.get(group);
			for (Student student : group.keySet()) {
				String place = group.get(student);
				System.out.println("该学生的姓名为：" + student.getName() + "，年龄为：" + student.getAge() + "，坐标在：" + place + "，是"
						+ name + "的成员。");
			}
		}

10.Hashtable

和Vector命运一样，在1.2基本被HashMap抛弃。但是可以发现，Hashtable的命名都不规范，因为JDK1.0还没规定，直到JDK1.2才开始进行命名规范。

相同点：底层都是哈希算法，都是双列集合

不同点：

1.Hashtable在JDK1.0出现，线程安全效率低。HashMap在JDK1.2出现，线程不安全但是效率高。

2.Hashtable不能存储null键或者null值。HashMap可以存储null键或者null值。

当hashtable存储null的时候，会报错：

Exception in thread "main" java.lang.NullPointerException

11.Collections工具类

public static <T> void sort(List<T> list)
       public static <T> int binarySearch(List<?> list,T key)
       public static <T> T max(Collection<?> coll)
       public static void reverse(List<?> list)
       public static void shuffle(List<?> list)

排序，二分法查找，最大值，反转序列，打乱顺序。

在二分法查找的时候，如果没有，返回的是如果插入会在的位置的负数再减一。例如在acde中查找b，如果有b，就在1位置插入，负数一下再减一，就是负二。所以返回值是负二。

12.斗地主发牌

案例代码：


public class Test3 {

	/**
	 * * A:案例演示
	 * 模拟斗地主洗牌和发牌并对牌进行排序的代码实现
	 * 
	 *  分析:
	 * 1,买一副扑克,其实就是自己创建一个集合对象,将扑克牌存储进去
	 * 2,洗牌
	 * 3,发牌
	 * 4,看牌
	 */
	public static void main(String[] args) {
		//1,买一副扑克,其实就是自己创建一个集合对象,将扑克牌存储进去
		String[] num = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
		String[] color = {"红桃","黑桃","方片","梅花"};
		HashMap<Integer, String> hm = new HashMap<>();					//存储索引和扑克牌
		ArrayList<Integer> list = new ArrayList<>();					//存储索引
		int index = 0;
		
		//拼接扑克牌并索引和扑克牌存储在hm中
		for(String s1 : num) {											//获取数字
			for(String s2 : color) {									//获取颜色
				hm.put(index, s2.concat(s1));
				list.add(index);										//将索引0到51添加到list集合中
				index++;
			}
		}
		//将小王添加到双列集合中
		hm.put(index, "小王");
		list.add(index);												//将52索引添加到集合中
		index++;
		hm.put(index, "大王");
		list.add(index);												//将52索引添加到集合中
		
		//2,洗牌
		Collections.shuffle(list);
		//3,发牌
		TreeSet<Integer> gaojin = new TreeSet<>();
		TreeSet<Integer> longwu = new TreeSet<>();
		TreeSet<Integer> me = new TreeSet<>();
		TreeSet<Integer> dipai = new TreeSet<>();
		
		for(int i = 0; i < list.size(); i++) {
			if(i >= list.size() - 3) {
				dipai.add(list.get(i));							//将三张底牌存储在底牌集合中
			}else if(i % 3 == 0) {
				gaojin.add(list.get(i));
			}else if(i % 3 == 1) {
				longwu.add(list.get(i));
			}else {
				me.add(list.get(i));
			}
		}
		
		//看牌
		lookPoker(hm, gaojin, "高进");
		lookPoker(hm, longwu, "龙五");
		lookPoker(hm, me, "冯佳");
		lookPoker(hm, dipai, "底牌");
	}
	/*
	 * 看牌
	 * 1,返回值类型void
	 * 2,参数列表HashMap,TreeSet,String name
	 */
	public static void lookPoker(HashMap<Integer, String> hm,TreeSet<Integer> ts ,String name) {
		System.out.print(name + "的牌是:");
		for(Integer i : ts) {						//i代表双列集合中的每一个键
			System.out.print(hm.get(i) + " ");
		}
		System.out.println();
	}
}

建立索引，将索引的顺序打乱，发至每个人手中，再依照每个人手中的索引取到对应的牌。

13.泛型固定下边界

？ extend E 泛型固定上边界

泛型固定上边界用于子类进入父类，父类引用指向子类对象。更多的是放进去操作。

？ super E 泛型固定下边界

泛型固定下边界用于子类使用父类的比较器等，依旧是父类引用指向子类对象。更多的是取出来操作。

案例代码：

	public static void demo2() {
		TreeSet<Student> treeSet = new TreeSet<>(new CompareByAge());
		treeSet.add(new Student("张三", 19));
		treeSet.add(new Student("李四", 20));
		TreeSet<BaseStudent> treeSet2 = new TreeSet<>(new CompareByAge());
		treeSet2.add(new BaseStudent("王五", 27));
		treeSet2.add(new BaseStudent("赵六", 22));
		System.out.println(treeSet2);
	}

	public static void demo1() {
		// 泛型固定上边界，BaseStudent是Student的子类，上边界为Student
		ArrayList<Student> list = new ArrayList<>();
		list.add(new Student("张三", 17));
		list.add(new Student("李四", 18));
		ArrayList<BaseStudent> list2 = new ArrayList<>();
		list2.add(new BaseStudent("王五", 19));
		list2.add(new BaseStudent("赵六", 20));
		list.addAll(list2);
		System.out.println(list);
	}

14.异常及JVM默认处理方式

throwable只有两个子类，Error和Exception。error比exception严重得多。

Java中的异常被分为两大类：编译时异常和运行时异常。

所有的RuntimeException类及其子类的实例被称为运行时异常，其他的异常就是编译时异常

正确的查找异常方式：APi中查找异常，在控制台中由下向上依次查找。

15.try...catch...finally

try：检测异常

catch：捕获异常

finally：释放资源

try里面是进行检测，出现问题，产生了一个对象，该对象很明显数据类型无法捕获，就被try监测到，假设该对象是ArithmeticException，catch本质上就是方法，传入异常时ArithmeticException a = new ArithmeticException，接着执行语句，没传入参数，catch方法里面的语句就不执行。

JDK7中如何处理多个异常？

中间加 | 即可

异常处理的信息

getMessage()

获取异常信息，返回字符串。

toString()

获取异常类名和异常信息，返回字符串。

printStackTrace() （一般默认是这个）

获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。

throws和throw的区别

throws

用在方法声明后面，跟的是异常类名

可以跟多个异常类名，用逗号隔开

表示抛出异常，由该方法的调用者来处理

throw

用在方法体内，跟的是异常对象名

只能抛出一个异常对象名

表示抛出异常，由方法体内的语句处理

案例代码：

public void setAge(int age) throws AgeOutOfBoundsException {
		if(age >0 && age <= 150) {
			this.age = age;
		}else {
			//Exception e = new Exception("年龄非法");
			//throw e;
			throw new AgeOutOfBoundsException("年龄非法");
		}
	}

16.finally类

finally的特点

被finally控制的语句体一定会执行

特殊情况：在执行到finally之前jvm退出了(比如System.exit(0))

finally的作用

用于释放资源，在IO流操作和数据库操作中会见到

finally关键字的特点及作用

return语句相当于是方法的最后一口气,那么在他将死之前会看一看有没有finally帮其完成遗愿,如果有就将finally执行后在彻底返回

案例代码：

public static void main(String[] args) {
		try {
			System.out.println(10/0);
		} catch (Exception e) {
			System.out.println("除数为零了");
			System.exit(0);								//退出jvm虚拟机
			return;
		} finally {
			System.out.println("看看我执行了吗");
		}
	}

}

面试题：

final,finally和finalize的区别？

final修饰的类不能被继承

修饰的方法不能被重写

修饰的变量不能被赋值

finally是try语句中的一个语句体，不能被单独使用，主要是用来释放资源。

finalize：当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。

有return，finally里面的方法还会执行吗？在return前还是后？

案例代码：

class Demo {
	public int method() {
		int x = 10;
		try {
			x = 20;
			System.out.println(1/0);
			return x;
		} catch (Exception e) {
			x = 30;
			return x;
		} finally {
			x = 40;
			//return x;					千万不要在finally里面写返回语句,因为finally的作用是为了释放资源,是肯定会执行的
										//如果在这里面写返回语句,那么try和catch的结果都会被改变,所以这么写就是犯罪
		}
	}
}

输出30.很明显，代码是会执行的，在return前，准确来说，在中间。x=30，此时建立return通道，将x=30打包好，准备返回，检查了一下finally里面的语句，那么x就等于40了，但是此时30已结在通道里了，只能发送。

17.自定义异常

案例代码：

public class Demo1_Exception {

	public static void main(String[] args) throws Exception {
		Person p = new Person();
		p.setAge(-17);
	}

}

class Person {
	private String name;
	private int age;

	public Person() {
		super();

	}

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

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) throws AgeOutOfBoundsException {
		if (age > 0 && age <= 150) {
			this.age = age;
		} else {
			// Exception e = new Exception("年龄非法");
			// throw e;
			throw new AgeOutOfBoundsException("年龄非法");
		}
	}

}

自定义的AgeOutOfBoundsException异常：

class AgeOutOfBoundsException extends Exception {

	public AgeOutOfBoundsException() {
		super();
		// TODO Auto-generated constructor stub
	}

	public AgeOutOfBoundsException(String message) {
		super(message);
		// TODO Auto-generated constructor stub
	}

}

异常的注意事项：

子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类。(父亲坏了,儿子不能比父亲更坏)

如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集,子类不能抛出父类没有的异常

如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws

如何使用异常处理

原则:如果该功能内部可以将问题处理,用try,如果处理不了,交由调用者处理,这是用throws

区别:

后续程序需要继续运行就try

后续程序不需要继续运行就throws

如果JDK没有提供对应的异常，需要自定义异常。

try...catch案例代码：

public class Test1 {
	/**
	 * 键盘录入一个int类型的整数,对其求二进制表现形式
	 * 如果录入的整数过大,给予提示,录入的整数过大请重新录入一个整数BigInteger
	 * 如果录入的是小数,给予提示,录入的是小数,请重新录入一个整数
	 * 如果录入的是其他字符,给予提示,录入的是非法字符,请重新录入一个整数
	 * 
	 * 分析:
	 * 1,创建键盘录入对象
	 * 2,将键盘录入的结果存储在String类型的字符串中,存储int类型中如果有不符合条件的直接报错,无法进行后续判断
	 * 3,键盘录入的结果转换成int类型的数据,是正确的还是错误的
	 * 4,正确的直接转换
	 * 5,错误的要进行对应判断
	 */
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入想要转换的整数：");
		while (true) {
			String nextLine = sc.nextLine();
			try {
				int num = Integer.parseInt(nextLine);
				System.out.println(Integer.toBinaryString(num));
				break;
			} catch (Exception e) {
				try {
					new BigInteger(nextLine);
					System.out.println("您输入的整数太大了，请重新输入：");
				} catch (Exception e1) {
					try {
						new BigDecimal(nextLine);
						System.out.println("您输入的是小数，请重新输入：");
					} catch (Exception e2) {
						System.out.println("您输入的是非法字符，请重新输入：");
					}
				}
			}
		}
	}

}

18.File类

构造方法：

File(String pathname)：根据一个路径得到File对象

File(String parent, String child):根据一个目录和一个子文件/目录得到File对象

File(File parent, String child):根据一个父File对象和一个子文件/目录得到File对象

创建功能

public boolean createNewFile():创建文件如果存在这样的文件，就不创建了

public boolean mkdir():创建文件夹如果存在这样的文件夹，就不创建了

public boolean mkdirs():创建文件夹,如果父文件夹不存在，会帮你创建出来

重命名和删除功能

public boolean renameTo(File dest):把文件重命名为指定的文件路径

public boolean delete():删除文件或者文件夹

重命名注意事项

如果路径名相同，就是改名。

如果路径名不同，就是改名并剪切。

删除注意事项：

Java中的删除不走回收站。

要删除一个文件夹，请注意该文件夹内不能包含文件或者文件夹

判断功能

public boolean isDirectory():判断是否是目录

public boolean isFile():判断是否是文件

public boolean exists():判断是否存在

public boolean canRead():判断是否可读

public boolean canWrite():判断是否可写

public boolean isHidden():判断是否隐藏

获取功能

public String getAbsolutePath()：获取绝对路径

public String getPath():获取路径

public String getName():获取名称

public long length():获取长度。字节数

public long lastModified():获取最后一次的修改时间，毫秒值

public String[] list():获取指定目录下的所有文件或者文件夹的名称数组

public File[] listFiles():获取指定目录下的所有文件或者文件夹的File数组

需要注意的是：

windows下文件路径间隔符是\，在实际书写中要\\，因为\是转移字符。mac下为/。

windows下默认都是可读的，所以文件设置setReadble为false无效。mac下可以

检索文件夹下jpg结尾的文件：

public static void main(String[] args) {
		File dir = new File("/Users/yoofale/Desktop/假装是D盘/666");
		File[] files = dir.listFiles();
		for (File file : files) {
			if (file.isFile() && file.getName().endsWith(".txt")) {
				System.out.println(file);
			}
		}
	}

用listFiles而不是list的原因，listFiles获得的都是文件，可以直接操作。

或者可以直接文件名过滤器：

		String[] list = dir.list(new FilenameFilter() {

			@Override
			public boolean accept(File dir, String name) {
				File file = new File(dir, name);
				return file.isFile() && file.getName().endsWith(".txt");
			}
		});
		for (String string : list) {
			System.out.println(string);
		}

猜你喜欢