更多内容,前往 IT-BLOG

一、File


File 类(磁盘操作)可以用于表示文件和目录的信息,但是它不表示文件的内容。递归地列出一个目录下所有文件:

 1 public static void listAllFiles(File dir) {
2 if (dir == null || !dir.exists()) {
3 return;
4 }
5 if (dir.isFile()) {
6 System.out.println(dir.getName());
7 return;
8 }
9 for (File file : dir.listFiles()) {
10 listAllFiles(file);
11 }
12 }

二、IO 概述


什么是 IO:磁盘与内存之间的数据交互,可以看做是一种数据的流动,按照流动方向,以内存为基准,分为输入 input 和输出 output,即流向内存的是输入流,流出内存的是输出流。Java IO操作主要是指使用 java.io包下的内容,进行输入、输出操作。输入也叫读取数据,输出也叫写出数据。

IO 的分类:根据数据的流向分为:输入流和输出流。根据数据的类型分为:字节流(以字节为单位)和字符流(以字符为单位)。

  输入流 输出流
字节流 InputStream OutputStream
字符流 Reader Writer

三、字节流


一切文件数据(文本、图片、视频)在存储时,都是以二进制数字的形式保存,传输时也是如此。所以,字节流可以传输任意文件数据,在操作流的时候,我们要时刻明确,无论使用什么样的流对象,底层传输始终为二进制数据。

字节输入流【InputStream】:java.io.InputStream 抽象类是表示字节输入流的所有类的超类,可以读取字节信息到内存。它定义了字节输入流的基本共性。

public abstract int read()

从输入流读取数据的下一个字节

public int read(byte b[] b)

从输入流中读取一些字节数,并将它们存储到字节数组b中

public int read(byte b[] b, int off, int len)

off 写入数据的位置,数组中的起始偏移量。从输入流读取多达len字节的数据到字节数

public void close()

关闭此输入流并释放与此流相关联的任何资源

 1 // 读取数据
2 public abstract int read()
3
4 // 将读取到的数据放在 byte 数组中,该方法实际上是根据下面的方法实现的,off 为 0,len 为数组的长度
5 public int read(byte b[])
6
7 // 从第 off 位置读取 len 长度字节的数据放到 byte 数组中,流是以 -1 来判断是否读取结束的
8 public int read(byte b[], int off, int len)
9
10 // 跳过指定个数的字节不读取,想想看电影跳过片头片尾
11 public long skip(long n)
12
13 // 返回可读的字节数量
14 public int available()
15
16 // 读取完,关闭流,释放资源
17 public void close()
18
19 // 标记读取位置,下次还可以从这里开始读取,使用前要看当前流是否支持,可以使用 markSupport() 方法判断
20 public synchronized void mark(int readlimit)
21
22 // 重置读取位置为上次 mark 标记的位置
23 public synchronized void reset()
24
25 // 判断当前流是否支持标记流,和上面两个方法配套使用
26 public boolean markSupported()

字节输出流【OutputStream】 :java.io.OutputStream 抽象类是表示字节输出流的所有类的超类,它定义了字节流的基本共性功能方法。

public abstract void write(int b)

将指定的字节写入此输出流

public void write(byte b[])

将 b.length字节从指定的字节数组写入此输出流

public void write(byte b[], int off, int len)

从指定的字节数组写入 len字节,从偏移量 off开始输出到此输出流

public void flush()

刷新此输出流并强制任何缓冲的输出字节被写出

public void close()

关闭此输出流并释放此流相关联的任务系统资源
 1 //写入一个字节,可以看到这里的参数是一个 int 类型,对应上面的读方法,int 类型的 32 位,只有低 8 位才写入,高 24 位将舍弃。
2 public abstract void write(int b)
3
4 // 将数组中的所有字节写入,和上面对应的 read() 方法类似,实际调用的也是下面的方法。
5 public void write(byte b[])
6
7 // 将 byte 数组从 off 位置开始,len 长度的字节写入
8 public void write(byte b[], int off, int len)
9
10 // 强制刷新,将缓冲中的数据写入
11 public void flush()
12
13 // 关闭输出流,流被关闭后就不能再输出数据了
14 public void close()

