IO流

IO流概述及FileWriter类的使用
FileReader类使用
缓冲流介绍和使用
IO流相关案例

NO.one IO流概述及FileWriter类使用

1.1 IO流概述及分类

IO流用来处理设备之间的数据传输

Java对数据的操作是通过流的方式

Java用于操作流的类都在IO包中

流按流向分为两种：输入流，输出流

1.2 FileWriter类使用

A:打开帮助文档

B:点击显示，找到索引，看到输入框

C:你要学习什么内容，你就在框框里面输入什么内容

举例：Random

D:看包

java.lang包下的类在使用的时候是不需要导包的

E:看类的描述

Random类是用于生成随机数的类

F:看构造方法

Random():无参构造方法

Random r = new Random();

G:看成员方法

public int nextInt(int n):产生的是一个[0,n)范围内的随机数

调用方法：

看返回值类型：人家返回什么类型，你就用什么类型接收

看方法名：名字不要写错了

看形式参数：人家要几个参数，你就给几个，人家要什么数据类型的，

你就给什么数据类型的

int number = r.nextInt(100);

1.2.1 FileWriter向文件中写数据

A:FileWriter向文件中写数据操作步骤:

a:使用FileWriter流关联文件

b:利用FileWriter的写方法写数据

c:利用FileWriter的刷新方法将数据从内存刷到硬盘上

d:利用FileWriter的关流方法将释放占用的系统底层资源

B:FileWriter方法:

构造方法

FileWriter(String fileName) 传入一个文件的路径

成员方法

void write(String str) 向文件中写str

void flush() 将内存中的数据刷新到文件中

void close() 关流释放系统底层资源

1.2.1.1 案例代码一：

package com.gao_01;

import java.io.FileWriter;

import java.io.IOException;

/*

 * 需求：往文件中写数据

 *         写数据--输出流--FileWriter

 *

 * FileWriter:

 *         FileWriter(String fileName):传递一个文件名称

 *

 * 输出流写数据的步骤：

 *         A:创建输出流对象

 *         B:调用输出流对象的写数据的方法

 *         C:释放资源

 */

public class FileWriterDemo {

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

        //创建输出流对象

        FileWriter fw = new FileWriter("d:\\a.txt");

        /*

         * 创建输出流对象做了哪些事情:

         *         A:调用系统资源创建了一个文件

         *         B:创建输出流对象

         *         C:把输出流对象指向文件

         */

        //调用输出流对象的写数据的方法

        //写一个字符串数据

        fw.write("IO流你好");

        //数据没有直接写到文件，其实是写到了内存缓冲区

        fw.flush();

        //释放资源

        //通知系统释放和该文件相关的资源

        fw.close();

        //while(true) {}

    }

}

1.2.2 FileWriter 注意事项

1.2.2.1 案例代码二：

package com.gao_01;

import java.io.FileWriter;

import java.io.IOException;

/*

 * 输出流写数据的步骤：

 *         A:创建输出流对象

 *         B:调用输出流对象的写数据方法，并刷新缓冲区

 *         C:释放资源

 *

 * 相对路径：相对当前项目而言的，在项目的根目录下(a.txt)

 * 绝对路径：以盘符开始的路径(d:\\a.txt)

 *

 * close()和flush()方法的区别：

 *         flush():刷新缓冲区。流对象还可以继续使用。

 *         close():先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。

 */

public class FileWriterDemo2 {

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

        //创建输出流对象

        //FileWriter fw = new FileWriter("d:\\a.txt");

        FileWriter fw = new FileWriter("a.txt");

        //调用输出流对象的写数据方法，并刷新缓冲区

        fw.write("helloworld");

        fw.flush();

        fw.write("java");

        fw.flush();

        //释放资源

        fw.close();

        //Stream closed

        //fw.write("javaee");

        //fw.flush();

    }

}

1.2.3 FileWriter 其他写方法

void write(String str):写一个字符串数据

void write(String str,int index,int len):写一个字符串中的一部分数据

void write(int ch):写一个字符数据,这里写int类型的好处是既可以写char类型的数据，

也可以写char对应的int类型的值。'a',97

void write(char[] chs):写一个字符数组数据

void write(char[] chs,int index,int len):写一个字符数组的一部分数据

1.2.3.1 案例代码三：

package com.gao_01;

import java.io.FileWriter;

import java.io.IOException;

