2020.8.3课堂笔记（StringBuffer、FileInputStream、FileOutputStream）

最新推荐文章于 2022-09-23 11:12:43 发布

超可爱慕之

最新推荐文章于 2022-09-23 11:12:43 发布

阅读量351

点赞数 1

分类专栏：笔记

本文链接：https://blog.csdn.net/m0_48758256/article/details/107776535

版权

笔记专栏收录该内容

138 篇文章 5 订阅

订阅专栏

String
是final类型，不可被继承，底层是char类型数组常量，不可更改
而对String对象重新赋值的过程，其实是新建对象的过程
如果需要对String对象频繁赋值，则不推荐使用String

线程安全：synchronized 保证线程间隔离
String：不可被改变，真正意义上的安全，再频繁字符串拼接的情况下，速度非常慢
StringBuffer：线程安全，速度慢，涉及到线程安全的情况，除非能确保线程隔离
StringBuilder：线程不安全，速度快

绝对路径和相对路径：
绝对路径一般从根目录开始，写全路径
相对路径一般从当前目录开始
并不以File对象这个文件开始的，而是从这个工程开始的，
因为实际是JVM执行的，JVM是为这个工程服务的

输入输出：
基本概念：输入流、输出流、字节流、字符流、节点流，处理流
最基础的4个抽象类：InputStream、OutputStream、Reader、Writer
File打头的对文件读写FileInputStream FileOutputStream FileReader FileWriter
Buffered带缓冲区的 BufferedReader/BufferedWriter/BufferedInputStream/BufferedOutputStream
对一个内存里面的字节数组进行读写：
Bytearryinputstream/bytearraoutputstream
转换流（把字节转成字符）：
Inputstreamreader/outputstreamwriter
直接写基础的数据类型也可以是utf-8的
Datainputstream/dataoutputstream(比较省空间，网络上一般都用的utf-8的)
PrintStream/PrintWriter 打印流
Objectinputstream/Objectoutputstream
注意关键字：transient透明的，用来修饰成员变量，在序列化的时候不予考虑，读取的时候就是默认值0。serializable可序列化的，标记性的接口，由jdk控制序列化
当我要用一个东西的时候能记得有这么个东西，写法都非常的固定，保留好例子程序。非常简单

FileInputStream读取文件的流程：
1、FileInputStream对象和String对象声明
2、创建FileInputStream对象(文件路径或File对象)
3、读单字节或整个读到byte数组中
4、转成字符串
5、关闭FileInputStream流
6、返回结果字符串

FileOutputStream写文件的流程：
1、File对象装载文件路径
2、判断文件父级目录是否存在，不存在则创建
3、声明FileOutputStream对象
4、创建FileOutputStream对象(File对象，是否追加)
5、把要写的字符串转成byte数组，并写入输出流
6、关闭FileOutputStream流

StringBuffer:

package cn.kgc.kb09;

/**
 * @Author: ChaoKeAiMuZhi
 * @Date: 2020/8/3 13:39
 * @Description:
 **/
public class TestStringBuffer {
    public static void main(String[] args) {
        StringBuffer sb=new StringBuffer();
        System.out.println(sb);//还是打印的值
        char c='\u0000';
        sb.append("abc");
        sb.append(123);
        sb.append(new TestStringBuffer());
        System.out.println(sb);
        String s=sb.toString();
        System.out.println(s);
        //sb.substring() 使用的更多 sb.length()
        StringBuilder sb2=new StringBuilder();
        //几乎和StringBuffer没有任何区别，多了个insert方法

    }
}

Date:

package cn.kgc.kb09;

import java.text.FieldPosition;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

/**
 * @Author: ChaoKeAiMuZhi
 * @Date: 2020/8/3 14:05
 * @Description:
 **/
public class TestDate {
    public static void main(String[] args) {
        //格林威治时间 1970 01 01 00 00 00 000毫秒一直到当前毫秒的差值
        //long now = System.currentTimeMillis();
        //System.out.println(now/60/60/24/365/1000);
        Date d=new Date();
        System.out.println(d);
        //"yyyy-MM-dd HH:mm:ss"  数据库认识的："yyyy/MM/dd HH:mm:ss"
        //"yyyyMMddHHmmss"纯数字转数值型、运算方便
        SimpleDateFormat format=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String rst = format.format(d);
        System.out.println(rst);
        System.out.println(d.getTime());//当前时间的毫秒数
        Calendar c=format.getCalendar();
        System.out.println("当前的年"+c.getWeekYear());
        System.out.println("一年有多少个周"+c.getWeeksInWeekYear());
        Calendar.getInstance();
        System.out.println(c.get(Calendar.DAY_OF_WEEK_IN_MONTH));

    }
}