四、文件流


FileInputStream 把硬盘中的数据读取到内存中

 1 /**
2 * java.io.InputStream: 字节输入流。 此抽象类是表示字节输入流的所有类的超类。
3 * java.io.FileInputStream extends InputStream: 文件输入流
4 * 作用:把硬盘文件中的数据,读取到内存中
5 *
6 * 构造方法:public FileInputStream(String name) 文件路径
7 * public FileInputStream(File file) 文件
8 * 构造方法的作用:
9 * 1、创建一个 FileInputStream 对象;
10 * 2、会把 FileInputStream对象指向构造方法中创建的文件
11 * java程序--JVM--OS读取方法--读取文件
12 * 1个中文 GBK占两个字节 UTF-8占3个字节
13 */
14 public class MyInputStream {
15 public static void main(String[] args) {
16
17 FileInputStream fis = null;
18 /**
19 * JDK7 新特性【了解】 在 try 后边可以增加一个() ,在括号中定义流对象,那么这个流对象的作用域就在 try中有效,
20 * try 中的代码执行完毕,会自动把流对象释放,不用写 finally。多个流用 ;号隔开
21 * 例如: try(FileInputStream fis = new FileInputStream("test.txt");
22 * FileOutputStream fos = new FileOutputStream("test.txt");){}
23 *
24 * JDK9 新特性【了解】
25 * 在 try前边定义流对象
26 * 在 try 括号中引入流对象名称 ,不用写 finally
27 * 例如:
28 * FileInputStream fis = new FileInputStream("test.txt");
29 * FileOutputStream fos = new FileOutputStream("test.txt");
30 * try(fis ; fos){}
31 */
32 try {
33 //1、创建 FileInputStream对象,参数为绑定的数据源
34 fis = new FileInputStream("D:/test.txt");
35 //2、读取文件 read ,当读到结尾的时候返回 -1 , 注意需要用一个变量来接收 read返回值,不要读两次
36 /*int len = 0;
37 while((len = fis.read())!= -1){
38 System.out.println((char)len);
39 };*/
40 /**
41 * 一次读取多个字节的方法,byte[] 起到缓冲作用,存储每次读取到的字节个数。数组的长度一般定义为1024(1kb)或整数倍
42 */
43 byte[] bytes = new byte[2];
44 int lens = fis.read(bytes);
45 System.out.println(lens);//2 每次读取字节的个数
46 System.out.println(Arrays.toString(bytes)); //[97, 98]
47 System.out.println(new String(bytes));//ab
48 } catch (IOException e) {
49 e.printStackTrace();
50 }finally {
51 if(fis != null){
52 //3、关闭流
53 try {
54 fis.close();
55 } catch (IOException e) {
56 e.printStackTrace();
57 }
58 }
59 }
60 }
61 }

FileOutputStream 把内存中的数据写入到硬盘的文件中

 1 /**
2 * FileOutputStream: 文件输出流,将内存数据写入到文件中
3 * 构造方法: FileOutputStream(String name) 传入一个文件的路径
4 * FileOutputStream(File file) 传入一个文件
5 * FileOutputStream(String name,boolean append) 当 append为true 的时候,就不会覆盖文件,继续在文件的末尾追加写数据
6 * 构造方法的作用:
7 * 1、创建一个 FileOutputStream 对象
8 * 2、会根据构造方法中传递的文件/文件路径,创建一个空的文件
9 * 3、会把 FileOutputStream 对象指向创建好的文件
10 * 写数据的原理
11 * java程序---JVM--- OS(操作系统)---将数据写入文件中
12 * 写换行:换行符
13 * windows \r\n
14 * linux /n
15 * max /r
16 */
17 public class MyOutputStream {
18 public static void main(String[] args) {
19 FileOutputStream fos = null;
20 {
21 try {
22 //1、创建一个 FileOutputStream对象
23 fos = new FileOutputStream("D:/test.txt");
24 /**
25 * 2、调用 FileOutputStream对象的 writer方法,将数据写入文件
26 * 会把十进制的整数,转为二进制存入硬盘.任意的记事本,打开时都会查询编码表,把字节转为字符表示。查询 ASKII码
27 * 所以 test.txt中存的是 d
28 */
29 fos.write(100);
30 //写出多个字节
31 byte[] b = "你好".getBytes();
32 fos.write(b);
33 } catch (IOException e) {
34 e.printStackTrace();
35 }finally {
36 if(fos != null){
37 //3、释放资源,流使用会占用一定的内存,因此需要释放
38 try {
39 fos.close();
40 } catch (IOException e) {
41 e.printStackTrace();
42 }
43 }
44 }
45 }
46 }
47 }