/*

 * void write(String str):写一个字符串数据

 * void write(String str,int index,int len):写一个字符串中的一部分数据

 * void write(int ch):写一个字符数据,这里写int类型的好处是既可以写char类型的数据，也可以写char对应的int类型的值。'a',97

 * void write(char[] chs):写一个字符数组数据

 * void write(char[] chs,int index,int len):写一个字符数组的一部分数据

 */

public class FileWriterDemo3 {

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

        //创建输出流对象

        FileWriter fw = new FileWriter("b.txt");

        //void write(String str):写一个字符串数据

        //fw.write("abcde");

        //void write(String str,int index,int len):写一个字符串中的一部分数据

        //fw.write("abcde",0,5);

        //fw.write("abcde",1,3);

        //void write(int ch):写一个字符数据,这里写int类型的好处是既可以写char类型的数据，也可以写char对应的int类型的值。'a',97

        //fw.write('a');

        //fw.write(97);

        //void write(char[] chs):写一个字符数组数据

        char[] chs = {'a','b','c','d','e'};

        //fw.write(chs);

        //void write(char[] chs,int index,int len):写一个字符数组的一部分数据

        //fw.write(chs,0,5);

        fw.write(chs,2,3);

        //释放资源

        fw.close();

    }

}

1.2.4 FileWriter 写入换行以及向文本末尾追加

1.2.4.1 案例代码四：

package com.gao_01;

import java.io.FileWriter;

import java.io.IOException;

/*

 * 如何实现数据的换行?

 *         \n可以实现换行，但是windows系统自带的记事本打开并没有换行，这是为什么呢?因为windows识别的换行不是\n，而是\r\n

 *         windows:\r\n

 *         linux:\n

 *         mac:\r

 * 如何实现数据的追加写入?

 *         FileWriter(String fileName, boolean append)

 */

public class FileWriterDemo4 {

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

        //创建输出流对象

        //FileWriter fw = new FileWriter("c.txt");

        FileWriter fw = new FileWriter("c.txt",true); //表示追加写入，默认是false

        for(int x=0; x<10; x++) {

            fw.write("hello"+x);

            fw.write("\r\n");

        }

        //释放资源

        fw.close();

    }

}

NO.two FileReader类使用

2.1 FileReader 读数据一次读取一个字符

2.1.1 案例代码五：

package com.gao_02;

import java.io.FileReader;

import java.io.IOException;

/*

 * 需求：从文件中读数据并显示到控制台

 *         读数据--输入流--FileReader

 *

 * FileReader:

 *         FileReader(String fileName):传递文件名称

 *

 * 输入流读文件的步骤：

 *         A:创建输入流对象

 *         B:调用输入流对象的读数据方法

 *         C:释放资源

 *

 * java.io.FileNotFoundException: fr.txt (系统找不到指定的文件。)

 */

public class FileReaderDemo {

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

        //创建输入流对象

//        FileReader fr = new FileReader("fr.txt");

        FileReader fr = new FileReader("FileWriterDemo.java");

        //调用输入流对象的读数据方法

        //int read():一次读取一个字符

        /*

        //第一次读数据

        int ch = fr.read();

        System.out.println(ch);

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

        //第二次读数据

        ch = fr.read();

        System.out.println(ch);

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

        //第三次读数据

        ch = fr.read();

        System.out.println(ch);

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

        //这是时候，我们发现代码的重复度很高，想用循环改进，但是不知道循环的结束条件是什么

        ch = fr.read();

        System.out.println(ch);

        ch = fr.read();

        System.out.println(ch);

        //通过测试，我们知道，如果读取数据的返回值是-1的时候，就说明没有数据了，这也是我们循环的结束条件

        */

        int ch;

        //1:fr.read()

        //2:ch=fr.read()

        //3:ch != -1

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

            //System.out.println(ch);

            //System.out.println((char)ch);

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

        }

        //释放资源

        fr.close();

    }

}

2.2 利用FileReader 和 FileWriter完成文件复制

2.2.1 读一次写一次

2.2.1.1 案例代码六：

package com.gao_03;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

/*

 * 需求：

 *         把项目路径下的FileWriterDemo.java中的内容复制到项目路径下的Copy.java中

 *

 * 文件复制也是有规律可循的，也就是说有套路。

 *

 * 数据源：

 *         FileWriterDemo.java -- 读数据 -- FileReader

 * 目的地：

 *         Copy.java -- 写数据 -- FileWriter

 */

