JAVA泛型、File对象、IO流

1.泛型

1.1什么是泛型？

1.泛型就是限制我们的数据类型。
2.为什么使用泛型？
我们原来在定义集合时，是如下的定义方式：
List list = new ArrayList();//该集合没有使用泛型
list.add(“李白”);
list.add(“杜甫”);

		String str = (String) list.get(0);//获取元素，需要进行强制类型转换
		System.out.println(str);

获取元素时，不方便对元素进行相应的其他操作。

1.2如何使用泛型

List<类型>list=new ArrayList<类型>();只能在该集合中存储指定的类型。

/**
 * @author:hzk
 * @date 2022/4/19 20:47
 */
public class Test {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();//这里就限制了集合中每个元素的类型。
        list.add("李白");
        list.add("杜甫");
        list.add("赵云");//集合中只能添加String类型

        String s = list.get(0);//在获取元素时，默认就是相应的数据类型，而无需再进行转换

        System.out.println(s);

        HashMap hashMap = new HashMap<>();
        hashMap.put("收到",15);

    }
}

1.3自定义泛型

public class 类名<标识，标识…>{
标识 变量名；
public 标识 方法名(){
}
public void 方法名(标识 参数名)
}

/**
 * @author:hzk
 * @date 2022/4/19 21:26
 */
public class Test3 {
    public static void main(String[] args) {
        //在创建泛型类对象时没有指定相应的泛型类型，默认为Object类型
        Name N = new Name();
        N.name=15;
        N.sex=true;

        //这里的泛型必须都是对象类型
        Name<String> n = new Name<>();
        n.setName("李白");
        n.setSex("男");
        n.show();
    }
}
class Name<T>{
    T name;
    T sex;
    public void show(){
        System.out.println("姓名："+name+"性别："+sex);
    }

    public T getName() {
        return name;
    }

    public void setName(T name) {
        this.name = name;
    }

    public T getSex() {
        return sex;
    }

    public void setSex(T sex) {
        this.sex = sex;
    }
}

2.File对象

2.1file介绍

File类就是当前系统中文件或者文件夹的抽象表示，通俗的讲就是使用File对象来操作我们电脑系统中的文件或者文件夹。学习File类其实就是学习如何通过file对象对系统中的文件/文件夹进行增删改查。

2.2创建Fiel对象

1.磁盘准备一个目录A,以后对文件的操作都放在该目录下。

/**
 * @author:hzk
 * @date 2022/4/19 22:07
 */
public class Test4 {
    public static void main(String[] args) {
        File file = new File("D:\\A\\aaa.txt");
        /*
            \\目录层级，在window系统下层级分割符为\,但是在linux和mac系统上分割符为/.我们的java代码是一种
            跨平台的语言，我们的开发在window，但是我们的项目部署在linux。为了使我们的代码能在任意系统下用，有两种方法
            （1）因为window兼容/和\
         */
        File file1 = new File("D:/A/a.txt");
        //第二种 File.separator根据当前代码所在的系统自动获取相应的分割符

        System.out.println(File.separator);// \是我们当前在window下

    }
}

2.3增加操作

import java.io.File;
import java.io.IOException;

/**
 * @author:hzk
 * @date 2022/4/19 22:16
 */
public class Test5 {
    public static void main(String[] args) throws IOException {
        File f1 = new File("D:/A/a.txt");//创建File对象
        f1.createNewFile();//创建相应的文件

        File f2 = new File("D:/A/b");
        f2.mkdir();//创建目录

        File f3 = new File("D:/A/C/c");
        f3.mkdirs();//创建多级目录
    }
}

2.4删除

  File f4 = new File("D:/A/C/c");
        f4.delete();
        
        File f5 = new File("D:/A/C");
        f5.deleteOnExit();//当程序退出后删除
        Thread.sleep(5000);//休眠5秒

2.5修改

import java.io.File;
import java.io.IOException;

/**
 * @author:hzk
 * @date 2022/4/19 22:45
 */
