NobilityQAQ
NobilityQAQ

Java学习笔记：IO流

File

File类概述和构造方法

File：它是文件和目录路径名的抽象表示

  • 文件和目录是可以通过File封装成对象的
  • 对于File而言，封装的并不是一个真正存在的文件，仅仅是一个路径而已。这个路径可以存在也可以不存在，但将来是要通过具体的操作把这个路径的内容转换为具体存在的

构造方法

  • File(String pathname)通过将给定的路径名字符串转换为抽象路径名来创建新的File实例
    File f1= new File("E:\\itcast\\java.txt");
  • File(String parent, String child)从父路径名字符串和子路径名字符串创建新的File实例
    File f2= new File("E:\\itcast","java.txt");
  • File(File parent,String child)从父抽象路径名和子路径名字符串创建新的File实例
    File f3= new File("E:\\itcast");
    File f4= new File(f3,"java.txt");

File类创建功能

  • public boolean createNewFile()当具有该名称文件不存在是，创建一个由该抽象路径名命名的新空文件
File f = new File("E:\\itcast\\java.txt");
System.out.println(f.createNewFile());//文件存在返回false，不存在返回true
  • public boolean mkdir()创建由此抽象路径名命名的目录
File f = new File("E:\\itcast\\JavaSE");
System.out.println(f.mkdir());//目录存在返回false，不存在返回true，但无法创建多级目录
  • public boolean mkdirs()创建由此抽象路径名命名的目录，包括任何必须但不存在的父目录
File f = new File("E:\\itcast\\JavaWEB\\Html");
System.out.println(f.mkdirs());//目录存在返回false，不存在返回true，可以创建多级目录

File类的判断和获取功能

  • public boolean isDirectory()测试此抽象路径名表示的File是否为目录
  • public boolean isFile()测试此抽象路径名表示的File是否为文件
  • public boolean exists()测试此抽象路径名表示的File是否存在
  • public String getAbsolutePath()返回此抽象路径名的绝对路径名字符串
  • public String getPath()将此抽象路径名转换为路径名字符串
  • public String getName()返回由此抽象路径名表示的文件或目录的名称
  • public String[] list()返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
    String[] strArray = f.list();//当前目录下所有内容存入字符串数组中，可以通过输出字符串数组输出内容
  • public File[] listFiles()回此抽象路径名表示的目录中的文件和目录的File对象数组
File[] fileArray = f.listFiles();//当前目录下所有内容存入File型数组中
for(File file:fileArray){
      if(file.isFile()){
             System.out.println(file.getName());
      }
}

File类的删除功能

  • public boolean delete()删除由此抽象路径名表示的文件或目录
    若是目录下有内容(文件或目录)不能直接删除目录，要先删除内容
  • 绝对路径和相对路径
    绝对路径：完整的路径名，不需要其他信息就可以定位它表示的文件
    eg:E:\\itcast\\java.txt
    相对路径：必须使用取自其他路径名的信息进行解释
    eg:myFile\\java.txt 这里的myFile是project的模块名

递归

  • 递归解决问题需要找到的内容
    递归出口：否则会出现内存溢出
    递归规则：转换为与原问题相似的规模较小问题
  • 递归求阶乘
public static void main(String[] args) {
        int result=jc(5);
        System.out.println("5的阶乘是："+result);
}
public static int jc(int n){
        if(n==1){
            return 1;
        }else{
            return n*jc(n-1);
        }
}
  • 用递归遍历目录
public static void main(String[] args) {
        //根据给的的路径创建一个file对象
        File srcfile=new File("D:\\itcast");
        //调用方法
        getAllFilePath(srcfile);
}
//定义1个方法，用于获取给的目录下的所有内容，参数为第1步创建的File对象
public static void getAllFilePath(File srcFile){
        //获取给定的File目录下所有文件或者目录的File数组
        File[] fileArray=srcFile.listFiles();
        //遍历该File数组，得到每1个File对象
        if(fileArray!=null){
            for(File file :fileArray){
                //判断该File对象是否是目录
                if(file.isDirectory()){
                    //是：递归调用
                    getAllFilePath(file);
                }else{
                    //不是，获取绝对路径输出在控制台
                    System.out.println(file.getAbsolutePath());
                }
            }
        }
}

字节流

IO流概述和分类

IO流概述

  • IO：输入/输出(Input/Output)
  • 流：是一种抽象的概念，是对数据传输的总称。数据在设备间传输称为流，流的本质是数据传输
  • IO流就是用来处理数据传输问题的(eg：文件复制，文件上传，文件下载)

IO流分类

  • 按照数据的流向
    输入流：读数据；输出流：写数据；
  • 按照数据类型来分
    字节流：字节输入流、字节输出流；
    字符流：字符输入流、字符输出流；
    区分方式：数据用windows自动记事本软件打开，我们可以读懂，就使用字符流，否则使用字节流。不知道使用哪种流，就使用字节流

字节流写数据

字节流抽象基类

  • InputStream：此抽象类是表示字节输入流的所有类的超类
  • OutputStream：此抽象类是表示字节输出流的所有类的超类
  • 子类名特点：子类名称都是以其父类名作为子类名的后缀

构造方法：
FileOutputStream：文件输出流用于将数据写入File

  • FileOutputStream(String name)创建文件输出流以指定的名称写入文件
  • void write(int b)将指定字节写入此文件输出流
  • void close()关闭此文件输出流并释放与此相关联的任何系统资源
//创建字节流输出对象
FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");

FileOutputStream fos = new FileOutputStream(new File("myByteStream\\fos.txt"));

File file = new File("myByteStream\\fos.txt");
FileOutputStream fos = new FileOutputStream(file);
//上述3个创建方式效果一致
/*
     完成了3个操作：A.调用系统功能创建了文件
                   B.创建了字节输出流对象
                   C.让字节输出流对象指向创建好的文件
*/
fos.write(97);//输入的不是97，而是97的ascII码对应的内容a
fos.close();

字节流写数据3种方式

  • void write(int b)将指定的字节写入此文件输出流，1次写1个字节数据
  • void write(byte[] b)将b.length长度字节数组写入此文件输出流，1次写1个字节数组数据
byte[ ] bys = {97,98,99,100,101};
fos.write(bys);//将字符数组“abcde”写入文件中
//byte[ ] getBytes():返回字符串对应的字节数组
byte[ ] bys="abcde".getBytes();
fos.write(bys);
  • void write(byte[] b,int off,int len)对指定字节数组b，从偏移量off(索引位置)开始,取长度为len的字符数据，写入此文件输出流，1次写1个字节数组的部分数据
byte[ ] bys = "abcde".getBytes();
fos.write(bys,1,3);
fos.close();//完成操作后一定要释放资源

字节流写数据的两个小问题

  • 字节流写数据如何实现换行
    windows:\r\n
    linux:\n
    mac:\r
    eg:fos.write("\r\n".getBytes());
  • 字节流写数据如何实现追加写入
    public FileOutputStream(String name,boolean append)
    创建文件输出流以指定的名称写入文件
    如果第二个参数为true，则字节将写入文件的末尾而不是开头
    eg:FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt",true)

字节流写数据加入异常处理
finally：在异常处理时提供finally块来执行所有的清除操作，例如IO流中释放资源
finally控制的语句一定会执行，除非jvm退出

