“黑马程序员”学习笔记七

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/**
  所有涉及到IO流的代码都会出现异常
  GB2312中国第一种码表，含8000多常用字，后又更新扩容出GBK码表，含20000多常用字
  UTF-8世界通用码表和GBK有重复部分，应用时会有冲突
  字节流：InputStream  OutputStream(FileWriter是OutputStreamWriter的子类)
  字符流：Reader  Writer(FilterStream过滤器)
 FileWriter f=new FileWriter(String FileName);对象一建立就会创建一个指定路径
 的FileName文件如果该文件已经存在，则会覆盖并清空原有文件
 f.write("asdghjkghjkl");会将asdghjkghjkl写到内存中
 f.flush();将内存中的内容刷新到FileName文件中，每写一次就要刷新一次
 f.close();关闭流资源，在关之前会刷新流中内容
 FileWriter f=new FileWriter(String FileName,true);对象一建立，如果有FileName
 文件则在该文件中续写，如果没有则创建该文件在续写（在Windows系统中换行符只能是别\r\n单个不识别）
FileReader fr=new FileReader(String FileName) ;FileName必须存在，否则就异常
 int ch=fr.read();//将文本以二进制数读出来，每次只读一个字符两个字节（两个8位）当读到
                                                          不存在的内容时，返回的是-1
 sop((char)ch);//将二进制数转换成字符
 */
public class IOLiu
{
 public static void main(String[] args)
 {
  FileWriter f=null;
  try
  {
   f=new FileWriter("test.txt");
   f.write("qrtyu");
  }
  catch(IOException e)
  {
   System.out.println(e.toString());
  }
  finally
  {
   try
   {
    if(f!=null)
      f.close();
   }
   catch(IOException e)
   {
    System.out.println(e.toString());
   }
  }
 }
 public void myFileReader1()throws IOException
 {
  FileReader fr1=new FileReader("test.txt");
  int ch=0;
  while((ch=fr1.read())!=-1)
  {
   System.out.println((char)ch);
  }
 }
 public void myFileReader2()throws IOException
 {
  FileReader fr2=new FileReader("test.txt");
  char[] buf=new char[1024];
  int num=0;
  while((num=fr2.read(buf))!=-1)
  {
   System.out.println(new String(buf,0,num));
  }
 }
 
}

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class IOLiuLianXi
{

 public static void main(String[] args)
 {
  FileWriter fw=null;
  FileReader fr=null;
  try
  {
   fw=new FileWriter("D:\\FileName1.txt");
   fr=new FileReader("C:\\新建文件夹\\FileName2.txt");
   int num=0;
   char[] buf=new char[1024];
   while((num=fr.read(buf))!=-1)
   {
    fw.write(buf,0,num);
   }
  }
  catch(IOException e)
  {
   System.out.println("文件复制失败");
  }
  finally
  {
   try
   {
    if(fr!=null)
      fr.close();
   }
   catch(IOException e)
   {
    System.out.println("关读取流失败");
   }
   try
   {
    if(fw!=null)
     fw.close();
   }
   catch(IOException e)
   {
    System.out.println("关写入流失败");
   }
  }
 }

}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/*
  缓冲区对象，BufferedWriter BufferedReader缓冲区的出现是
  为了提高流的操作效率，所以在创建缓冲区之前必须先有流对象
  只要用到缓冲区就必须刷新，关闭缓冲区就相当于关闭了流，所以只用关闭一次
  缓冲区特有方法 ：对象.newLine();换行
             对象.readLine();读一行的有效内容，换行终止符不读
 */
public class IOLiuHuanChong
{ 
 public static void main(String[] args)throws IOException
 {
  FileWriter fw=new FileWriter("D:\\test.txt");
  FileReader fr=new FileReader("D:\\test.txt");
  BufferedReader br=new BufferedReader(fr);
  BufferedWriter bw=new BufferedWriter(fw);
  for(int x=0;x<5;x++)
  {
   bw.write("wertyuioop"+x);
   bw.flush();
   bw.newLine();
  }
  String line=null;
  while((line=br.readLine())!=null)
  {
   System.out.println(line);
  }
  br.close();
  bw.close();
 }
}

 