五、字符流


当使用字节流读取文本时,可能会有一个问题。就是遇到中文字符时,可能不会显示完整的字符,因为一个中文字符可能占用多个字节存储。所以 Java提供一些字符流,以字符为单位读写数据,专门用于处理文本文件。

字符输入流【Reader】:java.io.Reader 抽象类是读取字符流所有类的超类,可以读取字符信息到内存中。它定义了字符输入流的基本共性功能方法:

public int read()

从输入流读取一个字符

public int read(char cbuf[])

从输入流中读取一些字符,并将它们存储到字符数组 cbuf中

abstract public void close()

关闭此流并释放与此流相关联的任何系统资源

FileReader 文件字符输入流,继承 InputStreamReader 。

 1 /**
2 * 字符输入流 Reader 输入流的最顶层父类
3 * FileReader 构造方法:
4 * FileReader(String fileName)
5 * FileReader(File file)
6 * 作用:
7 * 1、创建一个 FileReader 对象
8 * 2、会把 FileReader 对象指向要读取的文件
9 *
10 *
11 */
12 public class MyReader {
13 public static void main(String[] args) {
14 FileReader fr = null;
15 try {
16 //1、创建 FileReader对象,参数中绑定读取的资源
17 fr = new FileReader("test.txt");
18 //2、使用 read读取当个字符并返回
19 int len = 0;
20 /*while((len = fr.read()) != -1){
21 System.out.print((char)len); //你好!
22 }*/
23 //读取多个字符
24 char[] cs = new char[1024];
25 while((len = fr.read(cs)) != -1){
26 System.out.printf(new String(cs,0,len));
27 }
28 } catch (IOException e) {
29 e.printStackTrace();
30 }finally {
31 if(fr != null){
32 //3、释放资源
33 try {
34 fr.close();
35 } catch (IOException e) {
36 e.printStackTrace();
37 }
38 }
39 }
40 }
41 }

字符输出流【Writer】:java.io.Writer 抽象类是所有输出字符流的最顶层父类。它定义了字符输入流的基本共性功能方法:

public void write(int c)

写入单个字符

public void write(char cbuf[])

写入字符数组

abstract public void write(char cbuf[], int off, int len)

写入字符数组的某一部分

public void write(String str)

写入字符串

public void write(String str, int off, int len)

写入字符串的某一部分

abstract public void flush()

刷新流的缓冲

abstract public void close()

关闭此流,但先要刷新它

FileWriter 文件字符输出流,继承 OutputStreamReader

 1 /**
2 * FileWriter 文件字符输出流
3 * 作用:把内存中的数据写入到文件中
4 * 构造方法:
5 * public FileWriter(String fileName) 传入文件的路径
6 * public FileWriter(File file) 传入一个文件
7 * public FileWriter(String fileName , boolean append) 传入文件的路径 append=true 的时候不覆盖文件,在文件后面 append的输出
8 * * public FileWriter(File file , boolean append) 传入一个文件
9 * 构造方法的作用:
10 * 1、会创建一个 FileWriter对象;
11 * 2、会创建一个文件,根据传入的参数
12 * 3、将 FileWriter对象指向创建好的文件
13 */
14 public class MyWriter {
15 public static void main(String[] args) {
16 FileWriter fw = null;
17 try {
18 //1、创建 FileWriter对象,绑定要写入数据的目的地
19 fw = new FileWriter("test.txt");
20 //2、使用 writer 将数据写入到内存缓冲区中(字符转化为字节的过程)
21 char[] cs = {'a','b','c'};
22 fw.write(cs);
23 fw.write("你好!");
24 //3、使用 flush 将缓冲区中的数据刷新到文件中
25 //fw.flush();
26 } catch (IOException e) {
27 e.printStackTrace();
28 }finally {
29 if(fw != null){
30 //4、关闭流,会触发 flush方法
31 try {
32 fw.close();
33 } catch (IOException e) {
34 e.printStackTrace();
35 }
36 }
37 }
38 }
39 }