格式
try{
      可能出现异常的代码;
}catch(异常类名  变量名){
      异常的处理代码;
}finally{
      执行所有的清楚操作;
}
eg:
FileOutputStream fos = null;
try{
      fos=new FileOutputStream("myByteStream\\fos.txt");
      fos.write("hello".getBytes());
}catch(IOException e){
      e.printStackTrace();
}finally{
      if(fos != null);{
            try{
                 fos.close()
            }catch(IOException e){
                 e.printStackTrace();
            }
      }
}

字节流读数据

FileInputStream：从文件系统中的文件获取输入字节

  • FileInputStream(String name)通过打开与实际文件的连接来创建一个FileInputStream,该文件由文件系统中的路径名name命名
  • 1次读1个字节步骤
    1.创建字节输入流对象
    2.调用字节输入流对象的读数据方法
    3.释放资源
FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");
int by;
/*
    read():方法读到空数据会返回-1
    fis.read():读数据
    by=fis.read():把读取到的数据赋给by
    by != -1 :判断读到的数据是否是-1
*/
while((by=fis.read())!=-1){
     System.out.print((char)by)//可以读取到换行，不需要加ln，需要char强制字符转换
}
fis.close();
  • 1次读1个字节数组
FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");
//int read(byte[] b);从该输入流读取最多b.length个字节的数据到1个字节数组
byte[] bys = new byte[1024]
int len;
while((len=fis.read(bys))!=-1){
     System.out.print(new String(bys,0,len));
}
fis.close();

复制文本文件

//根据数据源创建字节输入流对象
FileInputStream fis = new FileInputStream("E:\\itcast\\窗里窗外.txt");
//根据目的地创建字节输出流对象
FileOutputStream fos= new FileOutputStream("myByteStream\\窗里窗外.txt");
//读写数据，复制文本文件(1次读取1个字节，1次写入1个字节)
int by;
while((by=fis.read())!=-1){

            fos.write(by);
}
//释放资源
fos.close();
fis.close();

复制图片

//根据数据源创建字节流输入对象
FileInputStream fis=new FileInputStream("E:\\itcast\\mn.jpg");
//根据目的地创建字节输出流对象
FileOutputStream fos=new FileOutputStream("myByteStream\\mn.jpg");
//读写数据，复制图片(1次读取1个字节数组，1次写入1个字节数组)
byte[] bys=new byte[1024];
int len;
while((len=fis.read(bys))!=-1){
            fos.write(bys,0,len);
}
fos.close();
fis.close();

字节缓冲流

字节缓存流

  • BufferOutputStream:该类实现缓冲输出流。通过设置这样的输出流，应用程序向底层写入字节时，不必为每个字节进行底层系统调用
  • BufferedInputStream:创建此将创建一个内部缓冲区数组。当从流中读取或跳过字节时，内部缓冲区会根据需要从所包含的输入流中重新填充。

构造方法

  • 字节缓冲输出流：BufferedOutputStream(OutputStream out)
  • 字节缓冲输入流：BufferedInputStream(InputStream in)
  • 方法需要的是字节流，而非文件或路径：
    字节缓冲流仅仅提供缓冲区，真正读写数据还要依靠基本的字节流对象进行操作
写入数据
FileOutputStream fos = new FileOutputStream("myByteStream\\bos.txt");
BufferedOutputStream bos = new BufferedOutputStream(fos);
/*等同于BufferedOutputStream bos = 
new BufferedOutputStream(new FileOutputStream("myByteStream\\bos.txt"));*/
bos.write("hello\r\n".getBytes());
bos.write("write\r\n".getBytes());
bos.close();

读出数据
BufferedInputStream bis = 
new BufferedInputStream(new FileInputStream("myByteStream\\bos.txt"));
//1次读取1个字节数据
int by;
while((by=bis.read())!=-1){
      System.out.println((char)by);
}
//1次读取1个字节数组数据
byte[] bys = new byte[1024];
int len;
while((len=bis.read(bys))!=-1){
       System.out.println(new String(bys,0,len));
}
bis.close();

复制视频
4种方式，其中基本字节流1次读取1个字节数据最慢

public static void main(String[] args) throws IOException {
        //记录开始时间
        long startTime = System.currentTimeMillis();
        //复制视频
        method1();
        method2();
        method3();
        method4();
        //记录结束时间
        long endTime=System.currentTimeMillis();
        System.out.println("共耗时："+(endTime-startTime)+"毫秒");
    }
    //基本字节流1次读写1个字节
    public static void method1() throws IOException {
        FileInputStream fis = new FileInputStream("E:\\itcast\\字节复制.avi");
        FileOutputStream fos=new FileOutputStream("myByteStream\\字节复制.avi");
        int by;
        while((by=fis.read())!=-1){
            fos.write(by);
        }
        fos.close();
        fis.close();
    }
    //基本字节流1次读写1个字节数组
    public static void method2() throws IOException {
        FileInputStream fis = new FileInputStream("E:\\itcast\\字节复制.avi");
        FileOutputStream fos=new FileOutputStream("myByteStream\\字节复制.avi");
        byte[] bys=new byte[1024];
        int len;
        while((len=fis.read(bys))!=-1){
            fos.write(bys,0,len);
        }
        fos.close();
        fis.close();
    }
    //字节缓冲流1次读写1个字节
    public static void method3() throws IOException {
        BufferedInputStream bis=new BufferedInputStream(new FileInputStream("E:\\itcast\\字节复制.avi"));
        BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("myByteStream\\字节复制.avi"));
        int by;
        while((by=bis.read())!=-1){
            bos.write(by);
        }
        bos.close();
        bos.close();
    }
    //字节缓冲流1次读写1个字节数组
    public static void method4() throws IOException {
        BufferedInputStream bis=new BufferedInputStream(new FileInputStream("E:\\itcast\\字节复制.avi"));
        BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("myByteStream\\字节复制.avi"));
        byte[] bys=new byte[1024];
        int len;
        while((len=bis.read(bys))!=-1){
            bos.write(bys,0,len);
        }
        bos.close();
        bis.close();
}

字符流

字符流出现原因

  • 字节流操作中文不便，java提供字符流
    字符流 = 字节流 + 编码表
  • 字节流复制文本文件时对中文解决方案
    汉字存储：GBK编码，占2个字节；UTF-8编码，占3个字节
    底层操作自动进行字节拼接成中文，且汉字存储时，第一个字节总是负数

编码表

  • GBK：最常用的中文码表，GB2312标准基础上的扩展规范，双字节编码方法，支持繁体简体，日韩文汉字
  • UTF-8编码：表示Unicode标准(能表达任意语言，业界统一标准，有UTF-8，UTF-16，UTF-32三种编码方案)中任意字符。电子邮件，网页和其他存储或传输文字应用中优先采用的编码，所有互联网协议都必须支持UTF-8编码。使用1-4字节为每个字符编码。

ps:1.128ASCII码-1字节；拉丁文等-2字节；大部分常用文字包括中文-3字节
2.采用任何规则编码，就要采用对应规则解码，否则会出现乱码

字符串中编码解码问题

编码

  • byte[] getBytes():
    使用平台默认字符集将该String编码为一系列字节，将结果存储到新的字节数组中
String s="中国";
byte[] bys=s.getBytes();
  • byte[] getBytes(String charsetName):
    使用指定的字符集将该String编码为一系列字节，将结果存储到新的字节数组中
String s="中国";
byte[] bys=s.getBytes("UTF-8");
byte[] bys=s.getBytes("GBK");

