黑马程序员---2015.6.25java基础笔记---装饰模式--字节流拷贝图片--字节流缓冲--字节字符转化--File类

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

1.装饰模式比继承要灵活，避免了继承体系臃肿，而且降低了类与类之间的关系

    装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能。

    所以装饰类和被装饰类通常都属于一个体系中的。

    

/*
装饰设计模式：
当想要对已有对象功能进行加强时，可以定义类将已有对象传入，基于已有功能，并提供加强功能。
那么自定义的该类称为装饰类

装饰类通常会通过构造方法接收被装饰的对象。
并基于被装饰的对象的功能，提供更强的功能。
*/
class Person
{
public void eat()
{
System.out.println("吃饭、。。。");
}
}

class SuperPerson
{
Person p = null;
SuperPerson(Person p )
{
this.p = p;
}

public void superEat()
{
System.out.println("drink wine");
p.eat();
System.out.println("eat tian dian ");
}
}

class PersonDemo
{
public static void main(String[] args)
{
SuperPerson p = new SuperPerson(new Person());
p.superEat();
}
}

    

2.字符流用于处理文本类不能用于处理图片，MP3等格式。

    而字节流可以处理这些格式。

/*
复制一个图片
思路：
1.用字节读取流对象和图片关联
2.用字节写入流对象创建一个图片文件，用于存储获取到的图片数据
3.通过循环读写，完成数据的存储
4.关闭资源
*/
import java.io.*;
class CopyPic
{
public static void main(String[] args)
{
FileInputStream fis = null;
FileOutputStream fos = null;

try
{
fis = new FileInputStream("a.jpg");
fos = new FileOutputStream("a_copy.jpg");
byte[] buff1 = new byte[1024];
int num = 0;
while((num=fis.read(buff1))!=-1)
{
fos.write(buff1,0,num);
}

}
catch(IOException e)
{
throw new RuntimeException("读取出错了。。");
}
finally
{
try
{
if(fis != null)
{
fis.close();
}
if(fos != null)
{
fos.close();
}
}
catch(IOException e)
{
throw new RuntimeException("关闭资源出错了。。");
}
}
}
}

3.

/*
通过字节流缓冲区完成复制
*/
import java.io.*;
class CopyMp3
{
public static void main(String[] args)
{
BufferedInputStream bis = null;
BufferedOutputStream bos = null;

try
{
bis = new BufferedInputStream(new FileInputStream("0.mp3"));
bos = new BufferedOutputStream(new FileOutputStream("0_copy.mp3"));
int ch = 0;
while((ch = bis.read())!=-1)
{
bos.write((char)ch);
}
}
catch(IOException e)
{
throw new RuntimeException("读取出错了");
}
finally
{
try
{
if(bis != null)
{
bis.close();
}
if(bos != null)
{
bos.close();
}
}
catch(IOException e)
{
throw new RuntimeException("关闭资源出错了。。");
}
}
}
}

4.字符流

        FileReader,FileWriter

        BufferedReader,BufferedWriter

    字节流

        FileInputStream,FileOutputStream

        BufferedInputStream,BufferedOutputStream    

        

    键盘录入一行数据，并打印。发现其实就是读一行数据的原理。

    也就是readLine()方法。

    能不能直接使用readLine方法来完成键盘录入的一行数据的读取呢？

    readLine方法是字符流BufferedReader类中的方法。

    而键盘录入的read是InputStream的方法。

    

5.键盘录入。

        StringBuilder缓冲区清零的方法：sb.delete(0,sb.length());    

/*
读取键盘录入。
System.out:对应的是标准输出设备，控制台。
System.in:对应的标准输入设备：键盘。

键盘录入,录入一行就打印，当录入over就结束
*/
import java.io.*;
class ReadIn
{
public static void main(String[] args) throws IOException
{
//获取键盘输入数据
InputStream in = System.in;
int temp = 0;
//定义缓冲区，将每一行键盘录入的数据存入缓冲区中
StringBuilder sb = new StringBuilder();
while(true)
{
temp = in.read();
if(temp == '\r')
continue;
if(temp == '\n')
{
//如果输入一行是over就接收程序
if("over".equals(sb.toString()))
{
System.out.println(sb.toString());
break;
}else
{
//输出一行录入的数据并，将缓冲区清零。
System.out.println(sb.toString());
sb.delete(0,sb.length());
}
}    else
{
sb.append((char)temp);
}
}
}
}

6.字节转化为字符

/*
InputStreamReader 是字节流通向字符流的桥梁
OutputStreamWriter是字符流通向字节流的桥梁
*/
import java.io.*;
class TransStreamDemo
{
public static void main(String[] args) throws IOException
{
//获取键盘录入
InputStream in = System.in;
//字节流转化为字符流
InputStreamReader isr = new InputStreamReader(in);
//使用缓冲区，提高效率
BufferedReader br = new BufferedReader(isr);

//将字符流转坏为字节流输出到屏幕
OutputStream os = System.out;
OutputStreamWriter osw = new OutputStreamWriter(os);
BufferedWriter bufw = new BufferedWriter(osw);

String temp = null;

while((temp=br.readLine())!=null)
{
if("over".equals(temp))
break;
bufw.write(temp.toUpperCase());
bufw.newLine();
bufw.flush();
}

}
}

7.子节流转化为字符流的简写：

        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));

    字符流转化为字节流的简写：

        BufferedWriter bufr = new BufferedWriter(new OutputStreamWriter(System.out));

8. 需求：把键盘录入的数据存储到一个文件中

                BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));

                BufferedWriter bufr = new BufferedWriter(new FileOutputStream("out.txt"));

     需求：把一个文件数据打印在控制台上。        

                BufferedReader bufr = new BufferedReader(new FileInputStream("xxx.txt"));

                BufferedWriter bufr = new BufferedWriter(new OutputStreamWriter(System.out));

    

