java io 多线程_Java IO流对象、多线程

Input(读) Output(写)操作

File类

import java.io.File;

将操作系统中的文件、目录(文件夹)、路径、封装成File对象

提供方法，操作系统中的内容。File与系统无关的类。

String pathSeparator = File.pathSeparator;

System.out.println(pathSeparator); // windows';' Linux ':' 路径分割符

String separator = File.separator;

System.out.println(separator); // 斜线 / 目录的名称分割符 linux: \

构造方法

File(String pathName)

绝对路径

在系统中具有唯一性 如：c:\users\baidawei\downloads

相对路径

表示的是路径之间的相对关系 如： /downloads/  不需要考虑根级目录具体盘符

创建文件

File file = new File("c:\\Users\\baidawei\\Downloads\\o.txt");

if(!file.exists()){

boolean result = file.createNewFile();

System.out.println(result);

}

Mac:

File file = new File("/Users/baidawei/Desktop/test.txt");

boolean result = file.createNewFile();

System.out.println(result);

创建目录

boolean result = file.mkdir();

删除

boolean result = file.delete();

获取文件名或文件夹名

String fileName = file.getName(); //test.txt

获取文件路径

file.getPath() // /Users/baidawei/Desktop/test.txt

获取文件字节长度

file.length()

获取绝对路径 返回字符串

file.getAbsolutePath() // /Users/baidawei/Desktop/test.txt

获取绝对路径 返回file类

file.getAbsoluteFile()  // /Users/baidawei/Desktop/test.txt

获取父路径 返回字符串

file.getParent() // /Users/baidawei/Desktop

获取父路径 返回File类

file.getParentFile() // /Users/baidawei/Desktop

文件或目录是否存在

file.exists() // boolean

判断是否是目录

file.isDirectory() // boolean

获取路径中的文件和文件夹名 返回String[]

for(String str : file.list()){

System.out.println(str);

}

获取路径中的文件和文件夹名 返回File[]

for(File f : file.listFiles()){

System.out.println(f.getName());

}

过滤器

for (File f : file.listFiles(new myFilter())) {

System.out.println(f.getName());

}

class myFilter implements FileFilter {

@Override

public boolean accept(File pathname) {

if(pathname.isDirectory()){

return true;

}

return false;

}

}

递归获取全文件

public static void main(String[] args) {

File file = new File("F://");

getAllDir(file);

}

public static void getAllDir(File dir) {

if (dir.listFiles() != null) {

for (File f : dir.listFiles()) {

if (f.isDirectory()) {

getAllDir(f);

} else {

System.out.println(f);

}

}

}

}

字节流

字节输出流 OutputStream 所有输出流父类

常用方法：

write(int b) 写入1个字节

write(byte[] b) 写入字节数组

write(byte[] b,int ,int) 写入字节数组，int 开始写入的索引， int 写几个

close() 关闭流对象，释放与流相关的资源

FileOutputStream 写入数据文件 OutputStream的子类

FileOutputStream fos = new FileOutputStream("F://text.txt");

fos.write(97);

fos.write(98);

fos.write(99);

fos.close();

没有就创建，有就覆盖 abc

byte[] bytes = {65,66,67,68,69,70};

fos.write(bytes);//ABCDEF

fos.close();

byte[] bytes = {65,66,67,68,69,70};

fos.write(bytes,1,2);//BC

fos.close();

写字符串

String strs = "Hello Word \r\n my name is david"; // 换行\r\n

byte[] bytes = strs.getBytes();

fos.write(bytes);

fos.close();

续写文件，FileOutputStream构造方法第二个参数设置为true 就不会覆盖了

FileOutputStream fos = new FileOutputStream("F://text.txt",true);

字节输入流 InputStream 所有字节输入流的父类

读取任意文件，每次只读取1个字节。

read(int b) 读取1个字节

read(byte[] b) 读取字节数组

close() 关闭流对象

FileInputStream 读取数据文件 InputStream子类

读取字节：

public static void main(String[] arg) throws IOException {

FileInputStream fis = new FileInputStream("F://text.txt");

int len = 0;

while((len=fis.read()) != -1){ // -1就是没了

System.out.println(len); //输出字节 len代表执行一次

}

fis.close();

}

读取字节数组(字符串)：

public static void main(String[] arg) throws IOException {

FileInputStream fis = new FileInputStream("F://text.txt");

byte[] b = new byte[1024];

int len = 0;

while((len=fis.read(b)) != -1){

System.out.print(new String(b,0,len)); //调用String构造方法 参数 字节数组

}

fis.close();

}

复制文件

字节复制 效率低

FileInputStream fis = new FileInputStream("F:\\text.txt");

FileOutputStream fos = new FileOutputStream("F:\\copy\\text.txt");

int len = 0;

while((len=fis.read()) != -1){

fos.write(len);

}