解码

  • String(byte[] bytes):
    通过使用平台的默认字符集解码指定的字节数组来构造新的String
String ss = new String(bys)//bys是存储编码后信息的字节数组
  • String(byte[] bytes,String charsetName):
    通过指定的字符集解码指定的字节数组来构造新的String
byte[] bys=s.getBytes("UTF-8");//怎么编码就怎么解码
String ss = new String(bys,"UTF-8");
byte[] bys=s.getBytes("GBK");
String ss = new String(bys,"GBK");

字符流的编码解码问题

字符流抽象基类

  • Reader:字符输入流的抽象类
  • Writer:字符输出流的抽象类

字符流和编码解码问题相关的两个类

  • InputStreamReader字节流到字符流的桥梁
    读取字节，并使用指定的编码将其解码为字符
    使用字符集可以由名称指定，也可以被明确指定，或者可以接收平台默认字符集
InputStreamReader isr=new InputStreamWriter(new FileOutputStream("myChartStream\\osw.txt"),"xxxx")
//可以自选编码方式，或者不写采用默认编码
//1次读取1个字符数据
int ch
while((ch=isr.read())!=-1){
       System.out.print((char)ch);
}
isr.close();
  • OutputStreamWriter字符流到字节流的桥梁
    使用指定的编码将写入的字符编码为字节
    使用字符集可以由名称指定，也可以被明确指定，或者可以接收平台默认字符集
OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("myChartStream\\osw.txt"),"xxxx")
//可以自选编码方式，或者不写采用默认编码
osw.write("中国");
osw.close();

字符流写数据的5种方式

  • void write(int c)写一个字符
  • void write(char[] cbuf)写入一个字符数组
  • void write(char[] cbuf,int off,int len)写入字符数组的一部分(索引位置off开始，长度len)
  • void write(String str)写一个字符串
  • void write(String str,int off,int len)写一个字符串的一部分索引位置off开始，长度len)
  • void flush()刷新流，还可以继续写数据
  • void close()关闭流，释放资源，但在关闭前会先刷新流。一旦关闭就不能再写数据
//创建1个使用默认字符编码的OutputStreamWriter
OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("FileIO\\osw.txt"));
//void write(int c)写1个字符
osw.write(97);
osw.flush();//void flush():刷新流
//写入一个字符数组
char[] chs={'a','b','c','d','e'};
osw.write(chs);
//写入字符数组的一部分
osw.write(chs,1,3);
//写一个字符串
osw.write("abcde");
//写一个字符串一部分
osw.write("abcde",1,3);
osw.close();

字符流读数据的2种方式

  • int read()一次读一个字符数据
  • int read(char[] cbuf)一次读一个字符数组数据
//创建1个使用默认字符集的InputStreamReader
 InputStreamReader isr=new InputStreamReader(new FileInputStream("FileIO\\osw.txt"));
//1次读1个字符数据
int ch;
while((ch=isr.read())!=-1){
     System.out.println((char)ch);
}
//1次读1个字符数组数据
char[] chs=new char[1024];
int len;
while((len=isr.read(chs))!=-1){
      System.out.println(new String(chs,0,len));
}
isr.close();

案例：复制java文件

//根据数据源创建字符输入流对象
 InputStreamReader isr=new InputStreamReader(new FileInputStream("FileIO\\isw.java"));
//根据目的地创建字符输出流对象
OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream("FileIO\\osw.java"));
//1次读1个字符数组数据
char[] chs=new char[1024];
int len;
while((len=isr.read(chs))!=-1){
      osw.write(chs,0,len);
}
isr.close();
osw.close();

复制java文件改进

  • FileReader(String fileName)用于读取字符文件的便捷类，InputStreamReader子类
  • FileWriter(String fileName)用于写入字符文件的便捷类，OutputStreamWriter子类
//根据数据源创建字符输入流对象
FileReader fr=new FileReader("FileIO\\fr.java");
//根据目的地创建字符输出流对象
FileWriter fw=new FileWriter("FileIO\\fw.java");
//1次读1个字符数组数据
char[] chs=new char[1024];
int len;
while((len=fr.read(chs))!=-1){
      fw.write(chs,0,len);
}
isr.close();
osw.close();

字符缓冲流

  • BufferedWriter(Writer out)将文本写入字符输出流，缓冲字符，以提供单个字符、数组和字符串的高效写入，可以指定缓冲区大小，或默认大小。
BufferedWriter bw=new BufferedWriter(new FileWriter("FileIO\\bw.txt"));
bw.write("hello\r\n");
bw.write("world\r\n");
bw.close();
  • BufferedReader(Reader in)从字符输入流读取文本，缓冲字符，以提供字符、数组和行的高效读取，可以指定缓冲区大小，或默认大小。
BufferedReader br=new BufferedReader(new FileReader("FileIO\\br.txt"));
//1次读1个字符数据
int ch;
while((ch=br.read())!=-1){
            System.out.println((char)ch);
}
//1次读1个字符数组数据
char[] chs=new char[1024];
int len;
while((len=br.read(chs))!=-1){
            System.out.println(new String(chs,0,len));
}
br.close();

用缓冲流进行java文件复制和上面案例一致，只是创建的输入流和输出流对象不同
字符缓冲流特有功能
BufferedWriter

  • void newLine():写一行,行分隔符，行分隔符字符串由系统属性定义

BufferedReader:

  • public String readLine():读一行文字。结果包含行的内容的字符串，不包括任何行终止字符，如果流已经到达结尾，则为null

用特有功能复制java文件

//根据数据元源创建字符缓冲输入流对象
BufferedReader br=new BufferedReader(new FileReader("FileIO\\br.java"));
//根据目的地创建字符缓冲输出流对象
BufferedWriter bw=new BufferedWriter(new FileWriter("FileIO\\bw.java"));
//读写数据，复制文件
//使用字符缓冲流特有功能实现
String line;
while((line=br.readLine())!=null){
      bw.write(line);
      bw.newLine();
      bw.flush();
}
//释放资源
bw.close();
br.close();

IO流小结

Java学习笔记：IO流_第1张图片
2021-01-31_172450.jpg

字节输入流2种读数据方式，字节输出流也是两种写数据方式
字节流可以复制任意文件数据，4种方式一般采用字节缓冲流1次写1个字节数组方式


Java学习笔记：IO流_第2张图片
2021-01-31_172631.jpg

字符流涉及编码问题只能用InputStream
字符流只能复制文本数据，5种方式一般采用字符缓冲流的特有功能

特殊操作流

标准输入流

System类中有两个静态的成员变量

  • public static final InputStream in
    标准输入流，通常该流对应于键盘输入或由主机环境或用户指定的另一个输入源
  • public static final PrintStream out
    标准输出流，通常该流对应于显示输出或由主机环境或用户指定的另一个输出目标

在不用Scanner的情况下实现键盘录入数据

  • BufferedReader br = new BufferedReader(new InputStreamReader(System.in))
    将键盘录入转化为字节流再转化为字符缓冲输出流，就可以读中文和数字

输出语句的本质：是一个标准的输出流

  • PrintStream ps = System.out
  • PrintStream类有的方法，System.out都可以使用

打印流

打印流分类

  • 字节打印流：PrintStream
  • 字符打印流：PrintWriter

打印流特点

  • 只负责输出数据，不负责读取数据
  • 有自己的特有方法