9.流操作的基本规律

    ---1，明确源和目的

                源：输入流，InputStream  Reader

                目的：输出流，OutputStream Writer

    ---2,操作的数据是否为纯文本

                是，字符流

                否，字节流

    ---3，当体系明确后，再确定具体使用哪个对象

    

    ---4,FileWriter是使用的默认码表GBK

    

10.    转换流什么时候使用？

            字符和字节之间的桥梁，通常涉及到字符编码转换时，需要用到转换流。

                OutputStreamWriter(OutputStream out, String charsetName) //UTf-8,GBK

                

11.异常的日志信息

/*
异常的日志信息
思路：e.printStackTrace(System.out) == e.printStackTrace();
而System.setOut(PrintStream out); 这样就可以将错误信息存入一个指定的文件中。
*/
import java.text.*;
import java.io.*;
import java.util.*;
class ExceptionInfo
{
public static void main(String[] args)
{
PrintStream ps = null;
try
{
int[] a = new int[2];
System.out.println(a[2]);
}catch(Exception e)
{
try
{
//创建错误日志
ps= new PrintStream("log.txt");
//获取当前时间，并进行转化格式
Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd  HH:mm:ss");
String date = sdf.format(d);
//将时间字符串输入日志中
ps.println(date);
//重新设置输出流

b3ce
System.setOut(ps);
e.printStackTrace(System.out);
}
catch(IOException ex)
{
throw new RuntimeException("日志创建失败");
}
finally
{
try
{
if(ps != null)
{
ps.close();
}
}
catch(RuntimeException exx)
{}
}

}
}
}

12.//利用IO流将系统信息打印到指定文件

import java.util.*;
import java.io.*;
class SystemInfo
{
public static void main(String[] args) throws IOException
{
Properties p = System.getProperties();
p.list(new PrintStream("systemInfo.txt"));
}
}

13.    File类普通方法的演示

/*File类的演示
1.创建
boolean createNewFile(); 在指定位置创建文件，如果该文件已存在，则不创建，返回false
File f = new File("a.txt");不会创建出对象，只有执行了createNewFile()才可以
和输出流不一样，输出流对象一创建文件，如果文件存在，会被覆盖

boolean mkdir()创建文件夹
boolean mkdirs()创建多级目录
2.删除
boolean delate();  删除失败返回false。如果文件正在被使用，则删除不了返回falsel
void deleteOnExit() 在程序退出时，删除指定文件
3.判断
isFile() 文件是否存在
isHidden() 是否为隐藏文件
isAbsolute() 是否为绝对路径
isDirectory() 是否是一个目录
4.获取信息
f2.renameTo(f1);
*/

import java.io.*;
class FileDemo
{
public static void main(String[] args)throws IOException
{
//consMethod();
method_5();
}

//创建File对象
public static void consMethod() throws IOException
{
//将a.txt封装成file对象，可以将已有的和未出现的文件或者文件夹封装成对象。
File f1 = new File("d.txt");
File f2 = new File("c:\\abc","b.txt");

File f3 = new File("c:\\abcc");

File f4 = new File(f3,"c.txt");

//separator 与系统有关的默认分割符
File f5 = new File("c:"+File.separator+"d.txt");

sop("f1:"+f1);
sop("f2:"+f2);
sop("f3:"+f3);
sop("f4:"+f4);
sop("f5:"+f5);
}

public static void sop(Object obj)
{
System.out.println(obj);
}

public static void method_1() throws IOException
{
File f = new File("aa\\a.txt");

sop(f.createNewFile());
sop(f.delete());
}

public static void method_2() throws IOException
{
File f = new File("FileDemo.java");
//sop("是否存在？"+f.exists());
//sop("可执行？"+f.canExecute());
File f1 = new File("abcd");
File f2 = new File("abc\\cc\\dd\\ff\\ee\\cc");
sop("是否创建目录"+f1.mkdir());
sop("是否创建多级目录"+f2.mkdirs());
}

public static void method_3() throws IOException
{
File f = new File("hello.java");
f.createNewFile();
sop("文件？"+f.isFile());

File f1 = new File(".java");
sop("文件？"+f.isFile());
sop("绝对路径？"+f1.isAbsolute());
sop("目录？"+f1.isDirectory());
}

public static void method_4() throws IOException
{
File f = new File("c\\e.java");
sop("获取相对路径"+f.getPath());//即获取括号内的内容
sop("获取绝对路径"+f.getAbsolutePath());
//返回的是绝对路径中的父目录，如果获取的是相对路径，则返回null
//如果相对路径中有上层目录，那么该目录就是返回结果
sop("获取此目录的父目录"+f.getParent());
}

public static void method_5() throws IOException
{
File f1 = new File("d:\\Test.txt");
File f2 = new File("c:\\Hello.txt");
/*
相当于剪切，并且可以重命名
将d盘下的Test.txt剪切到c盘下，并且重命名为Hello.txt
*/
sop(f1.renameTo(f2));
}
}

    

14.File类List方法的演示

import java.io.*;
class FileDemo2
{
public static void main(String[] args)throws IOException
{
ListDemo();
}

//File对象必须是封装了一个目录，该目录必须存在
public static void ListDemo()
{
//如果文件d.txt下面没有其他文件，则输出空
File f = new File("f:\\d.txt");
String[] lists = f.list();
for(String s:lists)
{
sop(s);
}
}

//列出所有盘符
public static void listRoots()
{
File[] f1 = File.listRoots();
for(File f:f1)
{
sop(f);
}
}

public static void sop(Object obj)
{
System.out.println(obj);
}
}