字符流
Reader 读 Writer 写
Reader
用于读取字符流的抽象类 不能实例化
构造方法
public FileReader(File file) 参数是一个文件对象
public FileReader(String fileName) 参数 是文件的地址
子类
FileReader
FileReader 用于读取字符流。要读取原始字节流，请考虑使用 FileInputStream
1.实例化FileReader
2.调用读的方法
3.关闭资源
FileReader f=new FileReader("1.txt");
int l=0;
char[] ch =new char[1024];
while ((l=f.read(ch))!=-1){
System.out.println(new String(ch,0,l));
}
f.close();
FileWriter fw =new FileWriter("2.txt",true);
fw.write(ch);
fw.write("djsakhdka");
Writer
写入字符流的抽象类 不能实例化
子类
FileWriter
1. FileWriter 用于写入字符流。要写入原始字节流，请考虑使用 FileOutputStream
2.构造方法
public FileWriter(File file) 参数 文件对象
public FileWriter(File file,boolean append) 参数文件对象 append 是否覆盖 true 不覆盖
public FileWriter(String fileName) throws IOException 参数是文件的路径
7.使用字符来进行文件的copy
纯文本内容进行copy 没有必要使用字符流来进行操作，直接使用字节效率更高。
使用字符流是否可以读取 图片 音频 视频 不可以
因为使用字符流进行读写操作 是需要转换的 读取音频 视频 图片使用字节流进行读取
原因：
转换流
1.InputStreamReader 是字节流通向字符流的桥梁
2.可以指定其编码格式 使读写文件不出现乱码
3.为了达到最高效率，可要考虑在 BufferedReader 内包装 InputStreamReader
4.构造方法
public InputStreamReader(InputStream in,Charset cs）
OutputStreamWriter
1.OutputStreamWriter 是字符流通向字节流的桥梁
2.可以设置其写的编码格式
3.为了获得最高效率，可考虑将 OutputStreamWriter 包装到 BufferedWriter 中，以避免频繁调用转换器
4.构造
public OutputStreamWriter(OutputStream out, Charset cs)
out 输出流 cs 设置其编码格式
字符缓冲区流(高效)
BufferedRead
构造方法
public BufferedReader(Reader in) ==>实例化其子类n
独特的方法public String readLine() 读取一行
BufferedWriter
构造方法:public BufferedWriter(Writer out) 字符输出流
独有的方法 public void newLine() 表示换行
案例
需求
BufferedReader br=new BufferedReader(new FileReader("1.txt"));
BufferedWriter bw=new BufferedWriter(new FileWriter("2.txt"));
ArrayList<String> list=new ArrayList<>();
String str ="";
while ((str=br.readLine())!=null){
list.add(str);
}
for (int i= list.size()-1;i>=0;i--){
bw.write(list.get(i));
bw.newLine();
}
bw.close();
br.close();
线程
程序:一个固定逻辑与数据的集合
并行： 在同时一个时刻 两个或者是多个操作 同时执行 一般是发生在多核中 现在都是电脑都是多核
进程: 运行在内存中的程序就是进程
单线程: 只有一条执行通道通往cpu的路径 就是单线程 java中的程序路口就是单线程
多线程：有多条通向cpu 的执行的路径 就称为多线程
线程创建的第一种方式
步骤:
定义一个类 继承Thread类
重写其run() 方法 ==> 执行线程操作的方法
实例化这个线程的对象
调用线程的start() 方法表示开启线程
线程的调度方式:分配式调度 抢占式调度
分配式调度: 按照时间来进行分配 每一个操作执行cpu的执行的时间(每一个操作cpu执行的时间都是相同)
抢占式调度: 那个操作抢到cpu的执行权 那个操作去执行 java 中的线程就是抢占式进行调度
线程的名称
public final String getName(） ==> 返回的是当前线程名称 必须是在继承的前提下
2.第二种方式是通过获取当前线程 ==>再通过当前线程来调用 getName();
在第一种方法中，子类里能直接用getName()方法，在测试类中只能调用父类的getName和setName（string str） 方法。
2.通过构造方法来设置其名称
public Thread(String name)
线程休眠
1.public static void sleep(long millis) 是一个静态的方法
守护线程
3.新创建的线程不是守护线程 需要调用一个方法 还必须是在开启线程之前进行调用
public final void setDaemon(boolean on) 设置为true 表示是守护线程
public final boolean isDaemon() ==>用于来判断是否是守护线程
设置线程的优先级
1.三个常量
public static final int MAX_PRIORITY 最高优先级 10
public static final int MIN_PRIORITY 最低优先级 1
public static final int NORM_PRIORITY 默认的优先级 5
2.设置线程优先级的方法
public final void setPriority(int newPriority) 设置其优先级
public final int getPriority() 获取优先级的值
public class homeshiyan1Test extends Thread{
public homeshiyan1Test() {
}
public homeshiyan1Test(String name) {
super(name);
}
@Override
public void run() {
for (int i=0;i<100;i++)
{
System.out.println(getName()+"\t"+i);
}
}
}
public class homeShiyan1 {
public static void main(String[] args) throws InterruptedException {
homeshiyan1Test t =new homeshiyan1Test("lll");
homeshiyan1Test t1 =new homeshiyan1Test("lkj");
t.setDaemon(true);
System.out.println(t.isDaemon());
System.out.println(t.getPriority());
// t.setName("lkj");
t1.start();
t.start();
for (int i=0;i<100;i++)
{
Thread.sleep(100);
System.out.println(Thread.currentThread().getName()+"\t"+i);
}
}}
线程第二种创建方式
1.步骤(这种方式的底层也是也是的继承 就是为了解决java单继承的问题)
定义一个类 实现Runnable 接口
实现其抽象方法
实例化线程对象Thread 需要通过构造方法把定义的类传递进来
调用线程 start() 方法 开启线程
public class homeShiyan2Test implements Runnable{
@Override
public void run() {
for (int i=0;i<10;i++){
System.out.println(Thread.currentThread().getName()+"\t"+i);
}
}
}
使用匿名内部类创建多线程
1.匿名:没有名字
2.内部类: 在类的内部编写类
3.匿名内部类的语法:
new 抽象类|接口{
抽象方法
}
两种方法
public class homeShiyan2 {
public static void main(String[] args) {
homeShiyan2Test m =new homeShiyan2Test();
Thread t1=new Thread(m,"jkl");
Thread t2=new Thread(m,"ooo");
new Thread("uuu"){
@Override
public void run() {
for (int i=0;i<5;i++){
System.out.println(Thread.currentThread().getName()+"\t"+i);
}
}
}.start();
new Thread(new Runnable() {
@Override
public void run() {
for (int i=0;i<5;i++){
System.out.println(Thread.currentThread().getName()+"\t"+i);
}
}
}, "ppp").start();
t1.start();
t2.start();
}
}
线程通信的问题
解决访问
第一种使用同步代码块
同步代码块：可能出现线程安全的代码方法同步代码块中
语法:
synchronized (锁的对象){
//会出现线程安全的代码
}
第二种使用同步方法
语法：
访问修饰符 同步的关键字 返回值类型 方法的名称(){
可以出现线程安全问题的代码
}
第三种使用同步方法
使用jdk Lock锁对象
Lock 接口不能实例化 实例化其子类 ReentrantLock
Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。此实现允许更灵活的结构
两个方法
void lock() == >获取锁
void unlock() ==> 释放锁资源
使用的步骤
1.使用这个对象ReentrantLock
2. 在同步代码的前面调用lock()
3.在同步代码执行完毕之后 unlock() 释放锁资源
public class homeShiyan3 implements Runnable{
private int num=100;
private Lock lock=new ReentrantLock();
private Object object=new Object();
@Override
public void run() {
while (true){play();}
}
public synchronized void play(){
lock.lock();
/*synchronized (object){*/
try {
if (num>0){
Thread.sleep(500);
for (int i=1;i<=100;i++){
System.out.println(Thread.currentThread().getName()+"\t"+num);
num--;
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
lock.unlock();
}
/*}*/
}
}
扫一扫
3292
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