字节打印流

  • PrintStream(String fileName)：使用指定的文件名创建新的打印流
  • 使用继承父类的方法write()方法写数据，查看的时候会转码；
    使用自己特有的方法print(),println()写数据，查看的数据原样输出；
PrintStream ps = new PrintStream("FileIO\\ps.txt");
ps.write(97);//输出a
ps.print(97);//输出97

字符打印流
构造方法

  • PrintWriter(String fileName)用指定的文件名创建1个新的PrintWriter，不需要自动执行刷新
PrintWriter pw=new PrintWriter("FileIO\\pw.txt");
此类pw，write()写数据不刷新，println()写数据换行但不刷新
  • PrintWriter(Writer out,boolean autoFlush)创建1个新的PrintWriter
    out:字符输出流
    autoFlush:一个布尔值，如果为真，则println,printf,format方法将刷新输出缓冲区
PrintWriter pw=new PrintWriter(new FileWriter("FileIO\\pw.txt"，true));
此类pw，println()写数据换行且刷新

打印流改进复制java文件

//把模块目录下的PrintStreamDemo.java文件复制到模块目录下Copy.java
public class CopyJavaDemoImprove {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字符输入流对象
        BufferedReader br=new BufferedReader(new FileReader("FileIO\\PrintStreamDemo.java"));
        //根据目的地创建字符输出流对象
        PrintWriter pw=new PrintWriter(new FileWriter("FileIO\\Copy.java"),true);
        //读写数据，复制文件
        String line;
        while((line=br.readLine())!=null){
            pw.println(line);
        }
        //释放文件
        pw.close();
        br.close();
    }
}

对象序列化流

对象序列化：将对象保存在磁盘中，或者在网络中传输对象
这种机制就是使用1个字节序列表示1个对象

字节序列

  • 包含:对象的类型、对象的数据、对象中存储的属性等
  • 字节序列写到文件后，相当于文件中持久保存了1个对象的信息，因此可以从文件中读取字节序列，重构对象，并对它进行反序列化

对象序列化流

  • ObjectOutputStream将Java对象原始数据类型和图型写入OutputStream
    可以使用其读取重构对象，也可以通过流的文件来实现对象的持久存储
    如果流是网络套接字流，则可以在另一主机或进程中重构对象
  • 构造方法ObjectOutputStream(OutputStream out)
    创建一个写入指定的OutputStream的ObjectOutputStream
  • 序列化对象的方法void writeObject(Object obj)
    将指定的对象写入ObjectOutputStream
public class Student implements Serializable {
     ......
}
public static void main(String[] args) throws IOException {
        //创建1个写入指定OutputStream的ObjectOutputStream
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("FileIO\\oos.txt"));
        //创建对象
        Student s=new Student("Jack",20);
        //将指定的对象写入ObjectOutputStream
        oos.writeObject(s);
        //释放资源
        oos.close();
}

ps
1.类的序列化由实现java.io.Serializable接口的类启用，不实现此接口的类将不会使任何状态序列化或反序列化
2.Serializable是一个标记接口，实现该接口，不需要重写任何方法

对象反序列化流

  • 对象反序列化流ObjectInputStream
    反序列化先前使用ObjectOutputStream编写的原始数据和对象
  • 构造方法ObjectInputStream(InputStream in)
    创建从指定的InputStream读取的ObjectInputStream
  • 反序列化对象的方法Object readProject()
    从ObjectInputStream读取一个对象
public static void main(String[] args) throws IOException, ClassNotFoundException {
        //创建从指定的InputStream读取的ObjectInputStream
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream("FileIO\\oos.txt"));
        //从ObjectInputStream中读取一个对象
        Object obj=ois.readObject();
        Student s=(Student)obj;
        System.out.println(s.getName()+","+s.getAge());
        ois.close();
}

对象序列化流操作中的3个问题、

  • 对象序列化流序列化1个对象后，加入修改了对象所属的类文件，读取数据是否会出问题？
    会，当序列化运行是检测到类中的以下问题之一时抛出
    1.类的串行版本与从留中读取的类描述符的类型不匹配
    2.该类包含未知的数据类型
    3.该类没有可访问的无参数构造函数

  • 出了第一个问题如何处理？
    给对想所属的类加一个序列化ID值
    private static final long serialVersionUID = 42L

  • 1个对象中的某个成员变量的值不想被序列化，该如何实现？
    使用transient来修饰成员变量
    eg: private transient int age

Properties

Properties概述

  • 是一个Map体现的集合类
  • Properties可以保存到流中或从流中加载

作为Map集合使用

//创建集合对象
Properties prop=new Properties();
//存储元素
prop.put("jack",30);
prop.put("tom",26);
prop.put("mary",35);
//遍历集合
//不知道泛型，所以每个键和值都是Objcet型
Set keySet=prop.keySet();
for(Object key:keySet){
       Object value=prop.get(key);
       System.out.println(key+","+value);
}
 
 
Properties作为集合的特有方法
 
 
     
  
  •  Object setProperty(String key,String value)
     设置集合的键和值，都是String型，底层调用Hashtable方法put
     prop.setProperty("B17041634","张三") 
    •  
  
  •  String getProperty(String key)
     使用此属性列表中指定的键搜索属性
     prop.getProperty("B17041634") 
    •  
  
  •  Set stringPropertyNames()
     从该属性列表返回一个不可修改的键集，其中键及其对应的值是字符串
    •  
 
 
 
Set names=prop.stringPropertyNames();
for(String key:names){
     System.out.println(key);
}

 
 
Properties和IO流结合的方法
 
 
     
  
  • 与字节流结合
     void load(InputStream inStream)从输入字节流读取属性列表(键和元素对)
     void store(OutputStream out,String comments)
     将此属性列表(键和元素对)写入此Properties表中，以适合于使用load(InputStream)方式的格式写入输出字节流
    •  
  
  • 与字符流结合
     void load(Reader reader)从输入字符流读取属性列表(键和元素对)
     void store(Writer writer,String comments)
     将此属性列表(键和元素对)写入此Properties表中，以适合于使用load(Reader)方式的格式写入输出字符流
    •  
 
 
 
public static void main(String[] args) throws IOException {
        //把集合中的数据保存到文件
        myStore();
        //把文件中的数据加载到集合
        myload();
    }

    private static void myload() throws IOException{
        Properties prop=new Properties();
        FileReader fr=new FileReader("FileIO\\fr.txt");
        prop.load(fr);
        fr.close();
        System.out.println(prop);
    }

    private static void myStore() throws IOException {
        Properties prop=new Properties();
        prop.setProperty("B17041723","Jack");
        prop.setProperty("B17041743","Tom");
        prop.setProperty("B17041712","Mary");
        FileWriter fw=new FileWriter("FileIO\\fw.txt");
        prop.store(fw,null);
        fw.close();
}

 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Java学习笔记：IO流)

        

            

                
    
                    
  • JAVA学习笔记之23种设计模式学习
                        victorfreedom
Java技术设计模式androidjava常用设计模式
                        
    博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
    
                    
    • 
                    
  • 三分钟带你了解Python文件操作与IO流
                        4.0啊
Python教学系列python开发语言文件操作
                        
    在探索编程世界的奇幻旅程中，文件操作和IO（输入/输出）流是每一个探险者必须掌握的基础技能。在Python的世界中，这些技能尤为关键，它们像是巫师手中的魔杖，能让我们与文件进行深度的交流。本文将带你快速了解Python中的文件操作和IO流，通过大量的实例和代码，确保你能够自信地在Python的世界中畅游。目录一、Python文件操作基础1.打开文件a.文件模式2.关闭文件b.使用with语句二、文
    
                    
    • 
                    
  • C++ IO流
                        元凌丶