import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;

/*
 装饰设计模式：将已有的类进行功能增强，将已有类对象作为参数传入装饰类，进而对其进行功能增强
装饰和继承的区别：装饰类可以接收多种类进行相同的功能增强，增加 了代码的复用性和扩展性
                                  继承也能实现功能增强，但是每一个类它都要进行继承.复写，没有装饰类适用性强
 LineNumberReader也是一个FileReader的包装类，他是一个增加行号的包装类
 它有特有方法getLineNumber()获取行号和setLineNumber()创建行号
 */
public class IOZhuangShi
{
 public static void main(String[] args)throws IOException
 {
  FileReader fr=new FileReader("D:\\test.txt");
  LineNumberReader lnr=new LineNumberReader(fr);
  String line=null;
  while((line=lnr.readLine())!=null)
  {
   System.out.println(lnr.getLineNumber()+":"+line);
  }
  lnr.close();
 }

}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 字节流 ：InputStream   OutputStream和字符流相对应
    字节流对象.available();获取流操作文件的长度（包括空格和换行）（换行符两个字节）
    字符流需要刷新，字节流不用
 */
public class IOZiJieLiu
{

 public static void main(String[] args)throws IOException
 {
  damo3();
 }
 public static void damo1()throws IOException
 {
  FileOutputStream fos=new FileOutputStream("D:\\test1.txt");
  FileInputStream fis=new FileInputStream("D:\\test1.txt");
  fos.write("skkjljhgjgfuy".getBytes());//不需要刷新动作，它是一个一个字节往外写
  byte[] b=new byte[1024];
  int line=0;
  while((line=fis.read(b))!=-1)
  {
   System.out.print(new String(b,0,line));
  }
  fos.close();
  fis.close();
 }
 public static void damo2()throws IOException
 {
  FileOutputStream fos=new FileOutputStream("D:\\test1.txt");
  FileInputStream fis=new FileInputStream("D:\\test1.txt");
  fos.write("skkjljhgjgfuy".getBytes());//不需要刷新动作，它是一个一个字节往外写

  int line=0;
  while((line=fis.read())!=0)
  {
   System.out.print((char)line);
  }
  fos.close();
  fis.close();
 }
 public static void damo3()throws IOException
 {
  FileOutputStream fos=new FileOutputStream("D:\\test1.txt");
  FileInputStream fis=new FileInputStream("D:\\test1.txt");
  fos.write("skkjljhgjgfuy".getBytes());//不需要刷新动作，它是一个一个字节往外写
  byte[] ch=new byte[fis.available()];//fis.available()的长度不能超出内存，否则内存崩溃
  System.out.print((char)fis.read(ch));
  fos.close();
  fis.close();
 }
}

 

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
  字节流缓冲区练习BufferedInputStream  BufferedOutputStream
  通过缓冲区复制mp3练习
 
 */

public class ZiJieLiuHuanChongQuLianXi
{

 public static void main(String[] args)
 {
  long startTime=System.currentTimeMillis();
  try
  {
   copy();
  }
  catch(IOException e)
  {
   System.out.println("复制失败");
  }
  long endTime=System.currentTimeMillis();
  System.out.println((endTime-startTime)+"毫秒");
 }
 public static void copy()throws IOException
 {
  BufferedInputStream bis=
    new BufferedInputStream(new FileInputStream(""));
  BufferedOutputStream bos=
    new BufferedOutputStream(new FileOutputStream(""));
  int i=0;
  while((i=bis.read())!=-1)
  {
   bos.write(i);
  }
  bis.close();
  bos.close();
 }

}

import java.io.IOException;
import java.io.InputStream;
/*
 System.in对应的是标准输入设备：键盘录入,可以用System.setIn(new FileInputStream(String FileName))自定义
 System.out对应的是标准输出设备：控制台显示,可以用System.setOut(new printStream(String FileName))自定义
 
 */