public class CopyFileDemo {

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

        //创建输入流对象

        FileReader fr = new FileReader("FileWriterDemo.java");

        //创建输出流对象

        FileWriter fw = new FileWriter("Copy.java");

        //读写数据

        int ch;

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

            fw.write(ch);

        }

        //释放资源

        fw.close();

        fr.close();

    }

}

2.2.2 利用字符数组拷贝文件

2.2.2.1 案例代码七：

package com.gao_03;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

/*

 * 需求：

 *         把项目路径下的FileWriterDemo.java中的内容复制到项目路径下的Copy.java中

 *

 * 数据源：

 *         FileWriterDemo.java -- 读数据 -- FileReader

 * 目的地：

 *         Copy.java -- 写数据 -- FileWriter

 */

public class CopyFileDemo2 {

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

        //创建输入流对象

        FileReader fr  = new FileReader("FileWriterDemo.java");

        //创建输出流对象

        FileWriter fw = new FileWriter("Copy.java");

        //读写数据

        char[] chs = new char[1024];

        int len;

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

            fw.write(chs, 0, len);

        }

        //释放资源

        fw.close();

        fr.close();

    }

}

2.2.3 拷贝文件的两种方式图解

NO.three 缓冲流介绍和使用

3.1 缓冲流的基本使用

3.1.1 案例代码八：

package com.gao_04;

import java.io.BufferedReader;

import java.io.FileReader;

import java.io.IOException;

/*

 * BufferedWriter:将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

 * BufferedReader:从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。

 */

public class BufferedStreamDemo {

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

        //创建输出缓冲流对象

        /*

        BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));

        bw.write("hello");

        //bw.flush();

        bw.close();

        */

        //创建输入缓冲流对象

        BufferedReader br = new BufferedReader(new FileReader("FileWriterDemo.java"));

        /*

        //一次读写一个字符

        int ch;

        while((ch=br.read())!=-1){

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

        }

        */

        //一次读写一个字符数组

        char[] chs = new char[1024];

        int len;

        while((len=br.read(chs))!=-1) {

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

        }

        //释放资源

        br.close();

    }

}

3.2 缓冲流复制文本文件的两种方式

利用缓冲流把项目路径下的FileWriterDemo.java中的内容复制到项目路径下的Copy.java中

第一种方式:使用缓冲流不使用字符数组

第二种方式:使用缓冲流使用字符数组

3.2.1 案例代码九：

package com.gao_04;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

/*

 * 需求：

 *         把项目路径下的FileWriterDemo.java中的内容复制到项目路径下的Copy.java中

 *

 * 数据源：

 *         FileWriterDemo.java -- 读数据 -- FileReader -- 高效的读数据 -- BufferedReader

 * 目的地：

 *         Copy.java -- 写数据 -- FileWriter -- 高效的写数据 -- BufferedWriter

 */

public class CopyFileDemo {

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

        //创建输入缓冲流对象

        BufferedReader br = new BufferedReader(new FileReader("FileWriterDemo.java"));

        //创建输出缓冲流对象

        BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));

        //读写数据

        /*

        //一次读写一个字符

        int ch;

        while((ch=br.read())!=-1) {

            bw.write(ch);

        }

        */

//一次读写一个字符数组

        char[] chs = new char[1024];

        int len;

        while((len=br.read(chs))!=-1) {

            bw.write(chs,0,len);

        }

        //释放资源

        bw.close();

        br.close();

    }

}

3.3 缓冲流的特有方法使用

BufferedWriter

void newLine():写一个换行符，这个换行符由系统决定,不同的操作系统newLine()方法使用的换行符不同

windows: \r\n

linux: \n

mac: \r

BufferedReader

String readLine():一次读取一行数据，但是不读取换行符

3.3.1 案例代码十：

package com.gao_05;

import java.io.BufferedReader;

import java.io.FileReader;

import java.io.IOException;

/*

 * 缓冲流的特殊功能：

 * BufferedWriter

 *         void newLine():写一个换行符，这个换行符由系统决定

 * BufferedReader

 *         String readLine():一次读取一行数据，但是不读取换行符

 */

public class BufferedStreamDemo {

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

        /*

        BufferedWriter bw = new BufferedWriter(new FileWriter("bw2.txt"));

        for(int x=0; x<10; x++) {

            bw.write("hello"+x);

            //bw.write("\r\n");

            bw.newLine();

            bw.flush();

        }

        bw.close();

        */

