IO流（自用小结笔记）

最新推荐文章于 2024-08-06 20:27:03 发布
最新推荐文章于 2024-08-06 20:27:03 发布
阅读量111 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Giapeace/article/details/109783267
版权

IO流

File类的使用

1.File类的理解
File类的使用

  • File类的一个对象，代表一个文件或一个文件目录(俗称：文件夹)
  • File类生命在java.io包下
  • File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法。
    并未涉及到写入或读取文件内容的操作。如果需要读取或写入文件内容，必须使用IO流来完成。
  • 后续File类的对象常会作为参数传递到流的构造器中，指明读取或吸入的“终点”。

2.File的实例化

2.1 常用构造器

  • File(String filePath)
  • File(String parentPath,String childPath)
  • File(File parentFile,String chilePath)

2.2 路径的分类

  • 相对路径：相较于某个路径下指明的路径、
  • 绝对路径：包含盘符在内的文件或文件目录的路径

说明（IDEA中）：如果开发中使用JUnit中的单元测试方法测试，相对路径即为当前Module下。
如果使用main()方法测试，相对路径即为当前的Project下。
（Eclipse中）：不管使用单元测试方法还是使用main()测试，相对路径都是当前的Project下。

2.3 路径分隔符

  • windows:\
  • unix:/
@Test
    public void test1(){

        File file1 = new File("hello.txt");//相对于当前module
        File file2 = new File("E:\\Java\\IDEA-workspace\\JavaSenior\\20201110\\he.txt");

        System.out.println(file1);
        System.out.println(file2);

        //构造器2：
        File file3 = new File("E:\\Java\\IDEA-workspace","JavaSenior");
        System.out.println(file3);

        //构造器3：
        File file4 = new File(file3,"hi.txt");
        System.out.println(file4);
    }

3.File类的常用方法

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

IO流概述

1.流的分类

  • 操作数据单位：字节流、字符流
  • 数据的流向：输入流、输出流
  • 流的角色：节点流、处理流
    图示：
    在这里插入图片描述
    2.流的体系结构
    在这里插入图片描述
    说明：第一排的四个对应的时IO流中的4个抽象基类。
    篮框的流需要重点关注。

3.重点说明的几个流结构

在这里插入图片描述

4.输入、输出的标准化过程

4.1 输入过程

  1. 创建File类的对象，指明读取的数据的来源。（要求此文件一定要存在）。
  2. 创建相应的输入流，将File类的对象作为参数，传入流的构造器中。
  3. 具体的读入过程：创建相应的byte[] 或 char[]。
  4. 关闭流资源
    说明：程序中出现的异常需要使用try-catch-finally处理。

4.2 输出过程

  1. 创建File类的对象，指明写出的数据的位置。（不要求此文件一定要存在）。
  2. 创建相应的输出流，将File类的对象作为参数，传入流的构造器中。
  3. 具体的写出过程：write(char[]/byte[] buffer,0,len)。
  4. 关闭流资源
    说明：程序中出现的异常需要使用try-catch-finally处理。

节点流

  1. FileReader/FileWriter的使用：