public class IOJianPanLuRuKongZhiTaiXianShi
{

 public static void main(String[] args)throws IOException
 {
  InputStream in=System.in;
  StringBuilder sb=new StringBuilder();
  while(true)
  {
   int s=in.read();
   if(s=='\r')
    continue;
   if(s=='\n')
   {
    String str=sb.toString();
    if(str.equals("over"))
     break;
    System.out.println(str.toUpperCase());
    sb.delete(0, sb.length());
   }
   sb.append((char)s);
  
  }
  
 }

}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
  目的：读取一个图片，并把它存入内存中
  步骤：1.建立读取流对象和图片文件相关联
   2.建立写入流对象和内存相关联
   3.将读取流数据循环读入字节数组
   4.将数组中的内容循环写入写入流
 */

public class ZiJieLiuLianXi
{

 public static void main(String[] args)
 {
  FileInputStream fis=null;
  FileOutputStream fos=null;
  int num=0;
  try
  {
   fis=new FileInputStream("");
   fos=new FileOutputStream("");
   
   byte[] b=new byte[1024];
   while((num=fis.read(b))!=-1)
   {
    if (num!=0)
     fos.write(b,0,num);
   }
  }
  catch(IOException e)
  {
   System.out.println("文件复制失败");
  }
  finally
  {
   try
   {
    if(fis!=null)
     fis.close();
   }
   catch(IOException e)
   {
    System.out.println("读取流关闭失败");
   }
   try
   {
    if(fos!=null)
     fos.close();
   }
   catch(IOException e)
   {
    System.out.println("写入流关闭失败");
   }
  }
 }

}

/*
  流测操作对象有很多，选择哪一个很难选所以
  1.必须明确源和目的
  源：InputStream      Reader
  目的：OutputStream    Writer
  2.操作的数据是否是纯文本
  是：字节流
  不是：字符流
  3.当体系明确后，再明确要使用哪个对象
 */

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class ZhuanHuanLiu
{

 public static void main(String[] args)throws IOException
 {
  //InputStream is=System.in;
  //InputStreamReader isr=new InputStreamReader(is);
  //BufferedReader br=new BufferedReader(isr);
  BufferedReader br=
    new BufferedReader(new InputStreamReader(System.in));
  //OutputStream os=System.out;
  //OutputStreamWriter osw=new OutputStreamWriter(os);
  //BufferedWriter bw=new BufferedWriter(osw);
  BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
  String line=null;
  while((line=br.readLine())!=null)
  {
   if(line.equals("over"))
    break;
   bw.write(line);
   bw.newLine();
   bw.flush();
  }
  bw.close();
 }

}

import java.io.IOException;
import java.io.PrintStream;
import java.text.SimpleDateFormat;
import java.util.Date;

/*
       创建异常信息日志(现在有已经封装好的异常日志对象log4j,可以在网上下载下来后直接用)
       获取系统属性信息：
       public static void main(String[] args)throws IOException
       {
         Properties p=System.getProperties();
         p.list(new PrintStream("FileName"));
         //System.out.println(p);没有换行
       }
 */
public class ChuangJianYiChangXinXiWenBen
{
 public static void main(String[] args) throws IOException
 {
  try
  {
   int[] arr=new int[2];
   System.out.println(arr[3]);
  }
  catch(Exception e)
  {
   try
   {
    Date d=new Date();
    SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    String s=sdf.format(d);
    PrintStream ps=new PrintStream("C:\\Users\\ming\\Desktop\\新建文件夹\\19\\日志.txt");
    //ps.write(d.toString().getBytes());相当于下面一行
    ps.println(s);
    System.setOut(ps);
    //e.printStackTrace(这里默认的是System.out);将异常信息打印在控制台上
   }
   catch(IOException ex)
   {
    //System.out.println("日志文件创建失败");当日志不能建立时，最好是将程序停掉
    throw new RuntimeException("日志创建失败");
   }
   e.printStackTrace(System.out);
  }
 }

}