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

于 2015-06-25 22:42:53 发布
阅读量591 收藏
点赞数
分类专栏： java基础笔记 文章标签： 装饰模式 字节流拷贝图片 字节流缓冲 字
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010870544/article/details/46642353
版权

------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);
                //重新设置输出流
                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);
    }
}


月满西楼_qd
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值