六、Properties 集合


 1 /**
2 * java.util.Properties 集合 extends Hashtable<k,v>
3 * Properties 类表示一个持久的属性集。Properties 可保存在流中或从流中加载。
4 * Properties 集合是一个唯一和 IO流相结合的集合,
5 * 可以使用集合中的方法 store() ,把集合中的临时数据,持久化到硬盘中
6 * load(), 把硬盘中的数据读取到集合中
7 * Properties 集合是一个双列集合,key 和 value 都是字符串
8 *
9 */
10 public class MyProperties {
11 public static void main(String[] args) {
12 // 使用 Properties 集合存储数据,遍历取出数据
13 //1、创建 Properties 对象
14 Properties prop = new Properties();
15 //2、添加数据
16 prop.setProperty("you","小三");
17 prop.setProperty("mine","正房");
18 prop.setProperty("she","小四");
19 /**
20 * 3、将数据写入到磁盘中保存
21 * store(OutputStream out, String comments)
22 * store(Writer writer, String comments) 可以写中文
23 */
24 FileReader fr = null;
25 FileWriter fw = null;
26 try {
27 fw = new FileWriter("test.txt");
28 fr = new FileReader("test.txt");
29 /**
30 * 文件中的内容如下:
31 * #save data
32 * #Sun Nov 01 16:26:13 CST 2020
33 * you=小三
34 * she=小四
35 * mine=正房
36 */
37 prop.store(fw, "save data"); //第二个参数是注释
38
39 /**
40 * load 将文件中的数据读取:
41 * 存储键值对的文件中,键与值默认的连接符号可以是 =,空格(其它符号)
42 * # 表示注释
43 * 键和值默认都是字符串
44 */
45 Properties propRead = new Properties();
46 propRead.load(fr);//将在数据到 Properties
47 Set<String> strings = propRead.stringPropertyNames();//获取 key列表
48 /**
49 * 输入为:
50 * you = 小三
51 * she = 小四
52 * mine = 正房
53 */
54 for(String key: strings){
55 System.out.println(key + " = " + propRead.get(key));
56 }
57
58 } catch (IOException e) {
59 e.printStackTrace();
60 }finally {
61 if(fw != null && fr != null){
62 try {
63 fw.close();
64 fr.close();
65 } catch (IOException e) {
66 e.printStackTrace();
67 }
68 }
69 }
70 }
71 }

七、缓冲流


缓冲流也叫高效流,是对 4个基本的 Filexxx流的增强,所以也是4个流,按照数据类型分为:
【1】字节缓冲流:BufferedInputStream,BufferedOutputStream
【2】字符缓冲流:BufferedReader,BufferedWriter
缓冲流的基本原理,是在创建流对象时,会创建一个内置的默认大小的缓冲数组,通过缓冲区读写,减少系统 IO次数,从而提高效率。

