第八节:详细讲解Java中的异常处理情况与I/O流的介绍以及类集合框架

前言

大家好,我是 Vic,今天给大家带来详细讲解Java中的异常处理情况与I/O流的介绍以及类集合框架的概述,希望你们喜欢

JAVA 异常

try…catch…finally结构的使用方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class Test{
public static void main(String args[]){

try{
int i = 1 / 0;
}
catch(Exception e){
e.printStackTrace();
}
finally{
System.out.println("finally");
}
System.out.println(5);
}
}

class Test{
public static void main(String args[]){
try{
Thread.sleep(1000);
}
catch(Exception e){
e.printStackTrace();
}
}
}

throw和throws的作用区别:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Person{
private int age;

public void setAge(int age) throws Exception{
if(age<0){
RuntimeException e = new RuntimeException("年龄不能小于0");
throw e;
}
this.age = age;
}
}

class Test{
public static void main(String args[]){
Person person = new Person();
try{
person.setAge(-1);
}
catch(Exception e){
System.out.println(e);
}
}
}

Error和Exception的区别

  • Error是Throwable的子类用于标记严重错误
  • Exception是Throwable的子类,指示合理的程序想去catch的条件,非严重错误。

    try/catch的执行过程

    如果出现异常,系统则会抛出一个异常,进行捕捉(catch操作),或在最后(finally)来进行处理。

    throw和throws的区别

    throws 出现在方法声明上,throw出现在方法体内。

    异常分类

    异常分类:可查异常,运行时异常和错误

    说说IO

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    //第一种:输入流输出流
    //第二种:字节流字符流
    //第三种:节点流处理流
    //FileInputStream
    class Test{
    public static void main(String args[]){
    FileInputStream fis = null;
    try{
    fis = new FileInputStream("e:/read.txt");
    byte[] buffer = new byte[100];
    fis.read(buffer,0,buffer.length);
    for(int i = 0;i<buffer.length;i++){
    System.out.println(buffer[i]);
    }
    }
    catch(Exception e){
    System.out.println(e);
    }
    }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Test{
public static void main(String args[]){
FileInputStream fis = null;
FileOutputStream fos = null;
try{
fis = new FileInputStream("e:/read.txt");
fos = new FileOutputStream("e:/write.txt");
byte[] buffer = new byte[100];
int temp = fis.read(buffer,0,buffer.length);
fos.write(buffer,0,temp);
}
catch(Exception e){
System.out.println(e);
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class Test{
public static void main(String args[]){
FileInputStream fis = null;
FileOutputStream fos = null;
try{
fis = new FileInputStream("e:/read.txt");
fos = new FileOutputStream("e:/write.txt");
byte[] buffer = new byte[1024];
while(true){
int temp = fis.read(buffer,o,buffer.length);
if(temp = -1){
break;
}
fos.write(buffer,0,temp);
}
}catch(Exception e){
System.out.println(e);
}finally{
try{
fis.close();
fos.close();
}catch(Excepiton e){
System.out.println(e);
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
//字符流
public class TextChar
public static void main(String args[]){
FileReader fr = null;
FileWriter fw = null;
try{
fr = new FileReader("e:/read.txt");
fw = new FileWriter("e:/write.txt");

char[] buffer = new char[100];
int temp = fr.read(buffer,0,buffer.length);
fw.write(buffer,0,temp);
}
catch(Exception e){
System.out.println(e);
}finally{
try{
fr.close();
fw.close();
}
catch(Excepiton e){
System.out.println(e);
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
//FileReader和BufferedReader
class Test{
public static void main(String args[]){
FileReader fileReader = null;
BufferedReader bufferedReader = null;
try{
fileReader = new FileReader("e:/read.txt");
bufferedReader = new BufferedReader(fileReader);
String line = null;
while(true){
line = bufferedReader.readLine();
if(line == null){
break;
}
System.out.println(line);
}
}catch(Exception e){
System.out.println(e);
}
finally{
try{
bufferedReader.close();
fileReader.close();
}
catch(Exception e){
System.out.println(e);
}
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class Test{
public static void main(String[] args) throws Exception{
//字节流
FileInputStream in = new FileInputStream("c:/read.txt");
FileOutStream out = new FileOutputStream("c:/write.txt");
byte[] buffer = new byte[1024];
int len;
while( (len = in.read(buffer)) != -1){
out.write(buffer,0,len);
}
in.close();
out.close();
//字符流
BufferedReader bf = new BufferedReader(new FileReader("c:/read.txt");
BufferedWriter bw = new BufferedWriter(new FileWriter("c:/write.txt");
String str;
while( (str=bf.readLine()) != null ){
bw.write(str);
bw.newLine();
}
bf.close();
bw.close();
}
}
  • 字节流: InputStream字节输入流,OutputStream字节输出流
  • 字符流 : Reader字符输入流 ,Writer字符输出流
  • 数据流: DataInputStream 数据输入流 ,DataOutputStream 数据输出流

集合框架

一组类和接口,位于java.util包,主要用于存储和管理对象,主要分为三大类—集合,列表和映射。

什么是集合(Set)
集合中对象是没有顺序的,并且没有重复对象;

什么是列表(List)
集合中对象可以有重复的对象,可以按照顺序取,也可以指定取。

什么是映射(Map)
每一个元素包含一个键对象和一个值对象,键不可以重复,值可以重复。

类集框架主体结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
interface
Iterator Collection
ListIterator List Set Map
LinkeList ArrayList HashSet SortedSet HashMap SortedMap
LinkedHashSet TreeSet LinkedHashMap TreeMap
Comparable Comparator Collections Arrays

//arrayList默认10,可无限长,关于泛型

public class Test{
public static void main(String args[]){

//ArrayList arrayList = new ArrayList();
ArrayList<String> arrayList = new ArrayList<String>();

arrayList.add("a");
arrayList.add("b");
arrayList.add("c");

//String s = arrayList.get(1);
//System.out.println(s);

for(int i=0;i<3;i++){
String s = arrayList.get(i);
System.out.println(s);
}

}
}

优化

public class Test{
public static void main(String args[]){
ArrayList<String> arrayList = new ArrayList<String>();

arrayList.add("a");
arrayList.add("b");
arrayList.add("c");
arrayList.add("d");

for(int i = 0; i<arrayList.size();i++){
String s = arrayList.get(i);
System.out.println(s);
}
}
}

类集框架

集合 无序 不可重复
列表 有序 可重复
映射

Set继承了Collection

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
public class Test{
public static void main(String args[]){

//HashSet<String> hashSet = new HashSet<String>();
//Set<String> set = new HashSet<String>();

//别管就是转,方便
Set<String> set = new HashSet<String>();
set.add("a");
set.add("b");
set.add("c");
set.add("d");

int i = set.size();

System.out.println(i);

}
}

不可以重复

public class Test{
public static void main(String args[]){

//HashSet<String> hashSet = new HashSet<String>();
//Set<String> set = new HashSet<String>();

//别管就是转,方便
Set<String> set = new HashSet<String>();

boolean b1 = set.isEmpty();
System.out.println(b1);

set.add("a");
set.add("b");
set.add("c");
set.add("d");
set.add("c");

boolean b2 = set.isEmpty();
System.out.println(b2);

int i = set.size();

System.out.println("clear之前的长度"+i);

set.clear();

int j = set.size();

System.out.println(j);

}
}

取数据,迭代 iterate器 (Iterator)

public class Test{
public static void main(String args[]){
//HashSet<String> hashSet = new HashSet<String>();
//Set<String> set = hashSet;
//Iterator <-- Collection <-- Set <-- HashSet
//hasNext() next()

Set<String> set = new HashSet<String>();

set.add("a");
set.add("b");
set.add("c");
set.add("d");
set.add("c");

Iterator<String> it = set.iterator();

boolean b1 = it.hasNext();
if(b1){
String s = it.next();
System.out.println(s);
}

boolean b2 = it.hasNext();
if(b2){
String s = it.next();
System.out.println(s);
}

}
}

迭代器的使用
it.hasNext();
还有没有下一个元素,如果这个游标后面有元素就返回true,否则,false;

it.next();
返回游标所指位置的下一个元素,取出,用hasNext()看有没有,next取

优化
public class Test{
public stattic void main(String args[]){
Set<String> set = new HashSet<String>();

set.add("a");
set.add("b");
set.add("c");
set.add("d");
set.add("c");

Iterator<String> it = set.iterator();

while(it.hasNext()){
String s = it.next();
System.out.println(s);
}
}
}

什么是映射(Map)
每一个元素包含一个键对象和一个值对象,键不可以重复,值可以重复。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public class Test{
public static void main(String args[]){
HashMap<String,String> hasMap = new HashMap<String,String>();
Map<String,String> map = hasMap;

map.put("1","a");
map.put("2","b");
map.put("3","c");
map.put("4","d");

int i = map.size();
System.out.println(i);
}
}

public class Test{
public static void main(String args[]){
HashMap<String,String> hasMap = new HashMap<String,String>();
Map<String,String> map = hasMap;

map.put("1","a");
map.put("2","b");
map.put("3","c");
map.put("4","d");
map.put("3","e");

int i = map.size();
System.out.println(i);

String s = map.get("3");
System.out.println(ss);
}
}

1
2
3
4
5
6
7
8
9
10
11
12
public class TestCollection {
public static void main(String[] args) {
List<Hero> heros = new ArrayList<Hero>();
for (int i = 0; i < 5; i++) {
heros.add(new Hero("hero name " + i));
}
for (int i = 0; i < heros.size(); i++) {
Hero h = heros.get(i);
System.out.println(h);
}
}
}

总结

  • 本文讲了详细讲解Java中的异常处理情况与I/O流的介绍以及类集合框架,如果您还有更好地理解,欢迎沟通
  • 定位:分享 Android&Java知识点,有兴趣可以继续关注
-------------本文结束感谢您的阅读-------------
达叔小生 wechat
欢迎您扫一扫上面的微信公众号,订阅我的博客!
坚持原创技术分享,您的支持将鼓励我继续创作!
0%