public class Test6 {
    public static void main(String[] args) throws IOException {
        File f = new File("D:/A/a.txt");
        f.createNewFile();
        f.setWritable(false);//设置文件不能写
        f.setReadOnly();//设置只读的权限

        f.renameTo(new File("D:/A/b.txt"));//重命名
    }
}

2.6查询

/**
 * @author:hzk
 * @date 2022/4/19 22:54
 */
public class Test7 {
    public static void main(String[] args) {
        File f = new File("D:/A/b.txt");
        String name = f.getName();
        System.out.println(name);//得到文件名
        System.out.println(f.getParent());//得到父级目录
        System.out.println(f.getPath());//得到文件路径名称

        System.out.println(f.isFile());//判断文件对象是否为文件类型
        System.out.println(f.isDirectory());//判断文件对象是否为目录类型

        File f1 = new File("D:/A");
        String[] list = f1.list();//列出A目录下所有子文件对象
        System.out.println(Arrays.toString(list));

        File[] files = f1.listFiles();//列出A目录下所有的文件对象
        for (File n :files){
            System.out.println(n.toString());
        }
    }
}

例题，递归调用

/**
 * @author:hzk
 * @date 2022/4/19 23:29
 */
public class Test82 {
    public static void main(String[] args) {
        showAll("D:/A");
    }
    public static void showAll(String path){
        File file = new File(path);//设置输入路径
        if(!file.isDirectory()||!file.exists()){//判断是个目录或者文件是否为空
            return;
        }
        File[] files = file.listFiles();//列出目录下所有文件对象
        for (File f:files){
            if(f.isDirectory()){
                System.out.println(f.getPath()+"  Dir");
                showAll(f.getPath());
            }else {
                System.out.println(f.getPath());
            }
        }
    }
}

3.IO流

1.IO表示有两个单词的缩写
I:Input 输入 O:Output 输出
2.IO的作用：就是对文件中的内容进行操作
输入：读操作(读取文件的内容) 输出：写操作(往文件中写作内容)
3.IO流的分类：
（1）根据流的方向：
----输入流：程序可以从中读取数据的流
----输出流：程序能向其中写入数据的流
（2）根据流的单位
-----字节流：以字节为单位传输数据的流
-----字符流：以字符为单位传输数据的流
（3）根据功能
-----节点流：直接和文件进行交互
-----处理流：不是直接作用在文件上
四个基本的流：其他的流都是在这四个流的基础上进行扩展的
字节输入流
字节输出流
字符输入流
字符输出流

3.1Writer字符输出流

它是所有字符输出流的根类。—FileWriter类

/**
 * @author:hzk
 * @date 2022/4/20 10:18
 */
public class Test9 {
    public static void main(String[] args) throws IOException {
        //字符输出流 ---指定对哪个文件（路径）进行写作
        Writer writer = new FileWriter("D:/A/c.txt");
        Writer writer1 = new FileWriter("D:/B/c.txt",true);//追加内容
        String str = "今天打王者荣耀";
        writer1.write(str);

        writer1.flush();//刷新流
        writer1.close();//关闭流资源
    }
}

3.2Reader字符输入流

它是所有字符输入流的根类，它的实现类有很多，我们使用FileReader实现类

/**
 * @author:hzk
 * @date 2022/4/20 10:35
 */
public class Test10 {
    public static void main(String[] args) throws IOException {
        //创建字符输入流对象，作用：读取c.txt里的内容
        Reader reader = new FileReader("D:/A/c.txt");
        int count = 0;//表示读取字符的个数
        char[] cs = new char[2];//每次读取的元素存入该数组中
        while ((count= reader.read(cs))!=-1){
            String str = new String(cs,0,count);
            System.out.println(str);
        }
    }
}

3.3完成文件内容的复制

/**
 * @author:hzk
 * @date 2022/4/21 10:34
 */
public class TestCopy {
    public static void main(String[] args) throws IOException {
        //创建字符输入流
        FileReader f = new FileReader("D:/A/c.txt");
        //创建字符输出流
        FileWriter f1 = new FileWriter("C:/A/c.txt");
        char[] cs  = new char[2];//每次存入两个字符放入该数组中
        int c= 0;//读取到字符的个数
        while ((c=f.read(cs))!=-1){
            f1.write(cs,0,c);
        }
        f.close();
        f1.close();
    }

}