        BufferedReader br = new BufferedReader(new FileReader("br.txt"));

        /*

        String line = br.readLine();

        System.out.println(line);

        line = br.readLine();

        System.out.println(line);

        line = br.readLine();

        System.out.println(line);

        line = br.readLine();

        System.out.println(line);

        */

        String line;

        //1:br.readLine()

        //2:line=br.readLine()

        //3:line != null

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

            System.out.println(line);

        }

        br.close();

    }

}

3.4 缓冲流的特有方法复制文件

3.4 案例代码十一：

package com.gao_05;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

/*

 * 需求：

 *         把项目路径下的FileWriterDemo.java中的内容复制到项目路径下的Copy.java中

 *

 * 数据源：

 *         FileWriterDemo.java -- 读数据 -- FileReader -- 高效的读数据 -- BufferedReader

 * 目的地：

 *         Copy.java -- 写数据 -- FileWriter -- 高效的写数据 -- BufferedWriter

 */

public class CopyFileDemo {

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

        //创建输入缓冲流对象

        BufferedReader br = new BufferedReader(new FileReader("FileWriterDemo.java"));

        //创建输出缓冲流对象

        BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));

        //读写数据

        String line;

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

            bw.write(line);

            bw.newLine();

            bw.flush();

        }

        //释放资源

        bw.close();

        br.close();

    }

}

NO.four IO流相关案例

4.1 复制文本文件的5中方式

A:利用基本流一次读写一个字符

B:利用基本流一次读写一个字符数组

C:利用缓冲流一次读写一个字符

D:利用缓冲流一次读写一个字符数组

E:利用缓冲流的特有方法一次读写一个字符串

4.1.1 案例代码十二：

package com.gao_06;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

/*

 * 复制文本文件(5种方式)

 *

 * 数据源：

 *         FileWriterDemo.java

 * 目的地：

 *         Copy.java

 */

public class CopyFileTest {

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

        /*

        method1("FileWriterDemo.java","Copy.java");

        method2("FileWriterDemo.java","Copy.java");

        method3("FileWriterDemo.java","Copy.java");

        method4("FileWriterDemo.java","Copy.java");

        method5("FileWriterDemo.java","Copy.java");

        */

        String srcFileName = "FileWriterDemo.java";

        String destFileName = "Copy.java";

//        method1(srcFileName,destFileName);

//        method2(srcFileName,destFileName);

        method3(srcFileName,destFileName);

//        method4(srcFileName,destFileName);

//        method5(srcFileName,destFileName);

    }

    //缓冲流一次读写一个字符串

    public static void method5(String srcFileName,String destFileName) throws IOException {

        //创建输入缓冲流对象

        BufferedReader br = new BufferedReader(new FileReader(srcFileName));

        //创建输出缓冲流对象

        BufferedWriter bw = new BufferedWriter(new FileWriter(destFileName));

        //一次读写一个字符串

        String line;

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

            bw.write(line);

            bw.newLine();

            bw.flush();

        }

        //释放资源

        bw.close();

        br.close();

    }

    //缓冲流一次读写一个字符数组

    public static void method4(String srcFileName,String destFileName) throws IOException {

        //创建输入缓冲流对象

        BufferedReader br = new BufferedReader(new FileReader(srcFileName));

        //创建输出缓冲流对象

        BufferedWriter bw = new BufferedWriter(new FileWriter(destFileName));

        //一次读写一个字符数组

        char[] chs = new char[1024];

        int len;

        while((len=br.read(chs))!=-1) {

            bw.write(chs,0,len);

        }

        //释放资源

        bw.close();

        br.close();

    }

    //缓冲流一次读写一个字符

    public static void method3(String srcFileName,String destFileName) throws IOException {

        //创建输入缓冲流对象

        BufferedReader br = new BufferedReader(new FileReader(srcFileName));

        //创建输出缓冲流对象

        BufferedWriter bw = new BufferedWriter(new FileWriter(destFileName));

        //一次读写一个字符

        int ch;

        while((ch=br.read())!=-1) {

            bw.write(ch);

        }

        //释放资源

        bw.close();

        br.close();

    }

    //基本流一次读写一个字符数组

    public static void method2(String srcFileName,String destFileName) throws IOException {

        //创建输入流对象

        FileReader fr = new FileReader(srcFileName);

        //创建输出流对象

        FileWriter fw = new FileWriter(destFileName);

        //一次读写一个字符数组

        char[] chs = new char[1024];

        int len;

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

            fw.write(chs,0,len);

        }

        //释放资源

        fw.close();

        fr.close();

    }

    //基本流一次读写一个字符

    public static void method1(String srcFileName,String destFileName) throws IOException {

        //创建输入流对象

        FileReader fr = new FileReader(srcFileName);

        //创建输出流对象

        FileWriter fw = new FileWriter(destFileName);

        //一次读写一个字符

        int ch;

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

            fw.write(ch);

        }

        //释放资源

        fw.close();

        fr.close();

    }

}

