2021-07-17

最新推荐文章于 2021-11-10 17:26:45 发布

faharciki

最新推荐文章于 2021-11-10 17:26:45 发布

阅读量55

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/faharciki/article/details/118861418

版权

java 专栏收录该内容

28 篇文章 0 订阅

订阅专栏

IO流
流：管道，传输数据。数据以先入先出的方式流动
按照其操作单元可分为：
一、字节流：

InputStream
OutputStream
具体按功能又可分为：

1).节点流
文件流 : 对文件中内容做读写->字节
1. FileInputStream
2. FileOutputStream
字节数组流
1. ByteArrayInputStream
2. ByteArrayOutputStream
2).功能流 : 增强功能,提高性能
缓冲流 : 加块读写效率
基本数据类型流 Data : 读写数据+数据类型(基本数据类型|String)
对象流 Object : 读写数据+数据类型(基本+对象)

二、字符流
Reader
Writer
节点流 : 文件流
文件流 : 对文件中内容做读写->字符
FileReader
FileWriter
功能流 :
缓冲流 : 加块读写效率

字节缓冲流：
BufferedInputStream 字节输入缓冲流
BufferedOutputStream 字节输出缓冲流
字符节点流
FileReader
FileWriter

基本数据类型流|Data流（功能流，字节流）
作用：保留数据和数据类型（基本数据类型+String）
对Data流进行操作：

import java.io.*;

public class Class_Data {
    public static void main(String[] args) throws IOException {
        write("D://File//test.txt");
        read("D://File//test.txt");

    }

    public static void write(String path) throws IOException {
        //创建源
        DataOutputStream out=new DataOutputStream(new BufferedOutputStream(new FileOutputStream(path,true)));
        //写入数据
        int a=1;
        boolean b=true;
        char c='A';
        String d="天哪";
        out.writeInt(a);
        out.writeBoolean(b);
        out.writeChar(c);
        out.writeUTF(d);
        //刷新
        out.flush();
        //关闭
        out.close();
    }
    public static void read(String path) throws IOException {
        //创建源
        DataInputStream in=new DataInputStream(new BufferedInputStream(new FileInputStream(path)));
        //读出
        System.out.println(in.readInt());
        System.out.println(in.readBoolean());
        System.out.println(in.readChar());
        System.out.println(in.readUTF());
        //关闭
        in.close();
    }
}

注：Data流读出与写入的是一个文件，并且对数据的读写顺序要一致

Object流|对象流|引用数据类型流
作用：读写对象数据|引用数据类型的数据(包含基本数据类型)

ObjectInputStream 反序列化输入流
新增功能: readObject()
ObjectOutputStream 序列化输出流
新增功能: writeObject(Object obj)

序列化: 将对象数据转换一个可存储或者可传输的状态过程

<---------------------------------------------->

不能所有的类型都能序列化 java.io.Serializable
不是所有的属性都需要序列化
静态的内容不会序列化
如果父类实现序列化,子类没有实现,可以序列化所有的成员
如果子类实现序列化,父类实现,只能序列化子类成员
先序列化后反序列化
例：

import java.io.*;
import java.util.Arrays;

public class Class_Serialization {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //主方法里进行测试
        writeToFile("D://File//bbbbbb.txt");
        readFromFile("D://File//bbbbbb.txt");
    }


    public static void writeToFile(String path) throws IOException {
        //创建数据源
        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(path)));
        //输入数据
        User user=new User("张三",18,"123456");
        int[] arr=new int[]{1,2,3,4};
        out.writeObject(user);
        out.writeObject(arr);
        //刷新
        out.flush();
        //关闭
        out.close();
        //不是序列化对象
        user.password="654321987";
    }

    //Object流
    public static void readFromFile(String path) throws IOException, ClassNotFoundException {
        //数据源
        ObjectInputStream in=new ObjectInputStream(new BufferedInputStream(new FileInputStream(path)));
        //读出数据并显示
        System.out.println(in.readObject());
        System.out.println(Arrays.toString((int[]) in.readObject()));
        //关闭
        in.close();
    }
}



//简单定义一个对象 先序列化对象
class User implements Serializable{
    private static final long serialVersionUID = -4810568450707063908L;

    public String name;
    public String wuhu;

    //被transient 修饰的不会被序列化
    public transient int age;
    //静态内容不会被序列化
    public static String password;

    public User() {
    }

    public User(String name, int age, String password) {
        this.name = name;
        this.age = age;
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", password='" + password + '\'' +
                '}';
    }
}

注：通过序列号控制版本不一致问题:

实现Serializable接口的类型默认生成序列号,序列号会根据成员的修改做更新 serialVersionUID = -5204947308809070324
控制版本的统一问题: 控制类型修改之前与之后序列不变
通过工具生成序列号: 1.实现Serializable接口 2.setting设置 3.选中类名->alt+enter->生成序列号

