Map集合/异常/IO流

最新推荐文章于 2023-04-24 08:15:00 发布

faith_kevin

最新推荐文章于 2023-04-24 08:15:00 发布

阅读量399

点赞数 1

本文链接：https://blog.csdn.net/fath_kevin/article/details/78617013

版权

一;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);//将该牌盒子中的顺序打乱,实现三次洗牌

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(异常类名，变量名){处理语句}

#针对多个异常进行处理，如果第一个异常为大异常，那么后面的异常就可以不用写了。防止出错。

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!

faith_kevin

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
Map集合/异常/IO流

一;Map接口:有以下几个子实现类: HashMap Hashtable TreeMap(1) HashMap:基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用null 值和 null 键;底层数据结构是哈希表,特点:元素唯一,无序,元素唯一靠的是重写了equals()方法和hashcode()方法K - 此映射所维护的键的类型V - 所映射值的类
复制链接

扫一扫