4.2 把集合中的数据写到文本文件

把ArrayList集合中的字符串数据存储到文本文件项目根目下的array.txt中

每一个字符串元素作为文件中的一行数据

4.2.1 案例代码十三：

package com.gao_06;

import java.io.BufferedWriter;

import java.io.FileWriter;

import java.io.IOException;

import java.util.ArrayList;

/*

 * 把ArrayList集合中的字符串数据存储到文本文件

 * 每一个字符串元素作为文件中的一行数据

 *

 * 分析：

 *         A:创建集合对象

 *         B:往集合中添加字符串元素

 *         C:创建输出缓冲流对象

 *         D:遍历集合，得到每一个字符串元素，然后把该字符串元素作为数据写到文本文件

 *         E:释放资源

 */

public class ArrayListToFileTest {

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

        //创建集合对象

        ArrayList<String> array = new ArrayList<String>();

        //往集合中添加字符串元素

        array.add("hello");

        array.add("world");

        array.add("java");

        //创建输出缓冲流对象

        BufferedWriter bw = new BufferedWriter(new FileWriter("array.txt"));

        //遍历集合，得到每一个字符串元素，然后把该字符串元素作为数据写到文本文件

        for(int x=0; x<array.size(); x++) {

            String s = array.get(x);

            bw.write(s);

            bw.newLine();

            bw.flush();

        }

        //释放资源

        bw.close();

    }

}

4.3 把文本文件中的数据读取到集合

从项目根目录下的array.txt文本文件中读取数据到ArrayList集合中，并遍历集合,每一行数据作为一个字符串元素

4.3.1 案例代码十四：

package com.gao_06;

import java.io.BufferedReader;

import java.io.FileReader;

import java.io.IOException;

import java.util.ArrayList;

/*

 * 从文本文件中读取数据到ArrayList集合中，并遍历集合

 * 每一行数据作为一个字符串元素

 *

 * 分析：

 *         A:创建输入缓冲流对象

 *         B:创建集合对象

 *         C:读取数据，每次读取一行数据，把该行数据作为一个元素存储到集合中

 *         D:释放资源

 *         E:遍历集合

 */

public class FileToArrayListTest {

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

        //创建输入缓冲流对象

        BufferedReader br = new  BufferedReader(new FileReader("array.txt"));

        //创建集合对象

        ArrayList<String> array = new ArrayList<String>();

        //读取数据，每次读取一行数据，把该行数据作为一个元素存储到集合中

        String line;

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

            array.add(line);

        }

        //释放资源

        br.close();

        //遍历集合

        for(int x=0; x<array.size(); x++) {

            String s = array.get(x);

            System.out.println(s);

        }

    }

}

Java IO流及应用（一）的更多相关文章