1.1 FileReader的使用
/*
将20201119下的hello.txt文件内容读入程序中，并输出到控制台

说明点：
1.read()的理解：返回读入的一个字符。如果达到文件末尾，返回-1
2.异常的处理：为了保证流资源一定可以执行关闭操作。需要使用try-catch-finally来处理
3.读入的文件一定要存在，否则就会报FileNotFoundException。
*/

 @Test
    public void testFileReader1()  {
        FileReader fr = null;

        try {
            //1.File类的实例化
            File file = new File("hello.txt");

            //2.FileReader流的实例化
            fr = new FileReader(file);

            //3.读入的操作
            //read(char[] cbuf):返回每次读入cbuf数组中的字符的个数,如果达到文件末尾，返回-1
            char[] cbuf = new char[5];
            int len;
            while ((len = fr.read(cbuf)) != -1){

                //方式一
                //错误的写法
//                for (int i = 0; i < cbuf.length; i++) {
//                    System.out.print(cbuf[i]);
//                }
                //正确的写法
//                for (int i = 0; i < len; i++) {
//                    System.out.print(cbuf[i]);
//                }
                //方式二：
                //错误的写法,对应着方式一的错误写法
//                String str = new String(cbuf);
//                System.out.print(str);
                //正确的写法
                String str = new String(cbuf,0,len);
                System.out.print(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fr != null){
                //4.资源的关闭
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }

    }

1.2 FileWriter的使用
在这里插入图片描述

@Test
    public void testFileWriter() {
        FileWriter fw = null;
        try {
            //1.提供File类的对象，指明写出到的文件
            File file = new File("hello1.txt");

            //2.提供FileWriter的对象，用于数据的写出
            fw = new FileWriter(file,true);

            //3.写出的操作
            fw.write("I have a dream!\n");
            fw.write("You need me!");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fw != null){

                //4.流资源的关闭
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

1.3 文本文件的复制

@Test
    public void testFileReaderWriter() {
        FileReader fr = null;
        FileWriter fw = null;
        try {
            //1.创建File类对象，指明读入和写出的文件
            File srcFile = new File("hello.txt");
            File destFile = new File("hello2.txt");

            //2.创建输入流和输出流的对象
            fr = new FileReader(srcFile);
            fw = new FileWriter(destFile);

            //3.数据的读入和写出操作
            char[] cbuf = new char[5];
            int len;//记录每次读入到cbuf数组中的字符的个数
            while ((len = fr.read(cbuf)) != -1){
                //每次写出len个字符
                fw.write(cbuf,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {

                //4.关闭流资源
            {
                try {
                    if(fw != null)
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            try {
                if(fr != null)
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
}
  1. **FileInputStream/FileOutputStream的使用：
    2.1 对于文本文件(.txt .java .c .cpp)，使用字符流处理
    2.2 对于非文本文件(.jpg .mp3 .mp4 .avi .doc .ppt```）使用字节流处理
/*
    实现对图片的复制
     */
    @Test
    public void testFileInputOutputStream() throws FileNotFoundException {
        FileInputStream fis = null;
        FileOutputStream fos = null;

        try {
            //1.造文件
            File srcFile = new File("timg.jpg");
            File destFile = new File("timg2.jpg");

            //2.造流
            fis = new FileInputStream(srcFile);
            fos = new FileOutputStream(destFile);

            //3.复制的过程
            byte[] buffer = new byte[5];
            int len;
            while ((len = fis.read(buffer)) != -1){
                fos.write(buffer,0,len);
            }
            System.out.println("复制成功！");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭流
            try {
                if(fos != null)
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(fis != null)
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }

注意：相对路径再IDEA和Eclipse中使用的区别？

  • IDEA:如果使用单元测试方法，相对路径基于当前的Module的
    如果使用main()测试，相对路径基于dangqianProject的。

  • Eclipse：单元测试方法还是main(),相对路径都是基于当前Projece的。

缓冲流的使用

1.缓冲流涉及到的类：

  • BufferedInputStream
  • BufferedOutputStream
  • BufferedReader
  • BufferedWriter

2.作用

提供流的读取、写入的速度；提高读写速度的原因：内部提供了一个缓冲区
在这里插入图片描述

3.典型代码

3.1 使用BufferedInputStream和BufferedOutputStream：处理非文本文件

//实现文件复制的方法
    public void copyFileWithBuffered(String srcPath,String destPath){
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;

        try {
            //1.造文件
            File srcFile = new File(srcPath);
            File destFile = new File(destPath);

            //2.造流
            //2.1造节点流
            FileInputStream fis = new FileInputStream(srcFile);
            FileOutputStream fos = new FileOutputStream(destFile);
            //2.2造缓冲流
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);

            //3.复制细节:读取、写入
            byte[] buffer = new byte[10];
            int len;
            while ((len = bis.read(buffer)) != -1){
                bos.write(buffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.资源关闭
            //要求：先关闭外层的流，在关闭内层的流。
            if(bos != null){
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
            if(bis != null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
            //说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略。
//        fos.close();
//        fis.close();
        }
    }

3.2 使用BufferedReader和BufferedWriter：处理文本文件

/*
    使用BufferedReader和BufferedWriter实现文本文件的复制
     */
    @Test
    public void testBufferedReaderBufferedWriter(){
        BufferedReader br = null;
        BufferedWriter bw = null;

        try {
            //创建文件和相应的流
            br = new BufferedReader(new FileReader(new File("dbcp.txt")));
            bw = new BufferedWriter(new FileWriter(new File("dbcp1.txt")));

            //读写操作
            //方式一：使用char[]数组
//            char[] cbuf = new char[1024];
//            int len;
//            while((len = br.read(cbuf)) != -1){
//                bw.write(cbuf,0,len);
//    //            bw.flush();
//            }

            //方式二：使用String
            String data;
            while((data = br.readLine()) != null){
                //方法一：
//                bw.write(data + "\n");//data中不包含换行符
                //方法二:
                bw.write(data);//data中不包含换行符
                bw.newLine();//提供换行的操作
            }
            br.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            if(bw != null){
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
            if(br != null){
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }

    }

转换流的使用

1.转换流涉及到的类：属于字符流

  • InputStreamReader:将一个字节的输入流转换为字符的输入流
    解码：字节、字符数组 -----> 字符数组、字符串
  • OutputStreamReader：将一个字符的输出流转换为字节的输出流
    编码：字符数组、字符串 ------> 字节、字节数组

说明：编码决定了解码的方式

2.作用：提供字节流与字符流之间的转换

3.图示：
在这里插入图片描述

4.典型实现

 @Test
    public void test1() throws IOException {

        FileInputStream fis = new FileInputStream("dbcp.txt");
//        InputStreamReader isr = new InputStreamReader(fis);//使用系统默认的字符集
        //参数2指明了字符集，具体使用哪个字符集，取决于文件dbcp.txt保存时使用的字符集
        InputStreamReader isr = new InputStreamReader(fis,"UTF-8");//使用系统默认的字符集

        char[] cbuf = new char[20];
        int len;
        while((len = isr.read(cbuf)) != -1){
            String str = new String(cbuf,0,len);
            System.out.println(str);
        }

        isr.close();
    }

/*
    综合使用InputStreamReader和OutputStreamWriter
     */
    @Test
    public void test2(){
        InputStreamReader isr = null;
        OutputStreamWriter osw = null;

        try {
            //1.造文件、造流
            File file1 = new File("dbcp.txt");
            File file2 = new File("dbcp_gbk.txt");

            FileInputStream fis = new FileInputStream(file1);
            FileOutputStream fos = new FileOutputStream(file2);

            isr = new InputStreamReader(fis,"UTF-8");
            osw = new OutputStreamWriter(fos,"gbk");

            //2.读写过程
            char[] cbuf = new char[20];
            int len;
            while((len = isr.read(cbuf)) != -1){
                osw.write(cbuf,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //3.关闭资源
            if(isr != null){
                try {
                    isr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
            if(osw != null){
                try {
                    osw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }

    }

5.说明：

//文件编码的方式(比如：GBK)，决定了解析时使用的字符集(也只能是GBK)。

编码集

1.常见的编码表

  • ASCII:美国标准信息交换码
    用一个字节的七位可以表示。
  • ISO8859-1:拉丁吗表，欧洲码表
    用一个字节的8位表示。
  • GB2312:中国的中文编码表，最多两个字节编码所有字符。
  • GBK:中国的中文编码表升级，融合了更多的中文文字符号。最多两个字节编码。
  • Unicode：国际标准吗，融合了目前人类使用的所有字符。为每个字符分配唯一的字符码，所有的文字都用两个字节来表示。
  • UTF-8：变长的编码方式，可用1-4个字节来表示一个字符。

2.对后面学习的启示

客户端/浏览器端 ------ 后台(java,GO,Python,Node.js,php)

要求前前后后使用的字符集都要同意：UTF-8

其他流的使用

1.标准的输入输出流：

System.in:标准的输入流，默认从键盘输入
System.out:标准的输出流，默认从控制台输出

修改默认的输入和输出行为：
System类的setIn(InputStream is)/setOut(PrintStream ps)方式重新指定输入和输出的流。

2.打印流

PrintStream和PrintWriter
说明：

  • 提供了一系列重载的print()和println()方法，用于多种数据类型的输出
  • System.out返回的是PrintStream的实例

3.数据流：

DataInputStream 和 DataOutputStream

作用：用于读取或写出基本数据类型的变量或字符串

示例代码：

	/*
 	练习：将内存中的字符串、基本数据类型的变量写出到文件中。

    注意：处理异常的话，仍然应该使用try-catch-finally
     */

    @Test
    public void test3(){

        DataOutputStream dos = null;
        try {
            dos = new DataOutputStream(new FileOutputStream("data.txt"));
            dos.writeUTF("刘嘉宁");
            dos.writeInt(24);
            dos.writeBoolean(true);
            dos.flush();//刷新操作，将内存中的数据写入文件
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(dos != null){
                try {
                    dos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }


    }

    /*
    将文件中中存储的基本数据类型变量和字符串读取到内存中，保存在变量中

   注意点：读取不同类型的数据的顺序要与当初写入文件时，保存的顺序一致。
     */
    @Test
    public void test4(){
        DataInputStream dis = null;
        try {
            //1
            dis = new DataInputStream(new FileInputStream("data"));

            //2
            String name = dis.readUTF();
            int age = dis.readInt();
            boolean isMale = dis.readBoolean();

            System.out.println("name = " + name);
            System.out.println("age = " + age);
            System.out.println("isMale = " + isMale);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //3
            if(dis != null){
                try {
                    dis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }

    }

对象流的使用

1.对象流：
ObjectInputStream和ObjectOutStream

2.作用：
ObjectInputStream：内存中的对象–>存储中的文件、通过网络传输出去:序列化过程
ObjectOutStream:存储中的文件、通过网络传输出去–>内存中的对象：反序列化过程

3.对象的序列化机制：
对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久的保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。当其他程序获取了这种二进制流，就可以恢复成原来的Java对象。

4.序列化代码实现：

@Test
    public void testObjectOutputStream(){

        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("object.data"));

            oos.writeObject(new String("我爱北京天安门"));

            oos.flush();//刷新操作

            oos.writeObject(new Person("刘嘉宁",24));
            oos.flush();

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(oos != null){
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
        }

    }

5.反序列化代码实现：

@Test
    public void testObjectInputStream(){
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream("object.data"));

            Object obj = ois.readObject();
            String str = (String) obj;

            Person p = (Person) ois.readObject();

            System.out.println(str);
            System.out.println(p);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if(ois != null){

                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

6.实现序列化的对象所属的类需要满足：

  • 1.需要实现接口：Serializable

  • 2.需要当前类提供一个全局常量：serialVersionUID

  • 3.除了当前Person类需要实现Serizlizable接口之外，还必须保证其内部所有属性也必须是可序列化的。（默认情况下，基本数据类型可序列化 ）

  • 补充：ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量

RandomAccessFile的使用

1.随机存储文件流：

	RandomAccessFile

2.使用说明：

  • 1.RandomAccessFile直接继承于java.lang.Object类，实现了DataInput和DataOutput
  • 2.RandomAccessFile既可以作为一个输入流，又可以作为一个输出流。
  • 3.如果RandomAccessFile作为输出流时，写出到的文件不存在，则在执行过程中自动创建，如果写出到的文件存在，则会对原有文件内容进行覆盖。（默认情况下，从头覆盖）
  • 4.可以通过相关的操作，实现RandomAccessFile插入数据的效果

3.典型代码1：

 @Test
    public void test1()  {

        RandomAccessFile raf1 = null;
        RandomAccessFile raf2 = null;
        try {
            raf1 = new RandomAccessFile(new File("Jisoo.jpg"),"r");
            raf2 = new RandomAccessFile(new File("Jisoo2.jpg"),"rw");

            byte[] buffer = new byte[1024];
            int len;
            while((len = raf1.read(buffer)) != -1){
                raf2.write(buffer,0,len);

            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(raf1 != null){
                try {
                    raf1.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }

            }
            if(raf2 != null){

                try {
                    raf2.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

典型代码2：

/*
    使用RandomAccessFile实现数据的插入效果
     */
    @Test
    public void test3() throws IOException {

        RandomAccessFile raf1 = new RandomAccessFile("hello.txt","rw");

        raf1.seek(3);//将指针调到角标为3的位置

        //保存指针3后面的所有数据到StringBuilder中
        StringBuilder builder = new StringBuilder((int) new File("hello.txt").length());
        byte[] buffer = new byte[20];
        int len;
        while((len = raf1.read(buffer)) != -1){
            builder.append(new String(buffer,0,len));
        }

        //调回指针，写入"xyz"
        raf1.seek(3);
        raf1.write("xyz".getBytes());

        //将StringBuilder中的数据写入到文件中
        raf1.write(builder.toString().getBytes());

        raf1.close();

        //思考：将StringBuilder替换为ByteArrayOutputStream

    }

Path、Paths、Files的使用

1.NIO的使用说明：

Java NIO(New IO,Non-Blocking IO)是从Java1.4版本开始引入的一套新的 IO API，可以替代标准的Java IO API。
NIO与原来的IO同样的作用和目的，但是使用的方式完全不同，NIO支持面向缓冲区的(IO是面向流的)、基于通道的IO操作。

NIO将以更加高校的方式进行文件的读写操作。

随着JDK7的发布，Java对NIO进行了极大的扩展，增强了对文件处理和文件系统特性的支持，以至于我们称他们为NIO.2。

2.Path的使用—jdk7提供

2.1 Path的说明：

Path替换原有的File类。

2.2 如何实例化：

在这里插入图片描述

2.3 常用方法：
在这里插入图片描述

3.Files工具类—jdk7提供

3.1 作用：

操作文件或文件目录的工具类

3.2 常用方法：
在这里插入图片描述
在这里插入图片描述

37.2 �
关注
Linux-5-awk命令
weixin_57475485的博客
07-21 325
与sed一样，均是一行一行的读取、处理sed作用于一整行的处理，而awk将一行分成数个字段来处理BEGIN和END里的命令只执行一次BEGIN和END必须大写BEGIN和END不是必须的
Day63.IO流复习 -Java常用类、集合、IO#
阿昌爱Java
09-28 396
IO流复习 . File类的使用 1. File类的理解 1. File类的一个对象,代表一个文件或一个文件目录(俗称: 文件夹) 2. File类声明在java.io包下 3. File类中涉及到关于文件或文件目录的创建、删除、重命名、修改时间、文件大小等方法， 并未涉及到写入或读取文件内容的操作。如果需要读取或写入文件内容。就必须使用IO流来完成 4. 后续File类的对象常会作为参数传递到流的构造器中,指明读取或写入的"终点"。 2. File的实例化 常用构造器 File(String fi
IO流详解笔记
最新发布
weixin_72637723的博客
08-06 1106
IO流详解笔记；字节输入流：FileInputStream ；字节输出流：FileOutStream；字符输入流：FileReader；字符输出流：FileWriter；缓冲字节流：BufferedInputStream and BufferedOutStream； 缓冲字符流：BufferedReader and BufferedWriter；转换流：InputStreamReader and OutputStreamWriter ....等常用处理流
Linux awk
企鹅菜鸟的成长过程
03-11 428
1.命令行方式 awk [-F field-separator] 'commands' input-file(s) 其中，commands 是真正awk命令，[-F域分隔符]是可选的。 input-file(s) 是待处理的文件。 在awk中，文件的每一行中，由域分隔符分开的每一项称为一个域。通常，在不指名-F域分隔符的情况下，默认的域分隔符是空格。 2.shell脚本方式 将所有的awk
linux下awk的使用
热门推荐
起点的专刊
02-23 1万+
AWK是一种优良的文本处理工具。其名称得自于它的创始人 Alfred Aho 、Peter Weinberger 和 Brian Kernighan 姓氏的首个字母，AWK 提供了极其强大的功能：可以进行样式装入、流控制、数学运算符、进程控制语句甚至于内置的变量和函数。它具备了一个完整的语言所应具有的几乎所有精美特性。实际上 AWK 的确拥有自己的语言：AWK 程序设计语言， 三位创建者已将它正式...
Java 字节流与字符流（字节输出流：OutputStream）
Java软贱攻城狮
03-29 297
import java.io.File; import java.io.FileOutputStream; import java.io.OutputStream; public class Demo { public static void main(String[] args) throws Exception { File file = new File("e:" + File.se...
java IO流详细笔记
07-12
Java IO流详解
java IO流学习笔记——(1)文件字节流
12-21
java IO流学习笔记——(1) IO流总述 • 输入流：数据源到程序(InputStream、Reader读进来) • 输出流：程序到目的地(OutputStream、Writer写出去) 流分类 : • 节点流：可以直接从数据源或目的地读写数据 • 处理...
java-IO流与异常机制学习笔记
03-28
自己总结,知识点全面,包含了,IO流,异常机制等学习笔记 含有代码实例可供参考,需要mybase打开 持续更新,需要的自行下载 附上本人写的学习博客 https://blog.csdn.net/qq_35577787/article/details/105088073
马士兵 java IO流 笔记 和分析
08-30
以前学java时候看的马士兵老师的教程，老师讲的较快，有些不适应，自己做些笔记巩固练习，效果还不错，贴出来分析大家把，配图+示例。。。
io流的学习笔记
02-08
io流学习笔记，主要适合入门的人士学习及观看
字节流与字符流：OutputStream、InputStream、Writer、Reader
inter_stellar的博客
08-04 1037
字节流与字符流：OutputStream、InputStream、Writer、Reader
如何在Linux中使用awk工具详解
lin的专栏
05-29 437
awk 是一个强大的文本分析工具。它不仅是 Linux 中，也是任何环境中现有的功能最强大的数据处理引擎之一。相对于 grep 的查找，sed的编辑，awk在其对数据分析并生成报告时，显得尤为强大。     当你第一次拿起双手在电脑上使用 awk 命令处理一个或者多个文件的时候，它会依次读取文件的每一行内容, 然后对其进行处理，awk 命令默认从 stdio 标准输入获取
awk linux
u014133453的专栏
03-27 420
http://baike.baidu.com/link?url=E9V53yPaeCjIJoQCYEzYjFrMjsoWkhRyD3pi5JTGEzXStTT1rCafRkWJ8ZexGQf4
Linux命令 awk 入门教程
改变ing
01-09 381
参考： 阮一峰 占小狼的博客 2019-01-09   awk是处理文本文件的一个应用程序，几乎所有 Linux 系统都自带这个程序。   它依次处理文件的每一行，并读取里面的每一个字段。对于日志、CSV 那样的每行格式相同的文本文件，awk可能是最方便的工具。   awk其实不仅仅是工具软件，还是一种编程语言。不过，本文只介绍它的命令行用法，对于大多数场合，应该足够用了。 基本用法 awk的...
Linux awk命令_awk是一种处理文本文件的语言，一个强大的文本分析工具
陆山右的技术博客
02-28 1142
Linux 教程 Linux 教程 Linux 简介 Linux 安装 Linux 系统启动过程 Linux 系统目录结构 Linux 忘记密码解决方法 Linux 远程登录 ...
Linux的awk命令简单操作
weixin_33895604的博客
07-04 154
awk是一个编程工具，他有完整的语法和命令。在bash中，awk更多的用于处理列内容(我是这么认为的，仅供参考)awk程序的执行逻辑 首先将文本内容读入到内存中，根据字段分隔符，在读取文本内容的过程中把读入的内容分段，第一个字段对应$1，第二个字段对应$2，依次类推，$0代表所有的字段。注意： 1、在awk程序中，变量的使用不需要带$符号，因为$符号表示字...
Linxu三剑客——Linux awk命令详解
Itmastergo的博客
06-26 833
Linux 系统中有一个功能更加强大的文本数据处理工具，就是awk。它诞生于 20 世纪 70 年代末期，这也许是它影响了众多 Linux 用户的原因之一。曾有人推测 awk 命令的名字来源于 awkward 这个单词。其实不然，此命令的设计者有 3 位，他们的姓分别是 Aho、Weingberger 和 Kernighan，awk 就取自这 3 为大师姓的首字母。
Linux基本功十三：shell脚本Sed & Awk 及软件的安装
行而不辍，未来可期 - King
08-07 3404
shell脚本编程Scripting Language【把命令放到一个文本文件里，让其自动执行】 JSP-Java Service Page；perl python shell [bin/sh]--[bin/bash]不同的脚本其语法是不一样的。例如 bash csh tcsh ksh等 1、基础命令用法总结 wc命令。Linux系统中的wc(Word Count)命令的功能为统计指定文件中的字节数、字数、行数，并将统计结果显示输出。 -c 统计字节数。 -l 统计行数。 -m 统计字符数。这个标志
马士兵Java IO流详解与实战笔记
马士兵的Java IO流笔记和分析是对Java高级IO操作的深入学习资料，主要针对初学者在学习过程中可能遇到的理解难点进行讲解。以下是核心知识点的详细阐述： 1. **基础概念**： - Java中的流（Stream）是一种数据传输...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值