fis.close();

fos.close();

字节数组赋值 提高效率

FileInputStream fis = null;

FileOutputStream fos = null;

try{

fis = new FileInputStream("F:\\text.txt");

fos = new FileOutputStream("F:\\copy\\text.txt");

int len = 0;

byte[] b = new byte[1024];

while((len=fis.read(b)) != -1){

fos.write(len);

}

}catch(Exception ex){

System.out.print(ex.getMessage());

}finally {

fis.close();

fos.close();

}

FileWriter类 字符输出流 写文本

write(int c) 写1个字符

write(char[] c) 写字符数组

write(char[] c,int ,int)字符数组，开始索引，多少个

write(String s) 写字符串

FileWriter fw = new FileWriter("F:\\text.txt");

//写1个字符

fw.write(100);

//最好写一次刷一次，释放内存

fw.flush();

//写1个字符数组

fw.write(new char[]{99,98,97,96});

//写1个字符数组 1开始 3个

fw.write(new char[]{99,98,97,96},1,3);

//写字符串

fw.write("有一个姑娘，他有一些嚣张");

//刷新 write一次 刷新一次

fw.flush();

//关闭

fw.close();

续写 构造方法第二个参数true

FileWriter fw = new FileWriter("F:\\text.txt",true);

FileReader累 字符输入流 读取文本

FileReader fr = new FileReader("F:\\text.txt");

//读1个字节

int len = 0;

while((len=fr.read()) != -1){

System.out.print((char)len);

}

fr.close();

读取字符数组

char[] c = new char[1024];

int len = fr.read(c);

System.out.println(new String(c,0,len));

fr.close();

转换流

解决乱码问题

因为写文件时会默认本机编码表，GBK，美国机器打开就会乱码。

使用OutputStreamWriter(OutputStream out) 读取文件可以指定编码类型

FileOutputStream fos = new FileOutputStream("/Users/baidawei/Desktop/gbk.txt");

//使用转换流指定编码表

OutputStreamWriter osw = new OutputStreamWriter(fos,"GBK"); //默认GBK可以不写

osw.write("你好");

osw.flush();

osw.close();

使用UTF-8编码表

OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8");

UTF-8 编码表中 一个汉字3个字节。

使用InputStreamReader类写入文件指定编码类型。

//如果编码格式不一致则会乱码

public static void main(String[] args) throws IOException {

FileInputStream fis = new FileInputStream("/Users/baidawei/Desktop/utf.txt");

InputStreamReader isr = new InputStreamReader(fis,"UTF-8");

int len = 0;

while((len=isr.read()) != -1){

System.out.println((char)len);

}

fis.close();

}

缓冲流

提高读写速度、效率。

字节输出流的缓冲流 BufferedOutputStream(OutputStream out)

FileOutputStream fos = new FileOutputStream("/Users/baidawei/Desktop/gbk.txt");

//使用缓冲流

BufferedOutputStream bos = new BufferedOutputStream(fos);

bos.write("加班中...".getBytes());

bos.close();

字节输入流的缓冲流 BufferedInputStream(InputStream input)

FileInputStream fis = new FileInputStream("/Users/baidawei/Desktop/gbk.txt");

//使用缓冲流

BufferedInputStream bis = new BufferedInputStream(fis);

int len = 0;

byte[] b = new byte[1024];

while((len=fis.read(b)) != -1){

System.out.print(new String(b,0,len));

}

字符输出流缓冲流BufferedWriter

public static void main(String[] args) throws IOException {

String url = "/Users/baidawei/Desktop/test.txt";

FileWriter fw = new FileWriter(url);

BufferedWriter bfw = new BufferedWriter(fw);

bfw.write("测试bufferedWriter输出流缓冲流");

bfw.flush();

//特有换行方法

bfw.newLine();

bfw.write("newline好使么？");

bfw.flush();

bfw.close();

}

字符输入流缓冲流BufferedReader

public static void main(String[] args) throws IOException {

String url = "/Users/baidawei/Desktop/test.txt";

FileReader fr = new FileReader(url);

BufferedReader br = new BufferedReader(fr);

String line = null;

while((line = br.readLine()) != null){

//特有方法 读取一整行 返回字符串 不包含\r\n换行符号

System.out.println(line);

}

}

复制

public static void main(String[] args) throws IOException {

BufferedReader br = new BufferedReader(new FileReader("/Users/baidawei/Desktop/test.txt"));

BufferedWriter bw = new BufferedWriter(new FileWriter("/Users/baidawei/Desktop/test_bak.txt"));

String line = null;

while((line = br.readLine()) != null){

bw.write(line);

bw.newLine();

}

br.close();

bw.close();

}

Properties类

Properties类是Hashtable的子类,实现Map接口，Hashtable是线程不安全的被Hashmap替换。