TestInputStream:

package cn.kgc.kb09;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Arrays;

/**
 * @Author: ChaoKeAiMuZhi
 * @Date: 2020/8/3 15:53
 * @Description:
 **/
public class TestFileInputStream {
    public static void main(String[] args) throws IOException {
        /*File file =new File("E:/HelloWorld.txt");
        FileInputStream fis=new FileInputStream(file);
        //读单个字节
        //fis.read()!=-1或fis.read>0
        *//*int tmp;
        while((tmp=fis.read())!=-1){
            System.out.print((char)(tmp));
        }*//*
        //读一个byte数组
        byte[] b=new byte[1024];
        fis.read(b);
        byte[] rst=null;
        for (int i = 0; i < b.length; i++) {
            if(b[i]==0){
                rst= Arrays.copyOf(b,i);
                break;
            }
        }
        fis.close();
        String str=new String(rst);
        System.out.println(str);*/

        System.out.println(TestFileInputStream.readByOne("E:/HelloWorld.txt"));
        System.out.println(TestFileInputStream.readFile("E:/HelloWorld.txt"));
    }


    public static String readFile(String path){
        //File f = new File(path);
        FileInputStream fis=null;
        String str=null;
        try {
             fis= new FileInputStream(path);//可以省略对象的创建，直接传递路径进来
             byte[] b=new byte[fis.available()];
             //byte[] rst=null;
             fis.read(b);
            /*for (int i = 0; i < b.length; i++) {
                if(b[i]==0) rst=Arrays.copyOf(b,i);
            }*/
            str=new String(b);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return str;
    }


    public static String readByOne(String path){
        //局部变量作用域是它自身所在的大括号
        FileInputStream fis=null;
        String str=null;
        try {
            fis=new FileInputStream(path);
            StringBuffer sb = new StringBuffer();
            int tmp;
            //读的是每一个字符的ASCII码值   在末尾有个/r /n  对应10 13
            while((tmp=fis.read())>0){
                char c=(char) tmp;
                sb.append(c);
            }
            str=sb.toString();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    return str;
    }
}

TestOutputStream:

package cn.kgc.kb09;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * @Author: ChaoKeAiMuZhi
 * @Date: 2020/8/3 16:54
 * @Description:
 **/
public class TestFileOutputStream {
    public static void main(String[] args) throws IOException {
        String str="How do you do.\r\nFine,thanks,and you?\r\nThat's OK!";
        //写的时候文件是否存在无所谓
        /*FileOutputStream fos=new FileOutputStream("def.txt",true);
        byte[] b = str.getBytes();
        fos.write(b);
        fos.close();*/
        //path:"text/a.txt"java.io.FileNotFoundException: text\a.txt (系统找不到指定的路径。)
        //文件夹不存在的情况下，不能自动创建文件夹
        writeFile(str,"text/text/text/text/text/a.txt",true);
    }

    public static void writeFile(String str,String path,boolean isAppend){
        //追加还是替换的问题，在文件路径后面加一个true
        File f=new File(path);
        if(!f.getParentFile().exists()) {
            f.getParentFile().mkdirs();
        }
        FileOutputStream fos=null;
        try {
            fos=new FileOutputStream(f,isAppend);
            byte[] b=str.getBytes();
            fos.write(b);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }

}

TestFile:

package cn.kgc.kb09;

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

/**
 * @Author: ChaoKeAiMuZhi
 * @Date: 2020/8/3 14:50
 * @Description:
 **/
public class TestFile {
    public static void main(String[] args) {
        // 但斜杠适用于所有系统，尽量不要使用\\
        File f = new File("E:/HelloWorld.txt");
        //是否是文件
        System.out.println(f.isFile());
        //是否是目录
        System.out.println(f.isDirectory());
        //里面内容的长度
        System.out.println(f.length());
        //是否存在
        System.out.println(f.exists());
        File file =new File("E:/abc/test/Testabc.txt");
        System.out.println(file.exists());
/*
        //创建当前的目录，文件名不能包含/
        file.getParentFile().mkdir();
*/
        //多级目录创建，文件名不能包含/
        file.getParentFile().mkdirs();
        /*try {
            file.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }*/
        createFile("E:/abc/test/Testabc.txt");
        System.out.println(file.exists());
        //删除最后一级           file.delete();
        //变成另外一个file对象    file.renameTo();
        //记忆file.canRead();   file.canWrite();   file.canExecute();
        file.getPath();//获取路径，写的是啥就获取啥
        File f2=new File("abc.txt");
        createFile("abc.txt");

    }


    public static void createFile(String path){
        File f = new File(path);
        try {
            f.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }



}