c++开发语言
                        
    C++标准IO流使用cout进行标准输出，即数据从内存流向控制台(显示器)使用cin进行标准输入，即数据通过键盘输入到程序中使用cerr进行标准错误的输出使用clog进行日志的输出C++文件IO流文件流对象ofstream：只写ofstream是C++中用于输出文件操作的一个类，它可以创建新文件用于写入或者向已存在的文件写入数据。ofstream属于头文件中定义的一部分，是用于处理文件输出流的。基
    
                    
    • 
                    
  • Java基础 --- 多线程&JUC，以及一些常用的设计模式总结
                        lzhlizihang
java设计模式
                        
    文章目录一、多线程1、线程和进程的区别2、创建多线程的四种方式3、集合中的线程安全二、设计模式1、单例模式2、装饰者模式（IO流缓冲流）3、适配器模式4、模板模式一、多线程1、线程和进程的区别进程是操作系统资源分配的基本单位，而线程是处理器任务调度和执行的基本单位，一个进程可以运行多个线程多进程：操作系统中同时运行的多个程序多线程：在同一个进程中同时运行的多个任务2、创建多线程的四种方式Runna
    
                    
    • 
                    
  • java中IO流详解
                        一路向上的桃子
学习资料java
                        
    java中IO流详解转载：https://www.cnblogs.com/biehongli/p/6074713.html
    
                    
    • 
                    
  • Java中的IO流详解
                        Bro_cat
Javajava开发语言
                        
    Java的输入输出（IO）流是处理数据读写的基础。它们允许程序与外部设备（如文件、网络等）进行数据交互。Java中的IO流主要分为字节流和字符流，每种流都有其特定的用途和类结构。IO流的基本概念IO流是Java提供的一种用于处理输入输出的机制。它提供了一种统一的方式来处理不同类型的输入输出设备。输入流（InputStream/Reader）：用于从外部设备读取数据到程序中。输出流（OutputSt
    
                    
    • 
                    
  • 09.IO流
                        复活吧我的艾斯
java前端服务器
                        
    一.常用的文件操作1.如何创建文件：newFile(Stringpathname)//根据路径构建一个File对象newFile(Fileparent,Stringchild)/根据父目录文件+子路径构建newFile(Stringparent,Stringchild)//根据父目录+子路径构建publicclassfileCreat{publicstaticvoidmain(String[]ar
    
                    
    • 
                    
  • Effective Java学习笔记---------方法
                        年糕coder
EffectiveJava学习笔记java
                        
    检查参数的有效性使用Objects.requireNonNull方法来检查是否是null每当编写方法或者构造器的时候，应该考虑它的参数有哪些限制，应该把这些限制写到文档中，并且在这个方法体的开头处，通过显示的检查来实施这些限制必要时进行保护性拷贝Data已经过时了，不应该在新代码中使用（newData（））对于构造器的每一个可变参数进行保护性拷贝，例如：packagecodeTemplate.ef
    
                    
    • 
                    
  • 大厂高频面试题复习JAVA学习笔记-学习路线
                        addaduvyhup
java开发语言
                        
    对于应届生，要找到一份java工作，你得大概学会：java基础：javase、jvm、juc、gc、mysql、jdbc，计网计组Java微服务基础Maven→Gradle→Spring6→SpringMVC→MyBatis→MyBatisPlus→SSM->Redis7->SpringBoot2->SpringCloudjava微服务生态:Git-Docker-Elasticsearch→Zoo
    
                    
    • 
                    
  • 文件(或文件夹)的复制（Java）
                        人间有清欢
java开发语言
                        
    将源文件(或目录)复制到另一个目录里三种方法：1、最普通的方法，主要用File类中的方法和IO流相关的类进行递归复制。2、主要用Files类中的copy()方法递归复制。3、主要用Files类中的copy()方法和walkFileTree()方法进行复制，不用进行递归。importjava.io.*;importjava.nio.file.FileVisitResult;importjava.ni
    
                    
    • 
                    
  • 问：说说Java中有哪些IO流吧？
                        FIN技术铺
java开发语言
                        
    Java中的IO流（输入/输出流），主要包括以下几种基本类型：字节输入/输出流：输入流：InputStream及其子类输出流：OutputStream及其子类字符输入/输出流：输入流：Reader及其子类输出流：Writer及其子类装饰者流：用于增强功能，如缓冲、处理等。缓冲流：BufferedInputStream,BufferedOutputStream,BufferedReader,Buff
    
                    
    • 
                    
  • Java高级教程秘籍-13章_IO流下
                        AdaCoding
javapython开发语言
                        
    Java高级教程秘籍-13章_IO流下六、其它的流的使用1.标准的输入输出流：2.打印流：3.数据流：七、对象流的使用1.对象流：2.作用：3.对象的序列化机制：4.序列化代码实现：5.反序列化代码实现：6.实现序列化的对象所属的类需要满足：八、RandomAccessFile的使用1.随机存取文件流：RandomAccessFile2.使用说明：3.典型代码九、Path、Paths、Files的
    
                    
    • 
                    
  • java解析xml大文件工具类_xml解析工具类
                        weixin_39963830
java解析xml大文件工具类
                        
    创建一个xml解析工具类，了解其解析原理。全程使用封装思想。需求：创建一个xml解析工具类，通过用户指定的id值或者class文件路径判断其是否存在，如果存在就返回相对应的对象，如果不存在就返回null；需要用到的知识：【变量定义，数据类型转换，控制语句，循环，自定义方法，类的定义，多态，集合框架，IO流，异常体系，反射，xml解析等知识】工具类封装代码：packagecn.yun.xmldom;
    
                    
    • 
                    
  • kotlin use
                        鹅鹅鹅_

                        
    实现了Closeable接口的对象可调用use函数use函数会自动关闭调用者（无论中间是否出现异常）Kotlin的File对象和IO流操作变得行云流水use函数内部实现也是通过try-catch-finally块捕捉的方式，所以不用担心会有异常抛出导致程序退出close操作在finally里面执行，所以无论是正常结束还是出现异常，都能正确关闭调用者javaFileInputStreamfis=nu
    
                    
    • 
                    
  • Java实现服务器与客户端通信
                        AIR cyc
项目实现javasocket多线程
                        
    Java实现服务器与客户端通信基础要点我们的需求是用Java实现服务器与客户端通信，在Java类库中有相应使用简单的类库，了解基本原理不难实现服务器和客户端通信1、编程之前我们要对TCP/IP协议有一定的了解，知道Socket套接字的基本用法。2、关于数据的传输方式，我们要掌握Java中IO流的使用，服务器发出的输出流的所有信息都会成为客户端的输入流，同时所有客户端的所有输出流都会包含在服务器的输
    
                    
    • 
                    
  • File类和 IO流
                        吢禅
javapythonlinux
                        
    File类和IO流1.文件(file类)文件在程序中是以流的形式来操作的创建文件对象相关构造器和方法相关方法newFile(Stringpathname)//根据路径构建一个File对象newFile(Fileparent,Stringchild)//根据父目录文件+子路径构建newFile(Stringparent,Stringchild)//根据父目录+子路径构建createNewFile创建
    
                    
    • 
                    
  • 深入剖析Java核心API——io类，一篇文章总结清楚
                        欺霜