Commons-IO
是apache的一个开源的工具包,封装了IO操作的相关类,使用Commons IO可以很方便的读写文件,url源代码等。
使用第三方组件的方式|步骤:

下载源码资源,找到核心jar包
项目下新建文件夹lib,放入jar包
commons-IO 需要加入classpath 的第三方 jar 包内的 class 文件才能在项目中使用
选中jar包右键->add as lib…
添加Jar包后简单工具类使用：

import org.apache.commons.io.FileUtils;
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.io.filefilter.FileFilterUtils;
import java.io.File;
import java.io.IOException;

public class Class_Commons_IO {
    public static void main(String[] args) throws IOException {
        //创建File对象
        File file1=new File("D://File//test.txt");
        File file2=new File("D://FileNewAAA//work.txt");

        //FilenameUtils
        //isExtension(String fileName, String text) // 判断fileName是否是text后缀名
        //FilenameUtils.getBaseName(String filename) // 去除目录和后缀后的文件名
        System.out.println(FilenameUtils.getName(String.valueOf(file1)));
        System.out.println(FilenameUtils.getBaseName(String.valueOf(file1)));
        System.out.println(FilenameUtils.isExtension(String.valueOf(file1),"txt"));

        //FileUtils
        //FileUtils.copyFile(File srcFile, File destFile)` // 复制文件
        FileUtils.copyFile(file1,file2);

        // **复制文件夹**
        //FileUtils.copyDirectory(File srcDir, File destDir)` // 复制文件夹（文件夹里面的文件内容也会复制）
        //FileUtils.copyDirectory(new File("D://File"),new File("D://FileNewAAA"));
        //FileUtils.copyDirectory(File srcDir, File destDir, FileFilter filter)` // 复制文件夹，带有文件过滤功能
        FileUtils.copyDirectory(new File("D://File"),new File("D://FileNewAAA"), FileFilterUtils.fileFileFilter());

        //**把字符串写入文件**
        //`FileUtils.writeStringToFile(File file, String data, String encoding)`  // 字符串以指定的编码写到文件
        //`FileUtils.writeStringToFile(File file, String data, String encoding, boolean append)`// 指定知否追加
        FileUtils.writeStringToFile(file2," 这是追加的内容","UTF-8",true);
    }
}

** Collection集合**

集合层次结构中的根接口。集合表示一组对象，称为其元素。
集合优点：
1. 容量跟随内容的多少进行动态的增删
2. 存储任意引用类型数据
例.依照系统提供的ArrayList集合仿写一个简单String类型的集合：

import java.util.ArrayList;

public class Class_Gather {
    public static void main(String[] args) {
        //系统提供集合
        ArrayList list=new ArrayList();
        list.add("str");
        list.add(19);
        System.out.println(list.size());
        System.out.println(list.get(0));
        System.out.println(list.get(1));
        //仿写集合
        Gather he=new Gather();
        he.add("你好");
        System.out.println( he.size());
        he.add("123");
        System.out.println( he.size());
        he.add("我不好");
        System.out.println(he.get(3));

    }
}

class Gather{
    //集合属性
    private String[] elementData;
    private int size;
    //这个集合的方法
    //为集合增加添加方法
    public void add(String str){
        //判断是不是第一次写入,是就直接写入数据，并给长度加1
        if(size==0 && elementData==null){
            elementData=new String[++size];
            elementData[0]=str;
            return;
        }
        //不是第一次写入 拷贝原数组，创建新数组，存入新数据并给长度加1
        String[] temp=elementData;
        elementData=new String[++size];
        for (int i=0;i< temp.length;i++){
            elementData[i]=temp[i];
        }
        elementData[size-1]=str;
    }

    public int size(){
        return size;
    }
    public String get(int s){
        if(s<0 && s>=size){
            throw new IndexOutOfBoundsException();
        }
        return elementData[s-1];
    }

    //构造器
    public Gather() {
    }


}

集合的遍历：
1. 增加for循环
2. iterator迭代器
代码示例：

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

//遍历集合
public class Class_Collection {
    public static void main(String[] args) {
        Collection col=new ArrayList();
        col.add("aaa");
        col.add("bbb");
        col.add("ccc");
        col.add("ddd");
        //增强foreach循环
        for(Object obj:col){
            System.out.println(obj);
        }
        System.out.println("<--------!-------->");

        //使用迭代器遍历数组
        Iterator it = col.iterator();
        //boolean hasNext() 如果迭代具有更多元素，则返回 true 。
        while (it.hasNext()){
            //E next() 返回迭代中的下一个元素。
            System.out.println(it.next());
        }
    }
}