Java:IO流与文件基础
Java:IO流与文件基础说明: 本章内容将会持续更新,大家可以关注一下并给我提供建议,谢谢啦. 走进流什么是流流:从源到目的地的字节的有序序列. 在Java中,可以从其中读取一个字节序列的对象 ...
java IO流详解
流的概念和作用学习Java IO,不得不提到的就是JavaIO流. 流是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象.即数据在两设备间的传输称为流,流的本质是数据传输,根据数据传输 ...
Java IO流学习总结
Java流操作有关的类或接口: Java流类图结构: 流的概念和作用流是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象.即数据在两设备间的传输称为流,流的本质是数据传输,根据数据传输 ...
揭开Java IO流中的flush()的神秘面纱
大家在使用Java IO流中OutputStream.PrintWriter --时,会经常用到它的flush()方法. 与在网络硬件中缓存一样,流还可以在软件中得到缓存,即直接在Java代码中缓存. ...
java io流对文件夹的操作
java io流对文件夹的操作检查文件夹是否存在显示文件夹下面的文件 ....更多方法参考 http://www.cnblogs.com/phpyangbo/p/5965781.html ,与文 ...
Java IO流题库
一. 填空题 Java IO流可以分为节点流和处理流两大类,其中前者处于IO操作的第一线,所有操作必须通过他们进行. 输入流的唯一目的是提供通往数据的通道,程序可以通过这个通道读取数 ...
Java IO流总结
Java IO流分类以及主要使用方式如下: IO流 |--字节流 |--字节输入流 InputStream: int read();//一次读取一个字节 int read(byte[] bys);// ...
java io流运行错误时，保存异常到文件里面
java io流运行错误时,保存异常到文件里面下面这个实例,运行后,输入数字,为正确,如果输入字符串,则报错,保存错误信息 //运行错误时,保存异常到文件里面 //下面这个实例,运行后,输入数字, ...
java io流创建文件、写入数据、设置输出位置
java io流创建文件写入数据改变system.out.print的输出位置 //创建文件 //写入数据 //改变system.out.print的输出位置 import java.io.*; ...
java io流数据流传输
java io流数据流传输把这段当公式用就可以了 //数据流传输 import java.io.*; public class Index{ public static void main(Str ...

随机推荐

Oracle tablespace 创建表空间
定义: 表空间是一个逻辑概念,它的所有数据和结构信息都存储在一个或多个数据文件中,表空间属于数据库的一部分.数据库自带有几个表空间,如system,temp.一般系统将创建几个私用或业务的表空间. 模 ...
Oracle课程档案，第四天
“子查询”就是查询中嵌套着另一个查询,也即通过SELECT语句的嵌套使用形成子查询.当我们不知道特定的查询条件时,可以用子查询来为父查询提供查询条件以获得查询结果. 子查询先清除子查询在清除主查询 ...
linux --mariadb/redis数据库篇
mariadb ---磁盘型数据库基础安装配置好yum源后,软件就可以通过配置的yum源进行安装,按理来讲安装mysql直接通过 yum install mariadb -y 便可安装,但 ...
H5的缓存 manifest
H5里面的App Cache是由开发Web页面的开发者控制的,而不是由Native去控制的,但是Native里面的WebView也需要我们做一下设置才能支持H5的这个特性. 1.工作原理写Web页面 ...
C++ 在继承中虚函数、纯虚函数、普通函数，三者的区别
1.虚函数(impure virtual) C++的虚函数主要作用是“运行时多态”,父类中提供虚函数的实现,为子类提供默认的函数实现. 子类可以重写父类的虚函数实现子类的特殊化. 如下就是一个父类中的 ...
万能的DBHelper帮助类
DBHelper类: 简单的理解就是一个工具箱,我要用锤子的时候就在里面拿,我要用剪刀的时候也可以在里面拿,前提是我们写的DBHelper够不够强大! 软件中的四大功能:增.删.改.查我们要实现这 ...
Kali2安装完成后的设置
1.安装中文输入法 vim /etc/apt/sources.list 全部删除,改为国内源 #中科大 deb http://mirrors.ustc.edu.cn/kali kali-rolling ...
selenium 淘宝登入反爬虫解决方案（亲测有效）
前言目前在对淘宝进行数据爬取的时候都会碰到,登入时的滑块问题,无论是手动还是脚本都不成功.这里的很重要一个原因是很多的网站都对selenium做了反爬虫机制.接下来是笔者参考网上的网友们的方法亲自测 ...
linux下查看CPU、内存、磁盘信息
1.查看CPU信息# 总核数 = 物理CPU个数 X 每颗物理CPU的核数 # 总逻辑CPU数 = 物理CPU个数 X 每颗物理CPU的核数 X 超线程数 # 查看物理CPU个数cat /proc/c ...
C 二叉查找树的基本操作
最近研究一下二叉树排序问题,找到的资料还真是五花八门,说得也是千奇百怪. 分析一下原因,还是因为数的特性,造成结果的不唯一性造成的大家看了很多,似乎都有理,好像明白了,一综合又糊涂了的结果. 我这里给 ...

Java IO流及应用（一）

IO流

NO.one IO流概述及FileWriter类使用

Java IO流及应用（一）的更多相关文章

随机推荐

热门专题