字节缓冲输出流:BufferedOutputStream

 1 /**
2 * 继承 OutputStream 提高写入效率
3 * 构造方法:
4 * BufferedOutputStream(OutputStream out) 创建一个新的缓冲区输出流,以将数据写入指定的底层输出流,默认缓冲区大小= 8192
5 * BufferedOutputStream(OutputStream out, int size) 创建一个新的缓冲区输出流,以将具体指定缓冲区大小的数据写入底层输出流
6 */
7 public class MyBufferedOutputStream {
8 public static void main(String[] args) {
9 FileOutputStream fos = null;
10 BufferedOutputStream bos = null;
11 try {
12 //1、创建字节输出流 FileOutputStream
13 fos = new FileOutputStream("test.txt");
14 //2、创建缓冲流 BufferedOutputStream
15 bos = new BufferedOutputStream(fos);
16 //3、使用 writer 方法写入内部缓冲区中
17 bos.write("使用内部缓冲区".getBytes());
18 //4、flush 将内部缓冲区的数据刷新到文件中
19 bos.flush();
20 } catch (IOException e) {
21 e.printStackTrace();
22 }finally {
23 if(bos != null){
24 //5、close 关闭流,会先执行 flush后关闭
25 try {
26 bos.close(); //会自动关闭 fos.close();
27 } catch (IOException e) {
28 e.printStackTrace();
29 }
30 }
31 }
32 }
33 }

字节缓冲输入流:BufferedInputStream

 1 /**
2 * 继承 InputStream 称为 字节缓冲输入流
3 * 构造方法:
4 * BufferedInputStream(InputStream in)
5 * public BufferedInputStream(InputStream in, int size)
6 */
7 public class MyBufferedInputStream {
8 public static void main(String[] args) {
9 //1、创建 FileInputStream对象
10 FileInputStream fis = null;
11 BufferedInputStream bis = null;
12 try {
13 fis = new FileInputStream("test.txt");
14 //2、创建 BufferedInputStream 对象,提高 FileInputStream对象读取的效率
15 bis = new BufferedInputStream(fis);
16 //3、使用 read方法读取数据
17 int len = 0;
18 byte[] bytes = new byte[1024];
19 while((len = bis.read(bytes)) != -1){
20 System.out.println(new String(bytes,0,len));
21 }
22 } catch (IOException e) {
23 e.printStackTrace();
24 }finally {
25 //4、关闭流
26 if(bis != null){
27 try {
28 bis.close(); //自动关闭 fis
29 } catch (IOException e) {
30 e.printStackTrace();
31 }
32 }
33 }
34 }
35 }

BufferedWriter :新方法  newLine() 表示换行,替换了 “\r\n" BufferedReader:新方法 readLine() 读取一个文本行,读取一行数据。如果到达流末尾,则返回 null。

八、转换流


字符编码 Character Encoding:就是一套自然语言的字符与二进制数之间的对应规则;
字符集 Charset:也叫编码表。是一个系统支持的所有字符的集合,包括各国家文字、标点符号、图形符号、数字等。常见字符集有 ASCII、GBK、Unicode字符集。

在 IDEA中,使用 FileReader读取项目中的文本文件,由于 IDEA 默认使用 UTF-8编码,所有没有任何问题。但是当读取 Windows系统中创建的文本文件时,由于 Windows系统的默认是 GBK编码,就会出现乱码。

转化流  InputStreamReader:是 Reader的子类,是从字节流到字符流的桥梁,他读取字节,并使用指定的字符集将其解码为字符,它的字符集可以由名称指定,也可以接收平台默认的字符集。

 1 /**
2 * InputStreamReader:是 Reader的子类,是从字节流到字符流的桥梁,他读取字节,并使用指定的字符集将其解码为字符,它的字符集可以由名称指定,也可以接收平台默认的字符集。
3 * 构造方法:
4 * InputStreamReader(InputStream in)
5 * InputStreamReader(InputStream in, String charsetName)
6 */
7 public class MyInputStreamReader {
8 public static void main(String[] args) {
9 //1、创建 InputStreamReader对象,构造方法中传入字节输入流和指定的编码表名称 指定的编码要与文件的编码相同,否则会发生乱码;
10 InputStreamReader isr = null;
11 try {
12 isr = new InputStreamReader(new FileInputStream("text.txt"), "GBK");
13 //2、使用 read 方法读取文件
14 int len = 0;
15 while((len = isr.read()) != -1){
16 System.out.println((char)len);
17 }
18 } catch (IOException e) {
19 e.printStackTrace();
20 }finally {
21 if(isr != null){
22 //3、释放资源
23 try {
24 isr.close();
25 } catch (IOException e) {
26 e.printStackTrace();
27 }
28 }
29 }
30 }
31 }

