Map集合/异常/IO流
一;Map接口:有以下几个子实现类: HashMap Hashtable TreeMap
(1) HashMap<k,v>:基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键;底层数据结构是哈希表,特点:元素唯一,无序,元素唯一靠的是重写了equals()方法和hashcode()方法
K - 此映射所维护的键的类型
V - 所映射值的类型
(2) HashMap()集合中的方法:
添加功能:
put():第一次采用put 放置数据的时候 返回的是null; 第二次放置键相同的数据 会返回上一次的值-----键相同,值覆盖.
获取功能:
Set<Map.Entry<K,V>> entrySet(): 返回一个键值对的Set集合
V get(Object key):根据键获取值
Set<K> keySet():获取集合中所有键的集合
Collection<V> values():获取集合中所有值的集合
判断功能:
boolean containsKey(Object key)：判断集合是否包含指定的键
boolean containsValue(Object value):判断集合是否包含指定的值
boolean isEmpty()：判断集合是否为空
删除功能:
void clear():移除所有的键值对元素
V remove(Object key)：根据键删除键值对元素，(v—该键对应的值)并把值返回
#HashMap集合中方法的综合应用:
package HashMapText;
import java.util.HashMap;
import java.util.Set;
public class HashMapText_02 {
public static void main(String[] args) {
HashMap<String,String> hm=new HashMap<String,String>();//创建HashMap集合,并指明泛型
hm.put("孙悟空", "会72变");//调用HashMap集合的put()方法,向集合中添加元素
hm.put("杨戬", "有三只眼");
hm.put("哪吒", "三头六臂");
System.out.println("集合是否为空:" + hm.isEmpty());//对该集合进行判空操作
System.out.println("删除该键处指定的值:" + hm.remove("孙悟空"));//调用V remove(Object key)：根据键删除键值对元素，(v—该键对应的值)并把值返回
System.out.println("该集合是否含有该键:" + hm.containsKey("哪吒"));//判断集合是否有指定的键
System.out.println("该集合是否有这个值:" + hm.containsValue("没有"));//判断集合是否有指定的值
hm.clear();//删除该集合中的所有元素
System.out.println("删除该集合后的所有元素有:");
//遍历该集合:
Set<String> keySet = hm.keySet();//获取该集合的键集合
for(String k:keySet){
System.out.println(k + "---" + hm.get(k));
}
}
}
(3) HashMap集合的两种遍历方法:
方式一:
1. 先获取该集合的键集合;列:---Set<Integer> k=hm.keySet();(该方法返回Set集合)
2. 遍历该键集合,间接获取该集合中键所对应的每个值;列---for(Integer i:k){
System.out.println(i + “---“ + hm.get(i));
方式二:
1. 先获取该键值对的集合;例---Set<Entry<Integer,String>> s=hm.EntrySet();(该方法返回Set集合);
2. 用增强for循环进行遍历该键值对集合,并通过getkey()和getvalue()方法分别获取键和值
#HashMap集合的两种遍历方法:
package HashMapText;
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
public class HashMap_Text01 {
public static void main(String[] args) {
HashMap<Integer,String> hm=new HashMap<Integer,String>();//创建HashMap集合对象,并指明泛型
hm.put(2, "美队");
hm.put(1, "超人");//向集合中添加元素,因为该键的类型为Integer类型,其底层实现了Comparable接口,会自动进行比较,所以结果中的元素是唯一的
hm.put(4, "绿巨人");
hm.put(3, "钢铁侠");
//遍历HashMap集合元素,第一种遍历方法
// Set<Integer> k=hm.keySet();//调用hashMap集合的KeySet()方法,获取键集合.
// for(Integer key:k){
// System.out.println(key + "---" + hm.get(key));
// }
//第二种遍历方法
Set<Entry<Integer, String>> set = hm.entrySet();//调用hashMap集合的entrySet()方法,该方法返回Set集合的键值对集合
for(Entry<Integer, String> en:set){
System.out.println(en.getKey()+ "---" + en.getValue());
}
}
}
#HashMap集合中的键为自定义类时:Map集合中的数据结构只跟键有关,与值无关,当键为自定义类时,为了保证最后遍历出的元素具有唯一性,在该类中需要重写equals()方法和hashcode()方法,为了能让自定义类中的元素以字符串的形式打印出来,该类需要重写toString()方法.
package HashMapText;
import java.util.HashMap;
import java.util.Set;
public class HashMapText_03 {
public static void main(String[] args) {
HashMap<Student,String> hm=new HashMap<Student,String>();//创建HashMap集合对象,该键的类型为Student类
hm.put(new Student(22,"上官完成"), "三好学生");//向该集合中添加元素
hm.put(new Student(50,"王抢"), "该生很差");
hm.put(new Student(26,"欧阳长风"), "优等生");
hm.put(new Student(25,"欧阳长风"), "优等生");
hm.put(new Student(50,"王抢"), "该生很差");//添加相同元素
//遍历该集合
Set<Student> keySet = hm.keySet();//获取键集合
for(Student s:keySet){
System.out.println(s + "---" + hm.get(s));
}
}
}
class Student{
private int age;
private String name;
public Student() {
super();
// TODO Auto-generatedconstructor stub
}
public Student(int age, String name) {
super();
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public int hashCode() {//因为将HashMap集合的键定义为自定义类,想要保证集合中元素的唯一性,在该类中就需要重写equals()方法和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;
Student other = (Student) 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;
}
@Override
public String toString() {//重写该方法,才能以字符串形式打印出Student类中的元素
return "Student[age=" + age + ",name=" + name + "]";
}
}
(4) LinkedHashMap集合:底层数据结构是链表和哈希表,元素有序且唯一,元素的唯一性由哈希表保证,哈希表底层会重写equals()方法和hashcode()方法;有序性由链表结构保证;(注:这里的有序是指存的顺序和取得顺序一致)
#LinkedHashMap集合遍历集合元素:
package LinkedHashMapText;
import java.util.LinkedHashMap;
import java.util.Set;
public class LinkedHashMapText_01 {
public static void main(String[] args) {
LinkedHashMap<Integer,String> lhm=newLinkedHashMap<Integer,String> ();//创建LinkedHashMap集合对象,
lhm.put(3, "钢铁侠");
lhm.put(2, "美国队长");
lhm.put(1, "蜘蛛侠");
lhm.put(2, "美国队长");//添加相同元素
lhm.put(4, "美国队长副本");
Set<Integer> keySet = lhm.keySet();//获取键集合
for(Integer k:keySet){//遍历该集合
System.out.println(k + "---" + lhm.get(k));//该集合链表结构可以保证元素存的顺序和取得顺序一致
}
}
}
(5) TreeMap集合:数据结构是红黑树,特点:元素唯一,而且还能对元素进行排序,排序方式有自然排序和比较器排序
#TreeMap集合遍历元素:
package TreeMapText;
import java.util.Set;
import java.util.TreeMap;
public class TreeMapText_01 {
public static void main(String[] args) {
TreeMap<Integer,String> tm=new TreeMap<Integer,String>();//创建TreeMap集合的对象,TreeMap集合底层实现了Comparable接口,该接口存在方法Cmparato()方法,所以会进行排序
tm.put(3, "钢铁侠");
tm.put(2, "美国队长");
tm.put(1, "蜘蛛侠");
tm.put(2, "美国队长");//添加相同元素
tm.put(4, "美国队长副本");
Set<Integer> keySet = tm.keySet();//获取键集合
for(Integer k:keySet){
System.out.println(k + "---" + tm.get(k));
}
}
}
#TreeMap集合遍历自定义对象元素:
package TreeMapText;
import java.util.Set;
import java.util.TreeMap;
public class TreeMapText_02 {
public static void main(String[] args) {
TreeMap<Girl,String> tm=new TreeMap<Girl,String>();//创建TreeMap集合对象
tm.put(new Girl(18,"高圆圆"), "气质女神");
tm.put(new Girl(20,"王祖贤"), "完美女神");
tm.put(new Girl(23,"朱茵"), "不老女神");
tm.put(new Girl(26, "张敏"),"冷酷女神");
tm.put(new Girl(20,"林青霞"), "东方不败");
Set<Girl> keySet = tm.keySet();//获取键集合
for(Girl k:keySet){
System.out.println(k + "---" + tm.get(k));
}
}
}
class Girl implements Comparable<Girl>{
private int age;
private String name;
public Girl(int age, String name) {
super();
this.age = age;
this.name = name;
}
public Girl() {
super();
// TODO Auto-generatedconstructor stub
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Girl[age=" + age + ",name=" + name + "]";
}
public int compareTo(Girl g) {//重写该接口的Comparato()方法
// TODO Auto-generatedmethod stub
int num1=g.age-this.age;
int num2=num1==0?this.name.compareTo(g.name):num1;
return num2;
}
}
二:集合的嵌套遍历:
(1)HashMap集合的嵌套遍历:先获取大集合的键集,再根据键获取大集合中的每个键对应的值,然后用大集合获取值的这个对象调用keySet()方法,获取小集合的每个键,再用增强for()循环遍历该集合中的元素
#HashMap集合的嵌套遍历:
package HashMapText;
import java.util.HashMap;
import java.util.Set;
/**
* 需求:用HashMap集合遍历出
* 古希腊神话故事:
* 宙斯--宇宙之神
* 波塞冬--海洋之神
* 阿瑞斯--战神
* 中国神话故事:
* 如来--boss
* 玉皇老头--二把手
* 孙悟空--斗战圣佛
* */
public class HashMapText_04 {
public static void main(String[] args) {
HashMap<String,String> hm1=new HashMap<String,String>();//创建封装古希腊神话故事的集合
hm1.put("宙斯", "宇宙之神");
hm1.put("波塞冬", "海洋之神");
hm1.put("阿瑞斯", "战神");
HashMap<String,String> hm2=new HashMap<String,String>();//创建封装中国神话故事的集合
hm2.put("如来","boss");
hm2.put("玉皇老头", "二把手");
hm2.put("孙悟空","斗战圣佛");
HashMap<String,HashMap<String,String>> hm=newHashMap<String,HashMap<String,String>>();//创建封装神话故事的集合
hm.put("古希腊神话故事:", hm1);
hm.put("中国神话故事:", hm2);
//获取大集合的键集合
Set<String> keySet = hm.keySet();
for(String key:keySet){
HashMap<String, String> hashMap = hm.get(key);//通过大集合的键获取对应的值
Set<String> keySet2 = hashMap.keySet();//获取先集合的键
for(String key2:keySet2){
System.out.println(key2 + "---" + hashMap.get(key2));//获取小集合的每个键对应的值
}
System.out.println( "----------------------");
}
}
}
(2)ArrayList集合与HashMap集合的嵌套遍历:
(3)packageArrayListAndHashMapText;
(4)import java.util.ArrayList;
(5)import java.util.HashMap;
(6)import java.util.Set;
(7)/**
(8) * 需求:使用ArrayList集合和HashMap集合嵌套遍历这些元素
(9) * 音乐才子:
(10) * 马克西姆
(11) * 赵雷
(12) * 艺术家
(13) * 梵高
(14) * 徐悲鸿
(15) *
(16) * */
(17) public classArrayListAndHashMapText_01 {
(18) public static void main(String[]args) {
(19) ArrayList<String>al1=new ArrayList<String>();//创建第一个ArrayList集合,来封装音乐才子
(20) al1.add("马克西姆");
(21) al1.add("赵雷");
(22)
(23) ArrayList<String>al2=new ArrayList<String>();//创建第二个ArrayList集合,来封装艺术家
(24) al2.add("梵高");
(25) al2.add("徐悲鸿");
(26)
(27) HashMap<String,ArrayList<String>>hm=new HashMap<String,ArrayList<String>>();//将音乐才子与艺术家封装在HashMap集合中
(28) hm.put("音乐才子", al1);
(29) hm.put("艺术家", al2);
(30)
(31) //遍历该集合中的元素:
(32) Set<String>keySet = hm.keySet();
(33) for(String k:keySet){
(34) System.out.println(k);
(35) ArrayList<String>list = hm.get(k);//获取该HashMap集合中键所对应的值
(36) for(String s:list){
(37) System.out.println("\t" + s);
(38) }
(39) System.out.println("----------------");
(40) }
(41) }
(42) }
三：集合工具类 Collections
（1） 成员方法：
public static <T> voidsort(List<T> list): 根据元素的自然顺序对指定列表按升序进行排序。
public static <T> int binarySearch(List<?>list,T key): 二分查找；使用二分搜索法搜索指定列表，以获得指定对象。（前提是该集合中的元素是有序的）
public static <T> T max(Collection<?> coll): 根据元素的自然顺序，返回给定 collection 的最大元素。
public static void reverse(List<?> list): 反转指定列表中元素的顺序。
public static void shuffle(List<?> list): 使用默认随机源对指定列表进行置换。
#Colllections集合成员方法的应用:
package ArrayList_Demo;
import java.util.ArrayList;
import java.util.Collections;
public class ArrayListText_03 {
public static void main(String[] args) {
ArrayList<Integer> al=new ArrayList<Integer>();//创建ArrayList集合对象,并指定泛型
al.add(20);
al.add(18);
al.add(26);
al.add(23);
al.add(19);//向集合中添加元素
Collections.sort(al);//调用Collections工具类的sort()方法对,集合中的元素进行排序
int indexof=Collections.binarySearch(al, 20);//对已经排好序的集合元素进行二分查找
System.out.println("该数对应的索引为:" + indexof);
Collections.shuffle(al);//将集合中的元素打乱
int max=Collections.max(al);//返回该集合中的最大值
int min=Collections.min(al);//返回该集合中的最小数\
System.out.println("集合中的最大值为:" + max);
System.out.println("集合中的最小值为:" + min);
}
}
#用HashMap集合统计字符串中每个字母出现的次数:
package HashMapText;
/**
* 需求:键盘录入一串字符串,统计字符串中字母出现的次数
* */
import java.util.HashMap;
import java.util.Scanner;
import java.util.Set;
public class HashMaoText_05 {
public static void main(String[] args) {
HashMap<Character,Integer> hm=new HashMap<Character,Integer>();//先创建HashMap集合,并指明泛型
Scanner Sc=new Scanner(System.in);
System.out.println("请用户输入一个字符串:");
String Str=Sc.nextLine();
char []ch=Str.toCharArray();//将字符串转换为字节数组
for(char key:ch){//遍历该字节数组,实质是遍历HashMap集合中的键集
Integer in = hm.get(key);//通过上述的键集获取对应的Integer值
if(in==null){
hm.put(key, 1);//HashMap集合的put()方法在第一次添加元素时,Value返回Null,
}
else{
in++;
hm.put(key, in);//用put()方法第二次添加元素时,键相同,值覆盖
}
}
StringBuilder sb=new StringBuilder();//创建字符串缓冲区对象
Set<Character> keySet = hm.keySet();//获取该集合的键集
for(Character k:keySet){
sb.append(k).append("(").append(hm.get(k)).append(")");//通过StringBuilder的append()方法将键及其对应的值添加到缓冲区中
}
System.out.println("字符串中每个字母出现的次数为:" +sb.toString());//将StringBuilder类型转换为String类型进行输出
}
}
#用ArrayList集合实现斗地主的发牌,洗牌,看牌;显示输出玩家手中的牌:
package ArrayListGame;
import java.util.ArrayList;
import java.util.Collections;
/**
* 需求:实现斗地主的发牌,看牌游戏:
* 1.先创建一个ArrayList集合来封装54张牌
* 2.在定义两个数组,一个存放花色字符串,另一个数组存放数字字符串
* 3.通过增强for()循环的嵌套来将每张牌都封装在牌盒子集合中,在调用集合的添加功能,额外添加两张大小王
* 4.然后调用Collections工具类的shuffle()方法将集合中的元素打乱
* 5.再创建3个游戏用户集合,和封装底牌的集合
* 6.根据牌盒子存放牌的索引下标,判断给谁发牌
* 7.定义一个方法,功能实现看牌,用增强for()循环遍历每个用户手里的牌
*
* */
public class ArrayListGameText_01 {
public static void main(String[] args) {
ArrayList<String> Poker=new ArrayList<String> ();//创建牌盒子集合对象
String[] StrColor={"红桃","黑桃","梅花","方块"};//定义花色数组
String[] StrNumber={"A","2","3","4","5","6","7","8","8","9","10","J","Q","K"};//定义数字数组
for(String Color:StrColor){
for(String Number:StrNumber){
Poker.add(Color + Number);//获取52张常规牌
}
}
Poker.add("大鬼");
Poker.add("小鬼");//向该集合中添加大小王
Collections.shuffle(Poker);
Collections.shuffle(Poker);
Collections.shuffle(Poker);//将该牌盒子中的顺序打乱,实现三次洗牌
ArrayList<String> play1=new ArrayList<String>();//创建玩家一集合
ArrayList<String> play2=new ArrayList<String>();//创建玩家二集合
ArrayList<String> play3=new ArrayList<String>();//创建玩家三集合
ArrayList<String> publicPoker=newArrayList<String>();//创建封装底牌的集合
for(int i=0;i<Poker.size();i++){
if(i>=Poker.size()-3){
publicPoker.add(Poker.get(i));//调用arraylist集合的get()方法,该方法根据对应的索引,返回该索引对应的值
}
else if(i%3==0){
play1.add(Poker.get(i));//给玩家一发牌
}else if(i%3==1){
play2.add(Poker.get(i));//给玩家二发牌
}else if(i%3==2){
play3.add(Poker.get(i));//给玩家三发牌
}
}
ShowPoker("play1",play1);
ShowPoker("play2",play2);
ShowPoker("play3",play3);
ShowPoker("publicPoker",publicPoker);
}
public static void ShowPoker(String Str,ArrayList<String> PokerPlay){
System.out.println(Str);
for(String StrPoker:PokerPlay){
System.out.print(StrPoker + ",");
}
System.out.println();
}
}
四：异常类Throwable：两个具体的子类:Error和Exception
（1） Error：Error（错误）表示运行应用程序中较严重问题
（2） Exception异常分类：
1. 运行时期异常（RuntimeException）：严谨导致的问题（列：NullPointerException:空指针异常!解决方案：需要个对象进行非空判断,来防止该问题的出现!）
出现的原因：可能由于我们代码的逻辑不够
2. 编译时期异常: 只要不是RuntimeException中的异常都属于编译时期异常；比如:IOException(IO流中的),ParseException(解析异常)
出现的原因：要么语法有问题，要么使用sun公司提供的一些方法中，原本会抛出异常。调用的时候必须处理。
（3） 处理异常：
1.方式一：标准格式:try...catch...finally:捕获异常!
变形格式有：try...catch
Try...catch...catch
Try...finally...(多线程，lock锁)
经常会使用格式：try{可能有错误的语句}catch（异常类名，变量名）{输出语句处理，或者是调用printStackTrace()方法}；
2.多线程处理：
A,分别try..catch…
B,try{可能有问题的代码}
catch(异常类名，变量名){处理语句}
catch(异常类名，变量名){处理语句}
………………
catch(异常类名，变量名){处理语句}
#针对多个异常进行处理，如果第一个异常为大异常，那么后面的异常就可以不用写了。防止出错。
C,针对多个异常进行处理，JDK7.0以后给出了又一种新方式：
Try{可能出现问题的语句}
catch(异常类名1 |异常类名2 …变量名){处理异常}
#注意：上述多个异常类名之间都是平级关系
这种格式在开发中，虽然有多个异常，但是针对具体的异常应该给出具体的解决方案；
（4） 异常的第二种处理方式：
throws:抛出异常; 在方法声明上抛出异常,由于,编译时期异常,调用者必须要处理; 实际开发中,尽量的不要在main()方法抛出异常,在子方法中可以抛出异常,
#，throw和throws的区别？
Throw:后面跟的是异常对象（匿名对象）只能跟具体的一个异常类对象。Throw在方法中的语句中抛catch语句结束
Throws:后面跟的是异常类名，可以跟多个异常类名，中间用逗号隔开，throws表示在方法声明上抛出异常的可能性，由调用者去处理。
#对于多个异常,分别Try...catch(){...}
package ExceptionText_01;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class ExceptionText01 {
public static void main(String[] args) {
String Str="2017-11-22";//定义字符串格式的日期
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");//创建SimpleDateFormat对象
try {
Date date=sdf.parse(Str);
} catch (ParseException e) {
// TODO Auto-generatedcatch block
System.out.println("调用SimpleDateFormat的parse()方法,本身就会抛出异常:");
//e.printStackTrace();
}
int []arr={12,5,3,9,8,11};
//想获得下标为6的元素
try {
System.out.println(arr[6]);
} catch (ArrayIndexOutOfBoundsException e) {
// TODO Auto-generatedcatch block
System.out.println("数组下标越界异常:");
e.printStackTrace();
}
}
}
#多个异常Try..catch(){}catch(){}:
package ExceptionText_01;
public class ExceptionText02 {
public static void main(String[] args) {
int []arr={26,12,3,4};
int a=6;
int b=0;
try {
int d=arr[4];
System.out.println(d);
int c=a/b;
System.out.println(c);
} catch (ArithmeticException e) {
// TODO Auto-generatedcatch block
e.printStackTrace();
System.out.println("该异常是除数不能为0");
} catch(ArrayIndexOutOfBoundsException e2){
System.out.println("该异常是数组下标越界异常");
}
System.out.println("over!");
}
}
#注意:针对多个异常进行处理,如果第一个异常为大异常,也就是异常的父类,那么后面就可以不用再写了;
#多个异常的try...catch(){}用法:
package ExceptionText_01;
/**
* 注意:catch()中的异常类名之间都是平级关系
* */
public class ExceptionText03 {
public static void main(String[] args) {
int []arr={12,32,6,9};
int a=6;
int b=0;
try {
int c=a/b;
System.out.println(c);
int d=arr[4];
System.out.println(d);
} catch (ArithmeticException | ArrayIndexOutOfBoundsException e){
// TODO Auto-generatedcatch block
e.printStackTrace();
System.out.println("分别是数组越界和除数不能为0的异常:");
}
System.out.println("over!");
}
}
5. 捕获异常的标准格式: try...catch...finally
用法:finally经常用在数据库和Io流中,用来释放资源,finally中的代码一定会执行,finally中的代码只有在一种情况下不会执行:JVM退出,调用system.exit(0);
#面试题:final,final,finally三者的区别?
Final:可以修饰类,该类不能被继承,
修饰成员方法:该方法不能被重写
修饰成员变量:变量为一个常量
Finalize:表示通过gc回收器回收不用的对象或者是变量,System.gc():实质是调用的是重写了Object类中的finalize()方法,表示回收没有更多引用对象或者变量等.
Finally:不能单独使用,会在try...catch(){…}finally语句一块使用
#面试题:
如果catch里面有return语句,那么finally里面的语句是否会执行?如果会,是在return语句之前还是在return语句之后?
会执行,且会在return语句之前执行,因为return语句形成了返回路径,所以在执行完finally中的语句之后,会回到catch语句中的return语句;
#package ExceptionText_01;
public class ExceptionText04 {
public static void main(String[] args) {
System.out.println(show());
}
public static int show(){
int a=10;
try {
System.out.println(a/0);
a=20;
} catch (Exception e) {
// TODO Auto-generatedcatch block
System.out.println("这里出现了除数不能为0的异常:");
a=30;
return a;//这里的return语句形成了方法返回路径
}
finally{
a=40;
}
return a;
}
#自定义一个异常类:
测试类:
package ExceptionText_02;
import java.util.Scanner;
/**
* 需求:自定义一个异常类,该类继承自Exception或者RuntimeException
* 1.创建测视类,用键盘录入一个分数,
* 2.自定义一个异常类(MyException),继承自Exception,
* 3,定义一个具体类,该类提供一个方法,用来判断分数的有效性
*
* */
public class ExceptionText01 {
public static void main(String[] args) {
Scanner Sc=new Scanner(System.in);
System.out.println("请输入一个分数:");
intscore=Sc.nextInt();
Stuudent s=new Stuudent();
try {
s.check(score);
} catch (MyExceptionDemmo e) {
// TODO Auto-generatedcatch block
e.printStackTrace();
System.out.println("该方法会抛出异常;");
}
System.out.println("over!");
}
}
自定义异常类:
package ExceptionText_02;
public class MyExceptionDemmo extends Exception {
public MyExceptionDemmo() {
super();
// TODO Auto-generatedconstructor stub
}
public MyExceptionDemmo(String arg0, Throwable arg1, boolean arg2,
boolean arg3) {
super(arg0, arg1, arg2, arg3);
// TODO Auto-generatedconstructor stub
}
public MyExceptionDemmo(String arg0, Throwable arg1) {
super(arg0, arg1);
// TODO Auto-generatedconstructor stub
}
public MyExceptionDemmo(String arg0) {
super(arg0);
// TODO Auto-generatedconstructor stub
}
public MyExceptionDemmo(Throwable arg0) {
super(arg0);
// TODO Auto-generatedconstructor stub
}
}
具体类:
package ExceptionText_02;
public class Stuudent {
public static int check(int a)throws MyExceptionDemmo{
if(a<0 || a>100){
throw new MyExceptionDemmo("分数应该在0-100之间;");
}else{
return a;
}
}
}
异常中的注意事项:
1. 子类在重写父类方法的时候,如果父类的该方法有抛出异常,那么子类在重写该方法的时候,不能比父类中该方法的异常大,至少应该持平.
2. 如果子类在继承父类时,父类的该方法没有抛出异常,那么子类在重写父类的方法时,不能抛出异常,只能捕获异常;
五,File类;
(1) file:文件和目录路径名的抽象表示形式。
(2) 常用的构造方法: public File(Stringpathname): 通过将给定路径名字符串转换为抽象路径名来创建一个新
File 实例。(开发中经常使用该构造方法)
(3) public File(File parent,Stringchild): 根据 parent 抽象路径名和 child 路径名字符串创建一个新File 实例。
(4) public File(Stringparent,String child): 根据 parent 路径名字符串和 child 路径名字符串创建一个新
File 实例。
(5) public boolean mkdir():创建此抽象路径名指定的目录。
(6) public boolean createNewFile():该方法用来创建文件; 如果已经有这个文件了,不在创建,并且该方法本身就会编译时期异常IOException
(7) public boolean mkdirs():创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。(创建文件夹,文件夹不存在,才开始创建)
注意:调用者需要弄清楚自己想要创建的是文件夹还是文件;
如果给定的路径名不带盘符,则默认会建在当前项目下面;
#File类成员方法的综合应用:
package FileText;
import java.io.File;
import java.io.IOException;
public class FileText_01 {
public static void main(String[] args) throws IOException {
// //方式一:调用File类的public File(String pathname)方法;通过给定一字符串类型的路径名来表示当前的这个文件和文件夹
// File file=new File("e:\\JAVA\\FileDemo_01");
// System.out.println("创建目录mkdir:" +file.mkdir());
// //方法二:调用File类的public File(File parent,String child)方法;
// File file2=newFile("e:\\JAVA\\FileDemo_01","file.txt");
// System.out.println("在当前目录下面创建文件夹:" + file2.mkdirs());
//方法三:调用File类的(3) public File(File parent,String child)方法
// File file3=new File("e:\\JAVA\\filedemo_02");
// File file4=new File(file3,"a.txt");
// System.out.println("在当前文件下创建文件夹:" + file4.mkdirs());
//创建文件
File file5=new File("e:\\JAVA\\demo");
System.out.println("创建文件夹:" + file5.mkdirs());//创建文件夹,
File file6=new File("e:\\JAVA\\demo\\a.txt");
System.out.println("创建文件:" + file6.createNewFile());//创建文件,前提是的有该文件的文件夹路径
}
}
(8) File类的删除功能
public boolean delete()删除此抽象路径名表示的文件或目录;不能删除带有文件或者文件夹的目录
注意事项: 删除的方法不能删除带有目录或者文件的文件夹删除多个目录,必须逐一删除!
#File类的删除功能综合应用:
package FileText;
import java.io.File;
import java.io.IOException;
public class FileText_03 {
public static void main(String[] args) throws IOException {
File file1=new File("a\\b\\c");
System.out.println("在当前项目下创建嵌套文件夹:" + file1.mkdirs());
File file2=new File("a\\b\\c\\a.txt");
System.out.println("在文件夹中创建a.txt文件:" +file2.createNewFile());
//需求:现在要删除这个文件及文件夹
System.out.println(file2.delete());
//然后删除a\\b\\下的c文件夹
File file3=new File("a\\b\\c");//每次删除只能逐一删除,删除前要获取当前项目在的文件夹路径
System.out.println(file3.delete());
//再删除a\\下的b
File file4=new File("a\\b");
System.out.println(file4.delete());
File file5=new File("a");
System.out.println(file5.delete());
}
}
(9) File类的重命名功能:
publicboolean renameTo(File dest): 重新命名此抽象路径名表示的文件。
注意:1. 当两个抽象路径一致,那么只是重命名
2.当抽象路径不一致,该方法将剪切并改名
#File类的renameTo()方法应用:
package FileText;
import java.io.File;
import java.io.IOException;
public class FileText_02 {
public static void main(String[] args) throws IOException {
// System.out.println("先获取当前项目下的1.jpg");
// File file1=new File("1.jpg");
// File file2=new File("2.jpg");
// file1.renameTo(file2);
//当抽象路径不一样时,renameTo()功能是剪切并修改
System.out.println("先获取当前项目下的2.jpg");
File file3=new File("2.jpg");
File file4=new File("e:\\JAVA\\demo\\3.jpg");
file3.renameTo(file4);//将当前项目下的2.jpg文件拷贝到e盘下,并改名
}
}
(10) File类中的获取功能:
publicFile getAbsolutePath():获取当前文件或者文件夹绝对路径
publicString getPath():获取相对路径
public long length()返回由此抽象路径名表示的文件的长度
public long lastModified()返回此抽象路径名表示的文件最后一次被修改的时间
publicString getName():获取名称
#File类中获取功能的应用:
package FileText;
import java.io.File;
import java.io.IOException;
public class FileText_04 {
public static void main(String[] args) throws IOException {
File file=new File("file.txt");
System.out.println("创建当前项目下的文件:" + file.createNewFile());
System.out.println("获取当前文件的绝对路径:" + file.getAbsolutePath());
System.out.println("获取当前文件的相对路径:" + file.getPath());
System.out.println("获取当前文件的长度:" + file.length());
System.out.println("返回该文件最后一次被修改的时间:" + file.lastModified());
}
}
(11) File类中的判断功能:
publicboolean isDirectory():判断是否是文件夹
public boolean isFile():判断是否是一个标准文件
publicboolean canRead():判断是否可读
public boolean canWriter():判断是否可写
public boolean isHidden():判断是否是隐藏文件
public boolean isAbsolute():判断次路径名是否是绝对路径
#File类的判断功能综合应用:
package FileText;
import java.io.File;
import java.io.IOException;
public class FileText_05 {
public static void main(String[] args) throws IOException {
File file=new File("b.txt");
System.out.println("创建当前项目下的文件:" + file.createNewFile());
//需求:使用File类的判断功能
System.out.println("判断该文件是否为文件夹:" + file.isDirectory());
System.out.println("判断该文件是否为文件:" + file.isFile());
System.out.println("判断该文件是否为隐藏文件:" + file.isHidden());
System.out.println("判断该文件是否可写文件:" + file.canWrite());
System.out.println("判断该文件是否为可读文件:" + file.canRead());
System.out.println("判断该文件是否是绝对路径:" + file.isAbsolute());
}
}
(12)File类的高级获取功能:
publicString[] list(): 返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。
publicFile[] listFiles():返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。
#File高级获取功能的应用:
package FileText;
import java.io.File;
public class FileText_06 {
public static void main(String[] args) {
File file=new File("e:\\JAVA");//将e盘下的文件封装
//方式一:通过File类的List()方法获取该盘下的文件及目录
String[] Str=file.list();//giant方法返回String类型的数组
if(Str!=null){//对该数组进行非空判断
for(String s:Str){
System.out.println(s);
}
}
System.out.println("---------------------------------");
//方式二:通过File类的listFiles()方法,获取该盘下的文件及目录
File[] listFiles = file.listFiles();
if(listFiles!=null){
for(File f:listFiles){
System.out.println(f.toString());
}
}
}
}
#获取e盘下以.jpg结尾的文件:
package FileText;
/**
* 需求:获取e盘的JAVA文件下后缀为.Jpg结束的文件
* 1.先创建FIle类的对象,通过它的构造方法public File(String pathname)将e盘封装
* 2.再调用File类的list()方法,将e盘的文件及目录文件封装在String类型的数组中
* 3.对该数组进行非空判断
* 4.用增强for()循环获取每一个元素
* 5.在调用判断功能,判断这些元素是否为文件
* 6.在调用String类的endswith()方法
* 7.输出以.jpg结尾的文件
*
* */
import java.io.File;
public class FileText_07 {
public static void main(String[] args) {
File file=new File("e:\\JAVA");
File[] listFiles = file.listFiles();
if(listFiles!=null){
for(File s:listFiles){
if(s.isFile()){
if(s.getName().endsWith(".jpg")){
System.out.println(s);
}
}
}
}
}
}
六:IO流
(1) 设备和设备之间的数据传输; 设备和设备指的是:硬盘和内存之间的数据传输
(2) IO流的分类:
按流的方向分: 输入流:读数据的
输出流:写数据的
按数据类型分:
字节流: 字节输入流:InputStream
字节输出流:OutputStream
字符流: 字符输入流:Reader
字符输出流:Writer
(3) OutputStream: 字节输出流,该类是抽象类,不能实例化,创建对象时,可以采用抽象类多态的形式: OutputStream os = newFileOutputStream("os.txt");或者直接创建其子类的对象FileOutputStream fos = newFileOutputStream("fos.txt") ;
(4) 开发步骤: 1创建文件输出流对象(FileOutputStream fos = newFileOutputStream("fos.txt") ;)
2写数据(fos.write("hello,io,i'mcoming...".getBytes()) ;)
3关闭资源(fos.close() ;)
(5) 输出流中写数据的方法:
public abstract void write(int b):将指定的字节写入到输出流中
public void write(byte[] b):将指定的字节数组写入到输出流中
public void write(byte[] b, int off,int len):将字节数组的一部分写入到输出流中
#IO流的字节输出流综合应用:
测试类:
package IOText;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class IOText_01 {
public static void main(String[] args) {
FileOutputStream fos = null;
try {
fos = new FileOutputStream("c.txt");
} catch (FileNotFoundException e) {
// TODO Auto-generatedcatch block
e.printStackTrace();
}
try {
fos.write("You are mySunshine!".getBytes());//写数据,写完后调用getBytes()方法,将字符串类型转换为字节数组类型
} catch (IOException e) {
// TODO Auto-generatedcatch block
e.printStackTrace();
}
try {
fos.close();//释放流资源,释放时候不能进行写数据,否则会出错
} catch (IOException e) {
// TODO Auto-generatedcatch block
e.printStackTrace();
}
}
}
结果: You are mySunshine!