缓冲流，转换流，对象流，进程，线程

最新推荐文章于 2023-08-14 16:53:28 发布
最新推荐文章于 2023-08-14 16:53:28 发布
阅读量460 收藏 1
点赞数
分类专栏： Java基础 JavaSE教学 线程/多线程 文章标签： IO流 线程 进程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xinxin_blog/article/details/46454621
版权
1. 缓冲流：过滤流，一定要套接节点流。
1) 字节：BufferedInputStream/BufferedOutputStream：内部带了一个缓冲区，把物理文件中的内容读取到内部缓冲区中，之后再从内部缓冲区中读取到程序中。

例：

package com.wx;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
/**
 * @author wx
 *  字节缓冲输入，输出流
 */
public class Test1 {
public static void main(String[] args) {
// TODO Auto-generated method stub
BufferedInputStream bis=null;
BufferedOutputStream bos=null;
try {
bis=new BufferedInputStream(new FileInputStream("d:"+File.separator+"123abc.jpg"));
bos=new BufferedOutputStream(new FileOutputStream("F:"+File.separator+"test.jpg"));

int i=bis.read();
while(i!=-1){
bos.write(i);
i=bis.read();
}
bos.flush();

} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
if(bis!=null){
try {
bis.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(bos!=null){
try {
bos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}   

2) 字符：BufferedReader/BufferedWriter：

例1：

package com.wx;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
/**
 * @author wx
 * 字符缓冲输出流  BufferedWriter
 */
public class Test2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
BufferedWriter bw=null;
try {
bw=new BufferedWriter(new FileWriter("d:"+File.separator+"a.txt"));
bw.write("第一行");
bw.newLine();
bw.write("第二行");
bw.newLine();
bw.write("第三行");
bw.flush();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
if(bw!=null){
try {
bw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

}
}


例2：
package com.wx;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
/**
 * @author wx
 * BufferedReader 字符缓冲输入流
 */
public class Test3 {
public static void main(String[] args) {
// TODO Auto-generated method stub
BufferedReader br=null;
try {
br=new BufferedReader(new FileReader("d:"+File.separator+"a.txt"));
String str=br.readLine();
while(str!=null){
System.out.println(str);
str=br.readLine();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
if(br!=null){
try {
br.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

}
}


2. 转换流：转换流用于在字节流和字符流之间转换。Jave SE API提供了两种转换流：

 1) InputStreamReader需要和InputStream“套接”，它可以将字节流中读入的字节解码成字符

例：

package com.wx;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
/**
 * @author wx
 *  InputStreamReader  字节解码成字符
 */
public class Test4 {
public static void main(String[] args) {
// TODO Auto-generated method stub
InputStreamReader isr=null;
try {
isr=new InputStreamReader(new FileInputStream("d:"+File.separator+"b.txt"),"iso-8859-1");
int i=isr.read();
while(i!=-1){
System.out.println((char)i);
i=isr.read();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
if(isr!=null){
try {
isr.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

}
}


 2) OutputStreamWriter需要和OutputStream“套接”，它可以将要写入字节流的字符编码成字节

例：

package com.wx;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
/**
 * @author wx
 * OutputStreamWriter 字符---》字节
 */
public class Test5 {
public static void main(String[] args) {
// TODO Auto-generated method stub
OutputStreamWriter osw=null;
try {
osw=new OutputStreamWriter(new FileOutputStream("d:"+File.separator+"b.txt"));
osw.write("张三");
osw.write("王五");
osw.flush();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
if(osw!=null){
try {
osw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}


3. 对象流：用于存储和读取基本类型数据或对象的过滤流

 1）ObjectOutputStream保存基本类型数据或对象：序列化

例：

package com.wx;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import com.model.Student;
/**
 * @author wx
 * 序列化
 */
public class Test6 {
public static void main(String[] args) {
// TODO Auto-generated method stub
ObjectOutputStream oos=null;
try {
oos=new ObjectOutputStream(new FileOutputStream("d:"+File.separator+"c.dat"));
oos.writeObject(new Student(1001,"张三",10,"北京"));

oos.flush();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
if(oos!=null){
try {
oos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}


 2）ObjectInputStream读取基本类型数据或对象：反序列化

例：

package com.wx;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
import com.model.Student;
/**
 * @author wx
 * 反序列化
 */
public class Test7 {
public static void main(String[] args) {
// TODO Auto-generated method stub
ObjectInputStream ois=null;
try {
ois=new ObjectInputStream(new FileInputStream("d:"+File.separator+"c.dat"));
Object obj=ois.readObject();
Student stu=(Student)obj;
System.out.println(stu.getId()+stu.getName()+stu.getAge()+stu.getAddress());
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
if(ois!=null){
try {
ois.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}


注意：
 1) 能被序列化的对象所对应的类必须实现java.io.Serializable这个标识性接口
    基本类型的包装类、String类、java.util.Date、java.util.Calendar类都实现了Serializable接口。
 2) transient关键字修饰成员变量时，表示这个成员变量是不需要序列化的。
    static修饰的成员变量也不会被序列化。
 3) 实现了Serializable接口的类都应该生成一个private static final long serialVersionUID 序列化版本ID作为标识。这个标识会序列化到流中

4. 其它流
 1) 数据流：DataInputStream/DateOutputStream
 2) 打印流：PrintStream/PrintWriter，这类流的操作永远不会抛出IO异常
 3) 随机访问文件：RandomAccessFile类
 
 5. 进程：一个正在运行的程序，有独立的内存空间。进程之间的切换开销大。
   线程：是进程中的一条执行路径，共享进程的内存空间。线程之间的切换开销小。

★6. 创建线程的两种方式：

   1) 继承自java.lang.Thread类，重写它的run()方法，run()方法体就是线程体。

例：

package com.wx;
/**
 * @author wx
 * 继承Thread类 创建线程
 */
public class Test8 {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("主线程执行了");

MyThread my=new MyThread();
//启动线程
my.start();
MyThread1 my1=new MyThread1();
my1.start();

System.out.println("主线程执行完毕");
}
}
/**
 * 线程类
 * @author wx
 *
 */
class MyThread extends Thread{
/* (non-Javadoc)
* @see java.lang.Thread#run()
*/
@Override
public void run() {
// TODO Auto-generated method stub
for(int i=1;i<=100;i++){
System.out.println("子线程1:"+i);
}
}

}

class MyThread1 extends Thread{
@Override
public void run() {
// TODO Auto-generated method stub
for(int i=1;i<=100;i++){
System.out.println("子线程2:"+i);
}
}
}


   2) 实现java.lang.Runnable接口，实现它的run()方法。把这个Runnable实例作为参数构造成Thread的实例 

例：

package com.wx;
/**
 * @author wx
 *  
 */
public class Test9 {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("主线程:"+Thread.currentThread().getName());
MyThread3 my=new MyThread3();
Thread t=new Thread(my);
t.setName("线程一:");
t.start();
System.out.println("线程是否活着:"+t.isAlive());
System.out.println("线程的状态:"+t.getState());
System.out.println("线程名称:"+t.getName());
System.out.println("主线程执行完毕");
}
}

class MyThread3 implements Runnable{
@Override
public void run() {
// TODO Auto-generated method stub
for(int i=1;i<=100;i++){
System.out.println("子线程1:"+i);
}
}
}


   启动方式：
   1) MyThread mt = new MyThread();  mt.start(); 
   2) MyRun mr = new MyRun();  Thread t = new Thread(mr);  t.start();

7. Thread类中常用方法：
   1) public static Thread currentThread(); //当前线程的引用
   2) public ClassLoader getContextClassLoader();
   // InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream("xxx.yyy");
   3) public String getName();
      public void setName(String name);
   4) public Thread.State getState();
   
8.线程的分类

用户线程:用户自己创建的线程
守护线程:专门给用户线程提供服务的就是守护线程。
GC就是典型的守护线程

为什么需要多线程?

提高用户体验
充分利用CPU
改善程序结构



例：

package com.wx;
/**
 * @author wx
 *用程序模拟铁路售票系统：实现通过四个售票点发售某日某次列车的1000张车票，一个售票点用一个线程表示。
 */
public class Test10 {
public static void main(String[] args) {
// TODO Auto-generated method stub
MyTickets my=new MyTickets();
//创建四个窗口
Thread t1=new Thread(my);
t1.setName("窗口一:");
t1.start();
Thread t2=new Thread(my);
t2.setName("窗口二:");
t2.start();
Thread t3=new Thread(my);
t3.setName("窗口三:");
t3.start();
Thread t4=new Thread(my);
t4.setName("窗口四:");
t4.start();
}
}

class MyTickets implements Runnable{
int count=0;
@Override
public void run() {
// TODO Auto-generated method stub
while(true){
if(count<100){
System.out.println(Thread.currentThread().getName()+"正在卖出第"+(count+1)+"票");
count++;
}else{
break;
}
}
}
}

 
xinxin_blog
关注
专栏目录
Java语言基础六之(IO流、多线程)
bier_zm的博客
08-15 1749
1、IO流 io ==> input & output分类 按读写数据的基本单位分类 -- 字节流 和 字符流。 其中字节流主要指以字节为单位进行数据读写的流，可以读写任意类型的文件。 其中字符流主要指以字符(2个字节)为单位进行数据读写的流，只能读写文本文件。 按照读写数据的方向不同分类 -- 输入流 和 输出流（站在程序的角度） 其中输入流主要指从文件中读取数据内容输入到程序中，也就是读文件。 其中输出流主要指将程序中的数据内容输出到文件中，也就是写文件。
C++ 进程与线程
最新发布
qq_37464701的博客
03-22 1226
程序：就是磁盘上的可执行文件，并且只占用磁盘上的空间，是一个静态的概念。进程：被执行后的程序就叫做进程，不占用磁盘空间，需要消耗系统的内存，CPU资源，每个运行的进程都对应一个属于自己的虚拟地址空间。？？？后面有空去了解下？？？CPU时间片：CPU在某个时间点只能处理一个任务，但是操作系统都支持多任务的，那么在计算机CPU只有一个的情况下是怎么完成任务处理的？原理和古时候救济灾民的思路是一样的，每个人分一点，但是又不叫吃饱。
Java缓冲流、转换流、对象流
weixin_46046653的博客
09-26 207
第一章 缓冲流 1.1 概述 缓冲流,也叫高效流，是对4个Filexxx流的增强，所以也是4个流，按照数据类型分类： 字节缓冲流：BufferedInputStream BufferedOutputStream 字符缓冲流：BufferedReader BufferedWriter 缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO 次数，从而提高读写的效率。 1.2 字节缓冲流 构造
IO的对象流,转换流,打印流
Takeit_easy的博客
03-30 632
IO的对象流,转换流,打印流
缓冲流与转换流
weixin_46649583的博客
12-28 117
缓冲流 BufferedReader 不需要自定义char数组，或者byte数组，自带缓冲。 构造方法：readLine()：读取一个文本行，返回一个String。 BufferedWriter BufferedInputStream BufferedOutputStream BufferedReader使用： /* BufferedReader：带有缓冲的字符输入流 */ public class BufferedReaderTes01 { public stat
阶段二33_面向对象高级_IO[转换流,对象流]
java之书-资源
04-17 260
1.转换流：InputStreamReader，OutputStreamWriter 2.对象流：ObjectInputStream，ObjectOutputStream
JavaIO 总结笔记<四> 缓冲流和转换流
AfinalStone的专栏
06-29 890
个人博客、个人简书、gitHub主页 一、缓冲流1.缓冲区 基本字节流没有缓冲区 基本字符流有缓冲区（8K）2.对于基本字节流，Java后来提供了字节流的缓冲流和字符流的缓冲流3.缓冲流java.io.BufferedInputStream 字节缓冲流(读) java.io.BufferedOutputStream 字节缓冲流(写) java.io.BufferedReader
IO流面试题共5页.pdf.zip
10-28
5. **多路复用流**：如PipedReader和PipedWriter用于创建进程间的通信，或者在单个线程内实现数据的内部传递。 6. **文件操作**：包括文件的读写、追加、复制、删除等操作，以及文件通道(FileChannel)的使用。 7. ...
输入、输出流和线程的文档
01-13
- **BufferedInputStream/BufferedOutputStream**：增加了缓冲机制的字节流，能够提高读写效率，默认缓冲大小为8192字节。 - **ObjectInputStream/ObjectOutputStream**： - **序列化**：将对象转换成字节序列，...
java基础面试题-----集合/线程/IO流详细版
奋斗中的小码农博客
01-25 2332
一、集合 集合是什么？ 答：集合可以看作是一个容器，例如：java类的书可以看作是一个集合；联想品牌的电脑也可以看作是一个集合；也就是分类存放的一个容器。对于集合中的对象可以很方便的存入和取出，还可以按照一定的顺序进行摆放。java中提供了不同的集合类，这些类具有不同的存储对象的方式，并提供了相应的方法以方便用户对集合进行遍历、添加、删除以及查找指定的对象。java集合类存放于java.uti...
【缓冲流、转换流、序列化流】
weixin_46932548的博客
05-28 149
【缓冲流、转换流、序列化流】 缓冲流 缓冲流，也叫高效流，是对4个基本的FileXxx流的增强，所以也是4个流，按照数据类型分为： 字节缓冲流：BufferedInputStream、BufferedOutputStream 字符缓冲流：BufferedReader、BufferedWriter 缓冲流的基本原理：是在创建对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区的读写，减少系统的IO次数，从而提高读写的效率。 字节缓冲流 字节缓冲输出流 java.io.BufferedOutputStr
转换流-数据流-对象流-打印流-标准输入输出流
qq_44273739的博客
08-14 132
把字节流转换为字符流，转换流是一种处理流。字节流有乱码的可能。假设input.txt文件中存放了字符串“abc中国”，使用字节流读取会乱码，使用字符流读取是使用平台默认的编码格式读取的，如果文本存储是不是平台的编码格式，也会出现乱码。转换流本质上就是加了编码格式的字符流。
对象的序列化----将对象转化成二进制数据流（读书摘录）
海沙
05-04 8659
较为常用的方案，Google的Protocal BUffers，java内置的序列化方式、Hessian，JSON 和XML。网络数据传输的是一个二进制的字节数组。把对象序列化为二进制字节数组和把二进制字节数组反序列化为对象的时间加起来，时间越少，性能越高。 Protocal BUffers性能优异，跨平台，需要些proto文件，无法直接用java对象。Hessian效率稍低，支持语言良好，性能
JavaIO流_中(IO原理、流的分类(节点流、缓冲流、转换流、输入输出流、对象流、打印流))
斗鹰的技术专栏
09-29 1508
IO流原理及流的分类 IO原理 I/O是Input/Output的缩写， I/O技术是非常实用的技术，用于处理设备之间的数据传输。如读/写文件，网络通讯等。 Java程序中，对于数据的输入/输出操作以“流(stream)” 的方式进行。 java.io包下提供了各种“流”类和接口，用以获取不同种类的数据，并通过标准的方法输入或输出数据。 输入input**：**读取外部数据（磁盘...
java对象转化为流_Java基础-IO流对象之转换流（InputStreamReader与OutoutStreamWriter）...
weixin_42113794的博客
02-23 1511
Java基础-IO流对象之转换流(InputStreamReader与OutoutStreamWriter)作者：尹正杰版权声明：原创作品，谢绝转载！否则将追究法律责任。一.转换流概述我们之前介绍过FileWrite和FileReader两个字符类，FileReader是用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在 FileIn...
java对象转化为流_java 对象流和转换流：Serializable、ObjectOutputStream 、ObjectInputStream、InputStreamReader、OutputS...
weixin_33657398的博客
02-23 445
作用：标准输入流(System)是为了读取控制台用户输入内容，标准输出流可以将内容从控制台输出，输出流又叫打印流(PrintWriter)，可以打印将内容打印到文件，或者将内容打印到控制台，具体可以通过构造方法实现控制如下：具体使用如下：(关键代码)：try {// 可以将内容写入到 文件中PrintWriter writer = new PrintWriter(new File("a.txt")...
java对象转化为流_Java I/O 流之转换流
weixin_35361584的博客
02-23 1770
一、转换流简介Reader 和 Writer 最重要的子类是 InputStreamReader 和 OutputStreamWriter 类。用来实现将字节流与字符流的相互转换，是字符流与字节流之间的桥梁。1、InputStreamReaderInputStreamReader 类包含了一个底层输入流，可以从中读取原始字节。它根据指定的编码方式，将这些字节转换为 Unicode 字符。构造方法：...
java基础7：io流对象之转换流
qq_3775566111的博客
11-13 954
1，OutputStreamWriter /* 通过以前的输入输出流读写数据时，不能指定编码，使用的是默认的gbk，这时候就要用到转换流了  *  转换流  *    java.io.OutputStreamWriter 继承Writer类  *    就是一个字符输出流，写文本文件  *    write()字符，字符数组，字符串  *      *    字符通向字节的桥梁，将字
java io流详解（二）对象输入输出流
flyingzc的博客
09-08 6484
1.对象输入输出流 ObjectOutputStream和ObjectInputStream可以用来实现对象序列化和反序列化操作。一般操作对象时，对象是存在内存中的，如果希望将对象保存在硬盘上，或者在网络间传输，这是需要将一个对象序列化为字节序列，这个过程就叫做对象的序列化操作。相应的，如果需要将该字节序列再转换为对应的对象，这个过程就是反序列化。java序列化时会保存类的所有信息，包括属性、方
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值