键值对 都是字符串，可以和IO对象结合使用，实现持久化存储(可以存储到硬盘、u盘、光盘)上。

Properties pp = new Properties();

//存入 等同于put 区别只能字符串

pp.setProperty("key","value");

pp.setProperty("yu","datou");

System.out.println(pp);

//通过key获取value

String val = pp.getProperty("yu");

System.out.println(val);

//获取所有key

for(String s :pp.stringPropertyNames()){

System.out.println(pp.getProperty(s));

}

load() 加载方法

Properties pp = new Properties();

//.properties 后缀为 键值对配置文件

FileReader fr = new FileReader("/Users/baidawei/desktop/test.properties");

pp.load(fr);

System.out.println(pp);

fr.close();

test.properties文件格式固定 必须这样 不能加空格 分号

name=zhagnsan

age=18

#email=853020304@qq.com

#后面是注视

store() 保存方法

Properties pp = new Properties();

pp.setProperty("firstname","zhagn");

pp.setProperty("lastname","san");

pp.setProperty("email","83@qq.com");

FileWriter fw = new FileWriter("/Users/baidawei/desktop/test.properties");

pp.store(fw,"yuanyin buneng zhognwen"); //写中文会转换为unicode编码表存储

fw.close();

对象的序列化

对象中的数据new Person();以流的形式写入到文件中保存的过程称为写出对象。

ObjectOutputStream 写出对象 对象的序列化

//类需要实现Serializable接口

public class Person extends Object implements Serializable {

private String name;

private int age;

Person(String name){

this.name = name;

}

Person(String name,int age){

this(name);

this.age = age;

}

@Override

public String toString(){

return "Person[name" + name + ", age =" + age +"]";

}

}

Person p = new Person("name",18);

FileOutputStream fos = new FileOutputStream("/Users/baidawei/desktop/oos.text");

ObjectOutputStream oos = new ObjectOutputStream(fos);

oos.writeObject(p);

oos.close();

fos.close();

ObjectInputStream 读取对象 对象的反序列化

FileInputStream fis = new FileInputStream("/Users/baidawei/desktop/oos.text");

ObjectInputStream ois = new ObjectInputStream(fis);

Object obj = ois.readObject();

System.out.println(obj);

ois.close();

属性值静态的 static 不能序列化

属性值 加transient关键字 阻止序列化

Serializable接口 没有抽象方法 只是一个标记

打印流

只负责数据目的输出

PrintStream

接收File类型，字符串文件名，OutputStream输出流

PrintWriter

//输出目的FIle

public static void printStream_file() throws FileNotFoundException {

File file = new File("/Users/baidawei/desktop/myTest.txt");

PrintWriter pw = new PrintWriter(file);

pw.println("啥意思啊"); //原样输出

pw.println("啥意思啊嗯？");

pw.flush();

pw.close();

}

//输出String文件名

public static void printWriter_fileName() throws FileNotFoundException{

PrintWriter pw = new PrintWriter("/Users/baidawei/desktop/myTest2.txt");

pw.println("hahahehehhe");

pw.println("hahahhaha");

pw.flush();

pw.close();

}

//输出OutputStream 输出流对象可以 开启自动刷新

public static void printWriter_outputStream() throws FileNotFoundException{

PrintWriter pw = new PrintWriter(new FileOutputStream("/Users/baidawei/desktop/myTest3.txt"),true);

pw.println("333");

pw.println("444");

pw.flush();

pw.close();

}

commons-io工具类

简化File操作类

下载后 在Idea中选择File->Project Structure->Dependencies->加号->JARs or directories->ok->External Libraries中就出现了

FilenameUtils类

String url = "/Users/baidawei/Desktop/myTest.txt";

//获取文件扩展名

String ext = FilenameUtils.getExtension(url);

System.out.println(ext); //txt

//获取文件名

String fileName = FilenameUtils.getName(url);

System.out.println(fileName); ///myTest.txt

//是否是txt文件

boolean isExtens = FilenameUtils.isExtension(url,"txt");

System.out.println(isExtens);

FileUtils类

String url = "/Users/baidawei/Desktop/haha.txt";

//读取文件 返回String

String s = FileUtils.readFileToString(new File(url));

System.out.println(s);

//写String到文件

FileUtils.writeStringToFile(new File("/Users/baidawei/Desktop/haha.txt"),"字符串 要写的内容");

//复制文件

FileUtils.copyFile(new File("/Users/baidawei/Desktop/haha.txt"),new File("/Users/baidawei/Desktop/new.txt"));

//复制文件夹 macnew

FileUtils.copyDirectory(new File("/Users/baidawei/Downloads/mac"),new File ("/Users/baidawei/Downloads/macnew"));

//复制到目标文件里面去 macnew/mac

FileUtils.copyDirectoryToDirectory(new File("/Users/baidawei/Downloads/mac"),new File ("/Users/baidawei/Downloads/macnew"));