OutputStreamWriter:是 Writer的子类,是从字符流到字节流的桥梁,他写入数据,并使用指定的字符集将其编码为字符,它的字符集可以由名称指定,也可以接收平台默认的字符集。

 1 /**
2 * java.io.OutputStreamWriter 继承了 Writer
3 * OutputStreamWriter 是字符流通向字节流的桥梁,可使用指定的 charset 将要写入流中的字符编码成字节。
4 * 构造方法:
5 * OutputStreamWriter(OutputStream out) 使用默认的字符编码
6 * OutputStreamWriter(OutputStream out, Charset cs) 可以指定字符编码,不区分大小写
7 *
8 */
9 class MyOutputStreamWriter {
10 public static void main(String[] args) {
11 //1、创建一个 OutputStreamWriter 对象
12 OutputStreamWriter osw = null;
13 try {
14 osw = new OutputStreamWriter(new FileOutputStream("text.txt"), "GBK");
15 //2、使用 writer 写出数据
16 osw.write("你好");
17 //3、flush 刷新数据
18 osw.flush();
19 } catch (UnsupportedEncodingException e) {
20 e.printStackTrace();
21 } catch (IOException e) {
22 e.printStackTrace();
23 }finally {
24 //4、关闭流
25 if(osw != null){
26 try {
27 osw.close();
28 } catch (IOException e) {
29 e.printStackTrace();
30 }
31 }
32 }
33 }
34 }

九、序列化流


把对象以流的方式写入到文件中保存,对象中不仅仅是字符,也有字节。就有了 ObjectOutputStream[对象的序列化 writeObject(p)] 和 ObjectInputStream[对象的反序列化 readObject()]

ObjectOutputStream 对象序列化流:

 1 /**
2 * java.io.ObjectOutputStream extends OutputStream
3 * 构造器:
4 * ObjectOutputStream(OutputStream out) 创建写入指定 OutputStream 的 ObjectOutputStream
5 * 特有的成员方法:writeObject
6 */
7 public class MyObjectOutputStream {
8 public static void main(String[] args) {
9 //1、创建 ObjectOutputStream 对象,构造方法中传递字节输出流
10 ObjectOutputStream oos = null;
11 try {
12 oos = new ObjectOutputStream(new FileOutputStream("text.txt"));
13 //2、通过 writeObject 把对象写入到文件中
14 oos.writeObject(new Person("张三",1));//通过二进制序列化流存储的,无法打开查看。
15 } catch (IOException e) {
16 e.printStackTrace();
17 }finally {
18 //3、关闭流
19 try {
20 oos.close();
21 } catch (IOException e) {
22 e.printStackTrace();
23 }
24 }
25 }
26 }

ObjectInputStream 对象反序列化流

 1 /**
2 * java.io.ObjectInputStream 继承了 InputStream 将对象从文件中读取使用
3 * 构造方法:
4 * ObjectInputStream(InputStream in) 创建从指定 InputStream 读取的 ObjectInputStream
5 * 特有的方法:
6 * readObject() 返回一个 object对象
7 *
8 * transient 关键字:
9 * static 关键字:静态关键字,被 static修饰的成员变量不能被序列化的,序列化的都是对象的默认值。transient 与 static的作用是一样的,但却没有 static的含义
10 * Person对象需要实现 Serializable 并且要定义序列化ID
11 * 集合类的存储和对象相同
12 */
13 public class MyObjectInputStream {
14 public static void main(String[] args) {
15 //1、创建 ObjectInputStream对象,构造方法中传递字节输入流
16 ObjectInputStream ois = null;
17 try {
18 ois = new ObjectInputStream(new FileInputStream("text.txt"));
19 //2、使用 readObject 方法读取对象
20 Person o = (Person)ois.readObject();
21 //4、对象使用
22
23 } catch (Exception e) {
24 e.printStackTrace();
25 }finally {
26 if(ois != null){
27 //3、释放资源
28 try {
29 ois.close();
30 } catch (IOException e) {
31 e.printStackTrace();
32 }
33 }
34 }
35 }
36 }

十、打印流