Java核心APIjava开发语言
                        
    在前面几天中我们都在不断的学习Java中一个重要的API——io类，现在我们进行总结读入与写出首先我们来了解一下什么是数据的读入与写出，为什么要有io流来读入写出这些数据。我们先来认识一下在计算机内部中数据都是以二进制来存储与传递的，因此我们不能直接对数据进行操作，需要借助io类中的一些标准的读写操作来完成对不同设备的读写数据工作。java将IO按照方向划分为输入与输出,参照点是我们写的程序.输入
    
                    
    • 
                    
  • java基础之IO流（IO篇）
                        千淘萬漉

                        
    I/O类库中使用“流”这个抽象概念。Java对设备中数据的操作是通过流的方式。表示任何有能力产出数据的数据源对象，或者是有能力接受数据的接收端对象。“流”屏蔽了实际的I/O设备中处理数据的细节。IO流用来处理设备之间的数据传输。设备是指硬盘、内存、键盘录入、网络等。IO的分类可以为：流按操作数据类型的不同分为两种：字节流与字符流。流按流向分为：输入流，输出流（以程序为参照物，输入到程序，或是从程序
    
                    
    • 
                    
  • 第十五章文件与流
                        Dream_wdl

                        
    JAVA程序如何访问文件属性java.io.File类File类访问文件属性image.pngjava中的文件及目录处理类1.不论是文件还是目录都用File类操作File类只能提供操作文件及目录的方法,不能访问文件内容,描述的是文件本身属性3.如果要访问文件本身,用到IO流一:构造方法File文件名=newFile("文字路径字符串");二:一般方法1.文件检测相关方法booleanisDirec
    
                    
    • 
                    
  • 1.使用对象－[Java学习笔记]
                        贤贤别易色

                        
    习题1.单词长度题目内容：你的程序要读入一行文本，其中以空格分隔为若干个单词，以‘.’结束。你要输出这行文本中每个单词的长度。这里的单词与语言无关，可以包括各种符号，比如“it's”算一个单词，长度为4。注意，行中可能出现连续的空格。输入格式:输入在一行中给出一行文本，以‘.’结束，结尾的句号不能计算在最后一个单词的长度内。输出格式：在一行中输出这行文本对应的单词的长度，每个长度之间以空格隔开，行
    
                    
    • 
                    
  • Java——Stream
                        无柳丶先生