多线程

进程：当一个程序进入内存运行，就变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。 如 迅雷软件运行中

线程：线程是进程的一个执行单元，负责当前继承中的程序执行，一个进程中至少有一个线程，可以有多个线程。 如迅雷软件中 同时下载3个任务

程序运行原理

分时调度：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间。

抢占式调度：优先让优先级高的线程使用CPU，如果线程优先级相同，那么会随机选择一个，Java使用的为抢占式调度。

Main方法是主线程

public static void main(String[] args) {

SayHi();

System.out.println("===========================单线程======================");

}

public static void SayHi() {

for (int i = 0; i < 100000; i++) {

System.out.println(i);

}

}

需要等待10万次执行结束后 才能执行 最下面的输出。

Thread类

Thread类是程序中的线程类，允许应用程序并发地运行多个执行线程。

创建执行线程有两种方法，

1:继承Thread类，重写run方法 创建对象，开启线程，run方法相当于其他线程的main方法。

2:实现Runnable接口，重写run方法。创建runnable的子类对象，传入到某个线程的构造方法中，开启线程。

方法一继承Thread类：

public class SubThread extends Thread {

@Override

public void run() {

for(int i = 1;i<50;i++){

System.out.println(i+"A");

}

}

}

//并发执行 一起循环

public class Main {

public static void main(String[] args) {

SubThread st = new SubThread();

st.start();//运行子类 run方法

for (int i = 0; i < 50; i++) {

System.out.println(i);

}

}

}

获取线程的名字

public class SubThread extends Thread {

@Override

public void run() {

for(int i = 1;i<50;i++){

//获取线程的名字 父类的方法

System.out.println(getName());

System.out.println(i+"A");

}

}

}

Thread.currentThread().getName() //当前线程的名字

程序主线程名字：main，自定义的线程：Thread-0、Thread-1数字顺延 也可以使用setName()自定义线程名称

sleep()方法 睡眠多少毫秒在执行

方法二：实现Runnable接口

public class SubThread implements Runnable {

@Override

public void run() {

for(int i = 1;i<50;i++){

System.out.println(i+"A");

}

}

}

public static void main(String[] args) {

SubThread st = new SubThread();

Thread th = new Thread(st);

th.start();

for (int i = 0; i < 50; i++) {

System.out.println(i);

}

}

线程池

线程池是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。

实现Runnable接口

public class ThreadPoolRunnable implements Runnable {

public void run(){

System.out.println(Thread.currentThread().getName());

}

}

//创建线程池对象 包含2个线程对象

ExecutorService es = Executors.newFixedThreadPool(2);

//从线程池创建对象

es.submit(new ThreadPoolRunnable());

es.submit(new ThreadPoolRunnable());

多线程 安全问题

//并发问题 同时判断为true 执行了多次

SubThread st = new SubThread();

Thread t0 = new Thread(st);

Thread t1 = new Thread(st);

Thread t2 = new Thread(st);

t0.start();

t1.start();

t2.start();

public class SubThread implements Runnable {

private int count = 1;

@Override

public void run() {

while(true){

if(count > 0){

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + "出售第:" + --count);

}

}

}

}

解决线程安全：

1.同步代码块 synchronized(锁对象)

用于解决线程安全问题，同步执行，第一个线程执行完后再执行下一个线程。多个线程时，使用同一个锁对象才能够保证线程安全。

//lock是定义的一个object 对象

synchronized (lock){

if(count > 0){

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + "出售第:" + --count);

}

}

2.同步方法 synchronized 不需要写锁对象 是本类对象this

public synchronized void method(){

//可能会产生线程安全问题的代码

}

Lock接口

Lock实现了比使用synchronized方法和语句获得更广泛的锁定操作。

实现类 ReentrantLock

lock() 锁

unlock() 释放锁

public void run() {

while (true) {

lock.lock(); //锁住

if (count > 0) {

try {

Thread.sleep(1000);

} catch (InterruptedException e) {

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName() + "出售第:" + --count);

}

lock.unlock(); //释放

}

}

}

线程的死锁

当线程任务出现了多个同步(多个锁)时，如果同步中潜逃了其他的同步，这时容易引发一种现象：程序出现无限等待，这种现象称之为死锁。

synchronzied(A锁){

synchronized(B锁){

}

}

线程等待与唤醒

wait() :等待，将正在执行的线程释放其执行资格 和 执行权，并存储到线程池中。

notify()：唤醒，唤醒线程池中被wait()的线程，一次唤醒一个，而且是任意的。

notifyAll()： 唤醒全部：可以将线程池中的所有wait() 线程都唤醒。

这些方法都是在 同步中才有效。同时这些方法在使用时必须标明所属锁，这样才可以明确出这些方法操作的到底是哪个锁上的线程。