PrintStream:我们常用的 System.out.println 就是打印流。

 1 /**
2 * 可以打印各种数据值表示形式,不会抛出 IOException,有特有的方法 print println
3 * 构造方法:
4 * PrintStream(File file) 输出的是一个文件
5 * PrintStream(OutputStream out) 输出的是一个字节输出流
6 * PrintStream(String fileName) 输出的是一个文件路径
7 * 继承了 OutputStream 拥有该成员中的方法
8 * 注意事项:如果使用继承自父类中的 write方法写数据,那么会查询编码表。如果使用 print 就会原样使用。
9 * 可以改变输出语句的目的地:System.setOut() 目的地通过参数传递
10 */
11 public class MyPrintStream {
12 public static void main(String[] args) throws FileNotFoundException {
13 //创建打印流,绑定要输出的目的地
14 PrintStream ps = new PrintStream("text.txt");
15 //使用 write 和 print写数据
16 ps.write(97);//文件中为 a
17 ps.print(97);//文件中为 97
18 //设置输出流打印的目的地
19 System.setOut(ps);
20 System.out.println("此打印信息会在 text.txt文件中显示");
21 //释放资源
22 ps.close();
23 }
24 }

十一、网络通信


【1】InetAddress:用于表示网络上的硬件资源,即 IP地址。没有公有的构造函数,只能通过静态方法来创建实例。

1 InetAddress.getByName(String host);
2 InetAddress.getByAddress(byte[] address);

【2】URL:统一资源定位符。可以直接从 URL中读取字节流数据。

 1 public static void main(String[] args) throws IOException {
2
3 URL url = new URL("http://www.baidu.com");
4
5 /* 字节流 */
6 InputStream is = url.openStream();
7
8 /* 字符流 */
9 InputStreamReader isr = new InputStreamReader(is, "utf-8");
10
11 /* 提供缓存功能 */
12 BufferedReader br = new BufferedReader(isr);
13
14 String line;
15 while ((line = br.readLine()) != null) {
16 System.out.println(line);
17 }
18
19 br.close();
20 }

【3】Sockets:使用 TCP协议实现网络通信;ServerSocket:服务器端类,Socket:客户端类。服务器和客户端通过 InputStream OutputStream 进行输入输出。

【4】Datagram:使用 UDP协议实现网络通信。DatagramSocket:通信类。DatagramPacket:数据包类。

思考:Java 字节读取流的 read方法返回 int的原因?


读取二进制数据按字节读取,每次读一个字节(byte)。read()的底层是由 C++实现的,返回的是 unsigned byte,取值范围为[0~255],在 java中 byte只能表示 [-128,127]的无符号数,所以只能用 int类型接收,Java接收得到的就是 int[0~255]