4.字节流

4.1字节输出流–OutputStream

它可以对任意文件进行操作，对文件进行输出操作。以字节为单位。它是所有字节输出流的父类。FileOutputStream

/**
 * @author:hzk
 * @date 2022/4/21 10:45
 */
public class Test1 {
    @Test
    public void output()throws Exception{
        OutputStream os = new FileOutputStream("D:/A/a.txt");
        String s = "abc";
        //将字符串转化为字节数组
        byte[] bytes = s.getBytes();
        os.write(bytes);
        os.flush();
        os.close();
    }
}

4.2字节输入流—InputStream

它可以对任意文件进行读操作，以字节为单位，它是所有字节输入流的父类，子类有FileInputStream`

public void input()throws Exception{
        InputStream is = new FileInputStream("D:/A/a.txt");
        byte[] bytes = new byte[2];
        int c= 0;
        while ((c=is.read(bytes))!=0){
            //将读取的byte数组转化为字符串
            String s = new String(bytes,0,c);
            System.out.println(s+"  "+c);
        }
        is.close();
    }

使用字节输入和输出流完成文件的复制功能：

public void copy()throws Exception{
        //字节输入流
        InputStream is = new FileInputStream("D:/A/a.txt");
        //字节输出流
        OutputStream os = new FileOutputStream("C:/A/c.txt");
        byte[] bytes = new byte[2];
        int c = 0;
        while ((c=is.read(bytes))!=-1){
            os.write(bytes,0,c);
        }
        is.close();
        os.close();
    }

5.缓存流

缓存流是在基础流[InputStream OutputStream Reader Writer]之上添加了一个缓存池功能。
BufferInputStream BufferOutputStream BufferReader Bufferwriter 提高IO的效率，降低IO的次数

  @Test
    public void Buffer()throws Exception{
        OutputStream os = new FileOutputStream("D:/A/c.txt");
        BufferedOutputStream bos = new BufferedOutputStream(os);//缓存流要作用在基础流上
        String s = "dsds";
        byte[] bytes = s.getBytes();
        bos.write(bytes);//将内容暂时放入缓存池中，文件中没内容
        bos.flush();//刷新缓存池---把池子中的内容输入到文件上
        bos.close();//关闭----先刷新缓存池，在关闭流资源
    }

6.对象流–对java对象进行IO操作

运行的时候，所有的数据都在运行内存中，持久化，将运行内存的数据保存到硬盘上。

/**
 * @author:hzk
 * @date 2022/4/21 9:51
 */
public class Player implements Serializable {
    private String name;
    private String level;
    private String power;

    public Player() {
    }

    public Player(String name, String level, String power) {
        this.name = name;
        this.level = level;
        this.power = power;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getLevel() {
        return level;
    }

    public void setLevel(String level) {
        this.level = level;
    }

    public String getPower() {
        return power;
    }

    public void setPower(String power) {
        this.power = power;
    }

    @Override
    public String toString() {
        return "Player{" +
                "name='" + name + '\'' +
                ", level='" + level + '\'' +
                ", power='" + power + '\'' +
                '}';
    }
}

 @Test//存档  序列化
    public void ObjectTest()throws Exception{
        OutputStream os = new FileOutputStream("D:/A/a.txt");
        ObjectOutputStream oos = new ObjectOutputStream(os);
        Player p = new Player("马里奥","15级","全能属性");
        oos.writeObject(p);
        oos.close();
    }
    @Test//读档  反序列化
    public void ObjectTest1()throws Exception{
        InputStream is = new FileInputStream("D:/A/a.txt");
        ObjectInputStream ois = new ObjectInputStream(is);
        Object o =ois.readObject();
        System.out.println(o);
        ois.close();
    }

1序列化：把内存中的java对象存储到磁盘的过程。
java对象所属的类必须实现序列化接口：implement Serializable
2反序列化：把磁盘中的内容读取到java对象内存中的过程