java算法开发语言
                        
    IO流输入输出文件内容java8Stream处理数据集合(数组，集合类)对数组，集合类进行各种操作(过滤，排序……)stream处理数据大体过程数组/集合类->流---各种操作(过滤，排序……)->结果(数组/集合类).stream()把集合转为流获取流.filter(a->a.getGender().equals("男"))进行过滤操作中间操作.collect(Collectors.toList
    
                    
    • 
                    
  • java SQL常用语句总结大全（超详细）
                        西瓜尖尖最好吃
Java数据库mysqlsql
                        
    数据库数据库定义：**数据库：**存储数据的仓库.其本质是一个文件系统，数据库按照特定的格式将数据存储到文件中，使用者可以对数据库中的数据进行增加，修改，删除及查询操作。存储位置优点缺点内存例如:集合,实体类对象数据是放在内存中存取速度很快不能永久的保存,程序停止时,内存释放数据消失文件例如:IO流,把数据存在文件中可以永久操作数据每种不同类型的文件都有自己存放数据的格式,数据的管理和维护不方便数
    
                    
    • 
                    
  • Java学习Day17
                        JayMeWangGL

                        
    今日学习内容总结字符流的输入及输出PropertiesIO流字符流字符输入流【Reader】java.io.Reader抽象类是表示用于读取字符流的所有类的超类，可以读取字符信息到内存中。它定义了字符输入流的基本共性功能方法。publicvoidclose()：关闭此流并释放与此流相关联的任何系统资源。publicintread()：从输入流读取一个字符。publicintread(char[]c
    
                    
    • 
                    
  • C++ string流：istringstream、ostringstream、stringstream
                        shine stone
C/C++reviewC++
                        
    C++string流：istringstream/ostringstream/stringstreamstring流定义在头文件#include中，头文件定义三个类型（istringstream,ostringstream,stringstream）来支持内存IO，这些类型可以向string写入数据，从string读取数据，就像string是一个IO流一样。istringstream从string
    
                    
    • 
                    
  • Java学习笔记01
                        .wsy.
日常java学习笔记
                        
    1.1Java简介Java的前身是Oak，詹姆斯·高斯林是java之父。1.2Java体系Java是一种与平台无关的语言，其源代码可以被编译成一种结构中立的中间文件（.class，字节码文件）于Java虚拟机上运行。1.2.3专有名词JDK提供编译、运行Java程序所需要的种种工具及资源。JRE是运行Java所依赖的环境的集合。JVM是一个虚构出来的计算机，通过在实际的计算机上仿真模拟各种计算机功
    
                    
    • 
                    
  • Java学习笔记04：Java_数组
                        JasonYangQ
Javajava
                        
    文章目录1.数组1.1数组介绍1.2数组的定义格式1.2.1第一种格式1.2.2第二种格式1.3数组的动态初始化1.3.1什么是动态初始化1.3.2动态初始化格式1.3.3动态初始化格式详解1.4数组元素访问1.4.1什么是索引1.4.2访问数组元素格式1.4.3示例代码1.5内存分配1.5.1内存概述1.5.2java中的内存分配1.9数组的静态初始化1.9.1什么是静态初始化1.9.2静态初始
    
                    
    • 
                    
  • Java学习笔记：atomic的实现原理？
                        曲钟人散

                        
    在多线程的场景中，我们需要保证数据安全，就会考虑同步的方案，通常会使用synchronized或者lock来处理，使用了synchronized意味着内核态的一次切换。这是一个很重的操作。有没有一种方式，可以比较便利的实现一些简单的数据同步，比如计数器等等。concurrent包下的atomic提供我们这么一种轻量级的数据同步的选择。classMyThreadimplementsRunnable{
    
                    
    • 
                    
  • Java学习笔记之Java基础语法01-变量与常量
                        神马都会亿点点的毛毛张
编程笔记编程实战java学习笔记
                        
    文章目录0.前言1.注释1.1注释格式1.2使用的技巧2.关键字2.1概念2.2class关键字2.3保留字3.字面量3.1字面量种类3.2常用转义字符4.变量4.1变量定义4.2数据类型1.分类2.基本数据类型(四类八种)3.变量初始化细节4.3计算机中的数据存储4.4练习练习1练习2练习34.5标识符1.硬性要求：2.命名原则A.小驼峰命名法B.大驼峰命名法C.阿里巴巴命名规范细节：0.前言本
    
                    
    • 
                    
  • Java学习笔记004——接口概念理解及意义
                        诚外无物0106
java学习笔记
                        
    一个类中有抽象方法，则必须声明为abstract（做为抽象类），抽象类不能实例化。子类继承抽象类，必须对所有的抽象方法重写，否则依然有抽象方法，还是抽象的，无法实例化。故抽象类常做为基类。一个类中所有方法都是抽象方法，那么该类就可以使用接口来实现。在Java语言中，接口（interface）默认是公开的（public）。这意味着，当你定义一个接口时，你不需要显式地将其声明为public，它默认就是
    
                    
    • 
                    
  • 【JavaWeb·1】MySQL数据库使用方法
                        禾苗码上
JavaWeb数据库mysqldatabase
                        
    MySQL数据库引言需求：存储一条数据，牛牛–38–99.01、Java程序中：借助JVM内存变量，对数据进行存储（1）将数据存储在对应变量中：局部变量、成员变量（对象）、数组、集合栈空间：局部变量堆空间：对象（2）缺点：利用JVM存储数据，JVM一旦关闭，则空间被回收，空间里的数据也会丢。这种存储数据的方式，没有达到持久化。2、利用IO流技术，将数据存储在文件中(1)利用IO的输出流，将JVM中
    
                    
    • 
                                
  • Java开发中，spring mvc 的线程怎么调用？
                                    小麦麦子
springmvc
                                    
    今天逛知乎，看到最近很多人都在问spring mvc 的线程http://www.maiziedu.com/course/java/ 的启动问题，觉得挺有意思的，那哥们儿问的也听仔细，下面的回答也很详尽，分享出来，希望遇对遇到类似问题的Java开发程序猿有所帮助。 
 
问题： 
    在用spring mvc架构的网站上，设一线程在虚拟机启动时运行，线程里有一全局
    
                                
    • 
                                
  • maven依赖范围
                                    bitcarter
maven
                                    
    1.test 测试的时候才会依赖，编译和打包不依赖，如junit不被打包 
 
2.compile 只有编译和打包时才会依赖 
 
3.provided 编译和测试的时候依赖，打包不依赖，如：tomcat的一些公用jar包 
 
4.runtime 运行时依赖，编译不依赖 
 
5.默认compile 
 
依赖范围compile是支持传递的，test不支持传递 
 
1.传递的意思是项目A，引用
    
                                
    • 
                                
  • Jaxb org.xml.sax.saxparseexception : premature end of file
                                    darrenzhu
xmlprematureJAXB
                                    
    如果在使用JAXB把xml文件unmarshal成vo(XSD自动生成的vo)时碰到如下错误： 
org.xml.sax.saxparseexception : premature end of file 
很有可能时你直接读取文件为inputstream，然后将inputstream作为构建unmarshal需要的source参数。InputSource inputSource = new In
    
                                
    • 
                                
  • CSS Specificity
                                    周凡杨
html权重Specificitycss
                                    
      
有时候对于页面元素设置了样式，可为什么页面的显示没有匹配上呢？ because specificity   
CSS 的选择符是有权重的，当不同的选择符的样式设置有冲突时，浏览器会采用权重高的选择符设置的样式。   
    规则： 
  
  HTML标签的权重是1

  Class 的权重是10

  Id 的权重是100


    
                                
    • 
                                
  • java与servlet
                                    g21121
servlet
                                    
    servlet 搞java web开发的人一定不会陌生，而且大家还会时常用到它。 
下面是java官方网站上对servlet的介绍：  java官网对于servlet的解释 写道   
Java Servlet Technology Overview Servlets are the Java platform technology of choice for extending and enha
    
                                
    • 
                                
  • eclipse中安装maven插件
                                    510888780
eclipsemaven
                                    
    1.首先去官网下载 Maven： 
http://www.apache.org/dyn/closer.cgi/maven/binaries/apache-maven-3.2.3-bin.tar.gz 
下载完成之后将其解压， 
我将解压后的文件夹：apache-maven-3.2.3， 
并将它放在 D:\tools目录下， 
即 maven 最终的路径是：D:\tools\apache-mave
    
                                
    • 
                                
  • jpa@OneToOne关联关系
                                    布衣凌宇
jpa
                                    
    Nruser里的pruserid关联到Pruser的主键id，实现对一个表的增删改，另一个表的数据随之增删改。 
Nruser实体类 
//***************************************************************** 
@Entity 
@Table(name="nruser") 
@DynamicInsert @Dynam
    
                                
    • 
                                
  • 我的spring学习笔记11-Spring中关于声明式事务的配置
                                    aijuans
spring事务配置
                                    
    这两天学到事务管理这一块，结合到之前的terasoluna框架，觉得书本上讲的还是简单阿。我就把我从书本上学到的再结合实际的项目以及网上看到的一些内容，对声明式事务管理做个整理吧。我看得Spring in Action第二版中只提到了用TransactionProxyFactoryBean和<tx:advice/>,定义注释驱动这三种，我承认后两种的内容很好，很强大。但是实际的项目当中
    
                                
    • 
                                
  • java 动态代理简单实现
                                    antlove
javahandlerproxydynamicservice
                                    
    dynamicproxy.service.HelloService 
package dynamicproxy.service;

public interface HelloService {
	public void sayHello();
}
 
  
dynamicproxy.service.impl.HelloServiceImpl 
package dynamicp
    
                                
    • 
                                
  • JDBC连接数据库
                                    百合不是茶
JDBC编程JAVA操作oracle数据库
                                    
          
    如果我们要想连接oracle公司的数据库，就要首先下载oralce公司的驱动程序，将这个驱动程序的jar包导入到我们工程中; 
  
JDBC链接数据库的代码和固定写法; 
  
  
1,加载oracle数据库的驱动; 
    &nb
    
                                
    • 
                                
  • 单例模式中的多线程分析
                                    bijian1013
javathread多线程java多线程
                                    
    谈到单例模式，我们立马会想到饿汉式和懒汉式加载，所谓饿汉式就是在创建类时就创建好了实例，懒汉式在获取实例时才去创建实例，即延迟加载。 
饿汉式： 
package com.bijian.study;

public class Singleton {

	private Singleton() {
	}

	// 注意这是private 只供内部调用
	private static
    
                                
    • 
                                
  • javascript读取和修改原型特别需要注意原型的读写不具有对等性
                                    bijian1013
JavaScriptprototype
                                    
            对于从原型对象继承而来的成员，其读和写具有内在的不对等性。比如有一个对象A，假设它的原型对象是B，B的原型对象是null。如果我们需要读取A对象的name属性值，那么JS会优先在A中查找，如果找到了name属性那么就返回；如果A中没有name属性，那么就到原型B中查找name，如果找到了就返回；如果原型B中也没有
    
                                
    • 
                                
  • 【持久化框架MyBatis3六】MyBatis3集成第三方DataSource
                                    bit1129
dataSource
                                    
    MyBatis内置了数据源的支持，如： 
  
	<environments default="development">
		<environment id="development">
			<transactionManager type="JDBC" />
			<data
    
                                
    • 
                                
  • 我程序中用到的urldecode和base64decode,MD5
                                    bitcarter
cMD5base64decodeurldecode
                                    
    这里是base64decode和urldecode，Md5在附件中。因为我是在后台所以需要解码： 
 

string Base64Decode(const char* Data,int DataByte,int& OutByte)
{
    //解码表
    const char DecodeTable[] =
    {
        0, 0, 0, 0, 0, 0
    
                                
    • 
                                
  • 腾讯资深运维专家周小军：QQ与微信架构的惊天秘密
                                    ronin47

                                    
    社交领域一直是互联网创业的大热门，从PC到移动端，从OICQ、MSN到QQ。到了移动互联网时代，社交领域应用开始彻底爆发，直奔黄金期。腾讯在过去几年里，社交平台更是火到爆，QQ和微信坐拥几亿的粉丝，QQ空间和朋友圈各种刷屏，写心得，晒照片，秀视频，那么谁来为企鹅保驾护航呢？支撑QQ和微信海量数据背后的架构又有哪些惊天内幕呢？本期大讲堂的内容来自今年2月份ChinaUnix对腾讯社交网络运营服务中心
    
                                
    • 
                                
  • java-69-旋转数组的最小元素。把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个排好序的数组的一个旋转，输出旋转数组的最小元素
                                    bylijinnan
java
                                    
    

public class MinOfShiftedArray {

	/**
	 * Q69 旋转数组的最小元素
	 * 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个排好序的数组的一个旋转，输出旋转数组的最小元素。
	 * 例如数组{3, 4, 5, 1, 2}为{1, 2, 3, 4, 5}的一个旋转，该数组的最小值为1。
	 */
	publ
    
                                
    • 
                                
  • 看博客，应该是有方向的
                                    Cb123456
反省看博客
                                    
    看博客，应该是有方向的: 
 我现在就复习以前的，在补补以前不会的，现在还不会的，同时完善完善项目，也看看别人的博客. 
 我刚突然想到的: 
 1.应该看计算机组成原理，数据结构，一些算法，还有关于android,java的。 
 2.对于我，也快大四了，看一些职业规划的，以及一些学习的经验，看看别人的工作总结的. 
  
 为什么要写
    
                                
    • 
                                
  • [开源与商业]做开源项目的人生活上一定要朴素,尽量减少对官方和商业体系的依赖
                                    comsci
开源项目
                                    
     
 
     为什么这样说呢？  因为科学和技术的发展有时候需要一个平缓和长期的积累过程，但是行政和商业体系本身充满各种不稳定性和不确定性，如果你希望长期从事某个科研项目，但是却又必须依赖于某种行政和商业体系，那其中的过程必定充满各种风险。。。 
 
      所以，为避免这种不确定性风险，我
    
                                
    • 
                                
  • 一个 sql优化 （[精华] 一个查询优化的分析调整全过程！很值得一看 ）
                                    cwqcwqmax9
sql
                                    
    见   http://www.itpub.net/forum.php?mod=viewthread&tid=239011 
 
 
 
 
Web翻页优化实例 
 提交时间: 2004-6-18 15:37:49      回复    发消息  
 
 
环境： 
Linux ve
    
                                
    • 
                                
  • Hibernat and Ibatis
                                    dashuaifu
Hibernateibatis
                                    
    Hibernate  VS  iBATIS 简介 Hibernate 是当前最流行的O/R mapping框架，当前版本是3.05。它出身于sf.net，现在已经成为Jboss的一部分了 iBATIS 是另外一种优秀的O/R mapping框架，当前版本是2.0。目前属于apache的一个子项目了。 相对Hibernate“O/R”而言，iBATIS 是一种“Sql Mappi
    
                                
    • 
                                
  • 备份MYSQL脚本
                                    dcj3sjt126com
mysql
                                    
    #!/bin/sh
# this shell to backup mysql
#[email protected] (QQ:1413161683 DuChengJiu)

_dbDir=/var/lib/mysql/
_today=`date +%w`
_bakDir=/usr/backup/$_today
[ ! -d $_bakDir ] && mkdir -p 
    
                                
    • 
                                
  • iOS第三方开源库的吐槽和备忘
                                    dcj3sjt126com
ios
                                    
    转自 
ibireme的博客       做iOS开发总会接触到一些第三方库，这里整理一下，做一些吐槽。       目前比较活跃的社区仍旧是Github，除此以外也有一些不错的库散落在Google Code、SourceForge等地方。由于Github社区太过主流，这里主要介绍一下Github里面流行的iOS库。       首先整理了一份 
Github上排名靠
    
                                
    • 
                                
  • html wlwmanifest.xml
                                    eoems
htmlxml
                                    
    所谓优化wp_head()就是把从wp_head中移除不需要元素，同时也可以加快速度。 
 
步骤： 
 
加入到function.php 
 
remove_action('wp_head', 'wp_generator'); 
//wp-generator移除wordpress的版本号，本身blog的版本号没什么意义，但是如果让恶意玩家看到，可能会用官网公布的漏洞攻击blog 
 
remov
    
                                
    • 
                                
  • 浅谈Java定时器发展
                                    hacksin
java并发timer定时器
                                    
    java在jdk1.3中推出了定时器类Timer,而后在jdk1.5后由Dou Lea从新开发出了支持多线程的ScheduleThreadPoolExecutor，从后者的表现来看，可以考虑完全替代Timer了。 
Timer与ScheduleThreadPoolExecutor对比： 
1. 
  
 Timer始于jdk1.3,其原理是利用一个TimerTask数组当作队列
    
                                
    • 
                                
  • 移动端页面侧边导航滑入效果
                                    ini
jqueryWebhtml5cssjavascirpt
                                    
    效果体验：http://hovertree.com/texiao/mobile/2.htm可以使用移动设备浏览器查看效果。效果使用到jquery-2.1.4.min.js，该版本的jQuery库是用于支持HTML5的浏览器上，不再兼容IE8以前的浏览器，现在移动端浏览器一般都支持HTML5，所以使用该jQuery没问题。HTML文件代码： 
<!DOCTYPE html>
<h
    
                                
    • 
                                
  • AspectJ+Javasist记录日志
                                    kane_xie
aspectjjavasist
                                    
    在项目中碰到这样一个需求，对一个服务类的每一个方法，在方法开始和结束的时候分别记录一条日志，内容包括方法名，参数名+参数值以及方法执行的时间。 
  
@Override
public String get(String key) {
//	long start = System.currentTimeMillis();
//	System.out.println("Be
    
                                
    • 
                                
  • redis学习笔记
                                    MJC410621
redisNoSQL
                                    
    1)nosql数据库主要由以下特点：非关系型的、分布式的、开源的、水平可扩展的。 
1，处理超大量的数据 
2，运行在便宜的PC服务器集群上， 
3，击碎了性能瓶颈。 
1)对数据高并发读写。 
2)对海量数据的高效率存储和访问。 
3)对数据的高扩展性和高可用性。 
 
redis支持的类型： 
 
Sring 类型 
set name lijie 
get name lijie 
set na
    
                                
    • 
                                
  • 使用redis实现分布式锁
                                    qifeifei

                                    
    在多节点的系统中，如何实现分布式锁机制，其中用redis来实现是很好的方法之一，我们先来看一下jedis包中，有个类名BinaryJedis,它有个方法如下： 
  
public Long setnx(final byte[] key, final byte[] value) {
	checkIsInMulti();
	client.setnx(key, value);
	ret
    
                                
    • 
                                
  • BI并非万能，中层业务管理报表要另辟蹊径
                                    张老师的菜
大数据BI商业智能信息化
                                    
           BI是商业智能的缩写，是可以帮助企业做出明智的业务经营决策的工具，其数据来源于各个业务系统，如ERP、CRM、SCM、进销存、HER、OA等。 
       BI系统不同于传统的管理信息系统，他号称是一个整体应用的解决方案，是融入管理思想的强大系统：有着系统整体的设计思想，支持对所有
    
                                
    • 
                                
  • 安装rvm后出现rvm not a function 或者ruby -v后提示没安装ruby的问题
                                    wudixiaotie
function
                                    
    1.在~/.bashrc最后加入 
[[ -s "$HOME/.rvm/scripts/rvm" ]] && source "$HOME/.rvm/scripts/rvm" 
 2.重新启动terminal输入： 
  
rvm use ruby-2.2.1 --default 
 把当前安装的ruby版本设为默
    
                                
    •