IO 流分类的更多相关文章

  1. IO流分类详细介绍和各种字节流类介绍与使用 过滤流 字节流

    Java基础笔记 – IO流分类详细介绍和各种字节流类介绍与使用 过滤流 字节流本文由 arthinking 发表于627 天前 ⁄ Java基础 ⁄ 评论数 1 ⁄ 被围观 2,036 views+ ...

  2. java io 流分类表

    Java输入/输出流体系中常用的流分类(表内容来自java疯狂讲义) 注:下表中带下划线的是抽象类,不能创建对象.粗体部分是节点流,其他就是常用的处理流. 流分类 使用分类 字节输入流 字节输出流 字 ...

  3. IO流分类

    IO流在java中从输入和输出角度分类: 1.输入流 2.输出流 IO流在java中从数据的角度来分类: 1.字符流:文本,我们能读懂的都可以认为是字符流,如:文章,java文件等 字符输入流的超类: ...

  4. Java IO流总结

    Java IO流分类以及主要使用方式如下: IO流 |--字节流 |--字节输入流 InputStream: int read();//一次读取一个字节 int read(byte[] bys);// ...

  5. Java API —— IO流( FileInputStream & FileOutputStream & BufferedInputStream & BufferedOutputStream )

    1.IO流概述 · IO流用来处理设备之间的数据传输        · 上传文件和下载文件        · Java对数据的操作是通过流的方式 · Java用于操作流的对象都在IO包中   2.IO ...

  6. java基础(十九)IO流(二)

    这里有我之前上课总结的一些知识点以及代码大部分是老师讲的笔记 个人认为是非常好的,,也是比较经典的内容,真诚的希望这些对于那些想学习的人有所帮助! 由于代码是分模块的上传非常的不便.也比较多,讲的也是 ...

  7. java学习第21天(IO流的使用)

    IO流分类: A:流向 输入流 读取数据 输出流 写出数据 B:数据类型 字节流 字节输入流 字节输出流 字符流 字符输入流 字符输出流 注意: a:如果我们没有明确说明按照什么分,默认按照数据类型分 ...

  8. java基础06 IO流

    IO用于在设备间进行数据传输的操作. Java IO流类图结构:   IO流分类 字节流: InputStream FileInputStream BufferedInputStream Output ...

  9. java中io流浅析

    1.java.io包下File类:java程序中的此类的一个对象,就对应着硬盘中的一个文件或网络中的一个资源.File file1 = new File("d:\\io\\helloworl ...

  10. IO流2

    一.IO流简介及分类 1.IO流简介 IO流: 简单理解数据从一个地方流向另外一个地方 2.IO流分类 按照数据流动的方向 分为  输入流和输出流 按照数据流动的单位分为   字节流和字符流 二.四大 ...

随机推荐

  1. docker 中搭建 mysql pxc 集群

      一.docker中创建pxc 容器 1.拉取PXC 镜像 pull docker pull percona/percona-xtradb-cluster:5.7.21 2.更改镜像名称为pxc t ...

  2. Linux文本文件及处理工具

    Linux中的文本信息 文本文件 C语言,Java语言等编程文件的源程序语言 文本格式的数据文件 文本格式的文字信息 在Linux下一切皆文件 everything is file,包括目录也是文件的 ...

  3. bzoj 3669

    思想基本同bzoj 2594,但是多了一步 首先我们发现这时的边有两个属性了,因此我们考虑先去掉其中一者的限制 我们把所有边按$a$大小排序,然后从小到大加入维护的最小生成树 每次加边时都按照$b$的 ...

  4. C# DataTable.Select()根据条件筛选数据

    1.前言: 很多时候我们获取到一个表的时候需要根据表的包含的队列去筛选内容,一般来说可能想到的就是遍历整个表的内容进行条件筛选,但是这种方式增加了代码量且易出错,DataTable.Select()就 ...

  5. 昨天写了个ATM系统,学了点思想

    昨天上黑马的基础课终结,有个小测验是做个ATM系统 拿到之后我就明白该怎么做了 但是在后面遇到了瓶颈 就是 不知道怎么进入下级菜单 后面稍微看了一下他的做法,学会了 就继续做了,后面就做出来了 他这个 ...

  6. .net core 接收并存储客户端上传的文件

    1 文件是上传到Host,非上传到阿里云OSS 2 在Program.cs或StartUp中使用静态文件的中间件 public void Configure(IApplicationBuilder a ...

  7. 01. JavaScript基础知识

    一.JavaScript简介   JavaScript 是一门解释型编程语言,解释型编程语言指代码不需要手动编译,而是通过解释器边解释边执行.所以,要运行 JS,我们需要在计算机中安装 JS 的解释器 ...

  8. jsp第十周

    数据库test 中建个表 stu(stuid 主键 自动增长 ,用户名,密码,年龄) 1.设计一个注册页面,实现用户注册功能2.设计一个登陆页面,实现用户名密码登陆3.两个页面可以互相超链接 Base ...

  9. docker安装nginx挂载启动

    docker pull nginx 命令安装 查找 Docker Hub 上的 nginx 镜像: docker search nginx 这里我们拉取官方的镜像 docker pull nginx ...

  10. Vue二级联动上传图片

    二级联动的后台和之前一样都需要一个字典字段查询来实现二级联动 但是由于VUE语法和AJAX的不同在前台绑定的时候也有所不同 2.1 首先下拉框的写法就有了本质的改变通过v-model="&q ...