GGRoddick

JavaSE-IO流

package com.btp.t4;

import java.io.File;
import java.io.IOException;
import java.util.Date;

import org.junit.Test;

/*
 * java.io.File
 * 1.凡是与输入，输出相关的类，接口等都定义在java.io包下
 * 2.File是一个类，可以有构造器创建其对象。此对象对应着一个文件（.txt .avi .doc .ppt .mp3 .jpg）或文件目录
 * 3.File类对象是与平台无关的
 * 4.File中的方法，仅涉及到如何创建，删除，重命名等等.只要涉及文件内容，File是无能为力的，必须由io流来完成
 * 5.File类的对象常作为io流的具体类的构造器的形参
 * 
 *    getName()
 *    getPath()
 *    getAbsoluteFile()
 *    getAbsolutePath()
 *    getParent()
 *    renameTo(File newName)
 *    
 *    exists()
 *    canWrite()
 *    canRead()
 *    isFile()
 *    isDirectory()
 *    lastModified()
 *    length()
 *    
 *    createNewFile()
 *    delete()
 *    mkDir():上层目录存在的情况下，创建一个文件目录
 *    mkDirs()：上层目录不存在，连上层目录一起创建
 *    list():打印出所在路径所有的文件名，以String[]的形式返回
 *    listFiles():以File[]的形式返回路径下所有的文件
 */
public class TestFile {
    /*
     * 路径：
     * 绝对路径：包括盘符在内的完整的文件路径
     * 相对路径：在当前文件目录下的文件的路径
     */
    @Test
    public void test3() throws IOException
    {
        File f1=new File("C:\\Users\\kobefan1\\Desktop\\io\\helloworld.txt");
        f1.delete();
        if(!f1.exists()){
            System.out.println(f1.createNewFile());
        }
        File f2=new File("C:\\Users\\kobefan1\\Desktop\\io\\io2");
        if(!f2.exists()){
            System.out.println(f2.mkdir());
        }
        System.out.println();
        
        File f3=new File("C:\\Users\\kobefan1\\Desktop");
        String[] str=f3.list();
        for(Object obj:str){
            System.out.println(obj);
        }
        System.out.println();
        
        File[] str1=f3.listFiles();
        for(File obj:str1){
            System.out.println(obj.getName());
        }
    }
    
    @Test
    public void test2()
    {
        File f1=new File("C:\\Users\\kobefan1\\Desktop\\io\\helloworld.txt");
        File f2=new File("C:\\Users\\kobefan1\\Desktop\\io\\io1");
        System.out.println(f1.exists());
        System.out.println(f1.canWrite());
        System.out.println(f1.canRead());
        System.out.println(f1.isFile());
        System.out.println(f1.isDirectory());
        System.out.println(new Date(f1.lastModified()));
        System.out.println(f1.length());
        
        System.out.println();
        
        System.out.println(f2.exists());
        System.out.println(f2.canWrite());
        System.out.println(f2.canRead());
        System.out.println(f2.isFile());
        System.out.println(f2.isDirectory());
        System.out.println(f2.lastModified());
        System.out.println(f2.length());
    }
    
    @Test
    public void test1()
    {
        File f1=new File("C:\\Users\\kobefan1\\Desktop\\io\\helloworld.txt");
        File f2=new File("hello1.txt");
        
        File f3=new File("C:\\Users\\kobefan1\\Desktop\\io\\io1");
        System.out.println(f1.getName());
        System.out.println(f1.getPath());
        System.out.println(f1.getAbsoluteFile());
        System.out.println(f1.getParent());
        System.out.println(f1.getAbsolutePath());
        
        System.out.println();
        
        System.out.println(f3.getName());
        System.out.println(f3.getPath());
        System.out.println(f3.getAbsoluteFile());
        System.out.println(f3.getParent());
        System.out.println(f3.getAbsolutePath());
        
        // renameTo(File newName):重命名
        //file1.renameTo(file2):file1重命名为file2.要求：file1一定存在，file2一定不存在
        System.out.println(f1.renameTo(f2));
    }
}

File

package com.btp.t4;

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

import org.junit.Test;

/*
 * 1.流的分类
 * 按照数据流向的不同：输入流,输出流
 * 按照处理数据的单位的不同：字节流,字符流（处理文本文件）
 * 按照角色的不同：节点流（直接作用于文件的）,处理流
 * 2. IO的体系
 * 抽象基类                                                                     节点流（文件流）                                        缓冲流（处理流的一种，效率更高）
 * InputStream(处理字节流)            FileInputStream                   BufferedInputStream         
 * OutputStream(处理字节流)          FileOutputStream              BufferedOutputStream
 * Reader(处理字符流)                FileReader（处理文本文件）               BufferedReader
 * Writer(处理字符流)                FileWriter（处理文本文件）               BufferedWriter
 */
public class TestFileInputOutputStream {
    public static void main(String[] args){
        TestFileInputOutputStream.copyFile("C:\\Users\\kobefan1\\Desktop\\adoub.jpg", "C:\\Users\\kobefan1\\Desktop\\adoub1.jpg");
    }
    
    
    //实现文件复制的方法
    public static void copyFile(String str1,String str2)
    {
        //从硬盘中读取一个文件，并写入到另一个位置。（相当于文件的复制）
                //1.提供读入，写出的文件
                File file1=new File(str1);
                File file2=new File(str2);
                //2.提供相应的流的对象
                FileInputStream fis=null;
                FileOutputStream fos=null;
                
                try {
                    fis=new FileInputStream(file1);
                    fos=new FileOutputStream(file2);
                    //实现文件的复制
                    byte[] b=new byte[20];
                    int len;
                    while((len=fis.read(b))!=-1){
                        //fos.write(b);//错误的写法，和fos.write(b,0,b.length);一样的效果
                        fos.write(b, 0, len);
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
                //关闭相应的流
                finally{
                    try {
                        fis.close();
                    } catch (IOException e) {
                        // TODO 自动生成的 catch 块
                        e.printStackTrace();
                    }
                    try {
                        fos.close();
                    } catch (IOException e) {
                        // TODO 自动生成的 catch 块
                        e.printStackTrace();
                    }
                }
    }
    
    
    @Test
    public void testFileInputOutputStream(){
        //从硬盘中读取一个文件，并写入到另一个位置。（相当于文件的复制）
        //1.提供读入，写出的文件
        File file1=new File("C:\\Users\\kobefan1\\Desktop\\adoub.jpg");
        File file2=new File("adoub.txt");
        //2.提供相应的流的对象
        FileInputStream fis=null;
        FileOutputStream fos=null;
        
        try {
            fis=new FileInputStream(file1);
            fos=new FileOutputStream(file2);
            //实现文件的复制
            byte[] b=new byte[20];
            int len;
            while((len=fis.read(b))!=-1){
                //fos.write(b);//错误的写法，和fos.write(b,0,b.length);一样的效果
                fos.write(b, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        //关闭相应的流
        finally{
            try {
                fis.close();
            } catch (IOException e) {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
            }
            try {
                fos.close();
            } catch (IOException e) {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
            }
        }
    }
    
    
    //FileOutputStream
    @Test
    public void testFileOutputStream1(){
        //1.创建一个File对象，表明要写入的文件位置，文件可以不存在，自动帮你创建 。若存在，会将原有的文件覆盖。
        File file = new File("hello1.txt");
        //2.创建一个FileOutputStream对象，将File对象作为形参传递给FileOutputStream的构造器中
        FileOutputStream fos=null;
        
        try {
            fos=new FileOutputStream(file);
            //3.写入操作
            fos.write(new String("I love China,I love world").getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally{
            //4.关闭输出流
            try {
                fos.close();
            } catch (IOException e) {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
            }
        }
    }
    
    
    
    
    //从硬盘存在的一个文件中读取其内容到程序中，使用FileInputStream
    //要读取的文件一定要存在。否则抛FileNotFoundException
    
    @Test
    public void testFileInputStream3() throws IOException{
        File file=new File("hello.txt");
        FileInputStream fis=new FileInputStream(file);
        byte[] b=new byte[20];//读取到的数据要写入的数组
        int len;//每次要读写入byte的字节的长度
        while((len=fis.read(b))!=-1){//每次从文件中读取b.length个字节，如果少于b.length，则有多少读多少，读完返回每次读取的个数
            
            for(int i=0;i<len;i++){//b.length是20，所以要写成len
                System.out.println((char)b[i]);//把数组b中的打印出来，len是真实读入的字节个数
            }
        }
        fis.close();
    }
    
    
    
    //使用try-catch的方式处理如下异常更合适：保证流的关闭操作一定可以执行
    @Test
    public void testFileInputStream2(){
                FileInputStream fis=null;//声明在外面，使finally语句内也可以调用
                try {
                    //1.创建一个File类的对象
                    File file=new File("hello.txt");
                    //2.创建一个FileInputStream类的对象
                    fis=new FileInputStream(file);
                    //3.调用FileInputStream的方法，实现文件的读取
                    /*
                     * read():返回文件的一个字节，并指向下一个字节。当返回-1，文件读取结束
                     */
                    int b=fis.read();
                    while(b!=-1){
                        System.out.println((char)b);
                        b=fis.read();
                    }
                } catch (FileNotFoundException e) {
                    // TODO 自动生成的 catch 块
                    e.printStackTrace();
                } catch (IOException e) {
                    // TODO 自动生成的 catch 块
                    e.printStackTrace();
                }
                finally{
                    //4.关闭相应的流
                    try {
                        fis.close();
                    } catch (IOException e) {
                        // TODO 自动生成的 catch 块
                        e.printStackTrace();
                    }
                }
    }
    
    //抛出异常的方式
    @Test
    public void testFileInputStream1() throws IOException{
        //1.创建一个File类的对象
        File file=new File("hello.txt");
        //2.创建一个FileInputStream类的对象
        FileInputStream fis=new FileInputStream(file);
        //3.调用FileInputStream的方法，实现文件的读取
        /*
         * read():返回文件的一个字节，并指向下一个字节。当返回-1，文件读取结束
         */
        int b=fis.read();
        while(b!=-1){
            System.out.println((char)b);
            b=fis.read();
        }
        //4.关闭相应的流
        fis.close();
    }
}

FileInputOutputStream

package com.btp.t4;

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

import org.junit.Test;
/*
 * 使用FileReader，FileWriter可以实现文本文件的复制
 * 对于非文本文件（视频文件，音频文件，图片等），只能使用字节流
 */
public class TestFileReaderFileWriter {
    public static void main(String []args){
        //不能实现非文本文件的复制
        TestFileReaderFileWriter.copyTxt("hello1.txt", "hello2.txt");
    }
    
    
    //文本文件的读入
    @Test
    public void testFileReader(){
        File file1=new File("hello1.txt");
        
        FileReader frd=null;
        try {
            frd = new FileReader(file1);
        } catch (FileNotFoundException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }
        char[] c=new char[20];
        int len;
        try {
            while((len=frd.read(c))!=-1){
                String str=new String(c,0,len);
                System.out.print(str);
            }
        } catch (IOException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }
        try {
            frd.close();
        } catch (IOException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }
    }
    //文本文件的复制
    public static void copyTxt(String str1,String str2){
        File file1=new File(str1);
        File file2=new File(str2);
        
        FileReader frd=null;
        try {
            frd = new FileReader(str1);
        } catch (FileNotFoundException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }
        FileWriter fwt=null;
        try {
            fwt = new FileWriter(str2);
        } catch (IOException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }
        
        char[] c=new char[20];
        int len;
        try {
            while((len=frd.read(c))!=-1){
                try {
                    fwt.write(c,0,len);
                } catch (IOException e) {
                    // TODO 自动生成的 catch 块
                    e.printStackTrace();
                }
            }
        } catch (IOException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }
        try {
            frd.close();
        } catch (IOException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }
        try {
            fwt.close();
        } catch (IOException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }
    }
    
}

FileReaderWriter

  1 package com.btp.t4;
  2 
  3 import java.io.BufferedInputStream;
  4 import java.io.BufferedOutputStream;
  5 import java.io.BufferedReader;
  6 import java.io.BufferedWriter;
  7 import java.io.File;
  8 import java.io.FileInputStream;
  9 import java.io.FileNotFoundException;
 10 import java.io.FileOutputStream;
 11 import java.io.FileReader;
 12 import java.io.FileWriter;
 13 import java.io.IOException;
 14 
 15 import org.junit.Test;
 16 
 17 /*
 18  *IO的体系
 19  *抽象基类                                                               节点流(文件流)                缓冲流(处理流的一种，可以提升文件操作的效率）
 20  * InputStream(处理字节流)         FileInputStream              BufferedInputStream         
 21  * OutputStream(处理字节流)       FileOutputStream             BufferedOutputStream  (flush())
 22  * Reader(处理字符流)             FileReader(处理文本文件)      BufferedReader  (readLine())
 23  * Writer(处理字符流)             FileWriter(处理文本文件)      BufferedWriter  (flush())
 24  */
 25 public class TestBuffered {
 26     //使用BufferedInputStream和BufferedOutputStream实现非文本文件的复制
 27     @Test
 28     public void testBufferedInputOutputStream(){
 29         //1.提供读入，写出的文件
 30         File file1=new File("C:\\Users\\kobefan1\\Desktop\\adoub.jpg");
 31         File file2=new File("C:\\Users\\kobefan1\\Desktop\\adoub1.jpg");
 32         //2.创建相应的节点流：FileInputStream和FileOutputStream
 33         FileInputStream fis = null;
 34         try {
 35             fis = new FileInputStream(file1);
 36         } catch (FileNotFoundException e) {
 37             // TODO 自动生成的 catch 块
 38             e.printStackTrace();
 39         }
 40         FileOutputStream fos = null;
 41         try {
 42             fos = new FileOutputStream(file2);
 43         } catch (FileNotFoundException e) {
 44             // TODO 自动生成的 catch 块
 45             e.printStackTrace();
 46         }
 47         //3.将创建的节点流的对象作为形参传递给缓冲流的构造器中
 48         BufferedInputStream bis=new BufferedInputStream(fis);
 49         BufferedOutputStream bos=new BufferedOutputStream(fos);
 50         //4.具体的实现文件复制的操作
 51         byte[] b=new byte[20];
 52         int len;
 53         try {
 54             while((len=bis.read(b))!=-1){
 55                 bos.write(b,0,len);
 56                 bos.flush();//刷新一下
 57             }
 58         } catch (IOException e) {
 59             // TODO 自动生成的 catch 块
 60             e.printStackTrace();
 61         }
 62         //5.关闭相应的流
 63         try {
 64             bis.close();
 65         } catch (IOException e) {
 66             // TODO 自动生成的 catch 块
 67             e.printStackTrace();
 68         }
 69         try {
 70             bos.close();
 71         } catch (IOException e) {
 72             // TODO 自动生成的 catch 块
 73             e.printStackTrace();
 74         }
 75         
 76         
 77     }
 78     
 79     //使用BufferedReader和BufferedWriter实现文本文件的复制
 80     @Test
 81     public void testBufferedReaderWriter(){
 82         //1.提供读入，写出的文件
 83         File file1=new File("C:\\Users\\kobefan1\\Desktop\\hehe.txt");
 84         File file2=new File("C:\\Users\\kobefan1\\Desktop\\hehe1.txt");
 85         //2.创建相应的节点流：FileReader和FileWriter
 86         FileReader fis = null;
 87         try {
 88             fis = new FileReader(file1);
 89         } catch (FileNotFoundException e) {
 90             // TODO 自动生成的 catch 块
 91             e.printStackTrace();
 92         }
 93         FileWriter fos = null;
 94         try {
 95             fos = new FileWriter(file2);
 96         } catch (IOException e) {
 97             // TODO 自动生成的 catch 块
 98             e.printStackTrace();
 99         }
100         //3.将创建的节点流的对象作为形参传递给缓冲流的构造器中
101         BufferedReader bis=new BufferedReader(fis);
102         BufferedWriter bos=new BufferedWriter(fos);
103         //4.具体的实现文件复制的操作
104         String str;
105         try {
106             while((str=bis.readLine())!=null){//每次读一行
107                 bos.write(str);
108                 bos.flush();
109             }
110         } catch (IOException e) {
111             // TODO 自动生成的 catch 块
112             e.printStackTrace();
113         }
114         //5.关闭相应的流
115         try {
116             bis.close();
117         } catch (IOException e) {
118             // TODO 自动生成的 catch 块
119             e.printStackTrace();
120         }
121         try {
122             bos.close();
123         } catch (IOException e) {
124             // TODO 自动生成的 catch 块
125             e.printStackTrace();
126         }
127         
128         
129     }
130 }

Buffered

  1 package com.btp.t4;
  2 
  3 import java.io.BufferedInputStream;
  4 import java.io.BufferedOutputStream;
  5 import java.io.BufferedReader;
  6 import java.io.BufferedWriter;
  7 import java.io.File;
  8 import java.io.FileInputStream;
  9 import java.io.FileNotFoundException;
 10 import java.io.FileOutputStream;
 11 import java.io.FileReader;
 12 import java.io.FileWriter;
 13 import java.io.IOException;
 14 import java.io.Reader;
 15 
 16 import org.junit.Test;
 17 
 18 public class TestStreamandER {
 19   private String str="A BufferedInputStream adds functionality to another input stream-namely,\n"
 20            + " the ability to buffer the input and to support the mark and reset methods.\n"
 21            + " When the BufferedInputStream is created, an internal buffer array is created.\n"
 22            + " As bytes from the stream are read or skipped, the internal buffer is refilled as\n"
 23            + " necessary from the contained input stream, many bytes at a time. The mark operation \n"
 24            + "remembers a point in the input stream and the reset operation causes all the bytes read \n"
 25            + "since the most recent mark operation to be reread before new bytes are taken from the\n"
 26            + " contained input stream.";
 27    
 28    //使用字符流写出
 29    @Test
 30    public void testWriter()
 31    {
 32        BufferedWriter bfw = null;
 33     try {
 34         bfw = new BufferedWriter(new FileWriter(new File("java-Buffered.txt")));
 35     } catch (IOException e) {
 36         // TODO 自动生成的 catch 块
 37         e.printStackTrace();
 38     }
 39       
 40        try {
 41         bfw.write(str);
 42     } catch (IOException e) {
 43         // TODO 自动生成的 catch 块
 44         e.printStackTrace();
 45     }
 46        try {
 47         bfw.close();
 48     } catch (IOException e) {
 49         // TODO 自动生成的 catch 块
 50         e.printStackTrace();
 51     }
 52    }
 53    
 54  //使用字节流写出
 55    @Test
 56    public void testOutputStream()
 57    {
 58        BufferedOutputStream bfs = null;
 59     try {
 60         bfs = new BufferedOutputStream(new FileOutputStream(new File("Java-buffered-stream.txt")));
 61     } catch (FileNotFoundException e) {
 62         // TODO 自动生成的 catch 块
 63         e.printStackTrace();
 64     }
 65        try {
 66         bfs.write(str.getBytes());
 67     } catch (IOException e) {
 68         // TODO 自动生成的 catch 块
 69         e.printStackTrace();
 70     }
 71        try {
 72         bfs.close();
 73     } catch (IOException e) {
 74         // TODO 自动生成的 catch 块
 75         e.printStackTrace();
 76     }
 77    }
 78    
 79    //使用字节流读入
 80    @Test
 81    public void testInputStream(){
 82        BufferedInputStream bis = null;
 83     try {
 84         bis = new BufferedInputStream(new FileInputStream(new File("java-Buffered.txt")));
 85     } catch (FileNotFoundException e) {
 86         // TODO 自动生成的 catch 块
 87         e.printStackTrace();
 88     }
 89        byte[] b=new byte[1024];
 90        int len;
 91        try {
 92         while((len=bis.read(b))!=-1)
 93            {
 94                String str=new String(b,0,len);
 95                System.out.println(str);
 96            }
 97     } catch (IOException e) {
 98         // TODO 自动生成的 catch 块
 99         e.printStackTrace();
100     }
101        try {
102         bis.close();
103     } catch (IOException e) {
104         // TODO 自动生成的 catch 块
105         e.printStackTrace();
106     }
107        
108    }
109    
110  //使用字符流读入
111    @Test
112    public void testReader(){
113        BufferedReader br = null;
114     try {
115         br = new BufferedReader(new FileReader(new File("java-Buffered.txt")));
116     } catch (FileNotFoundException e) {
117         // TODO 自动生成的 catch 块
118         e.printStackTrace();
119     }
120        char[] b=new char[1024];
121        int len;
122        try {
123         while((len=br.read(b))!=-1)
124            {
125                String str=new String(b,0,len);
126                System.out.println(str);
127            }
128     } catch (IOException e) {
129         // TODO 自动生成的 catch 块
130         e.printStackTrace();
131     }
132        try {
133         br.close();
134     } catch (IOException e) {
135         // TODO 自动生成的 catch 块
136         e.printStackTrace();
137     }
138        
139    }
140    
141    //字节流实现复制
142    @Test
143    public void copyByte(){
144        BufferedInputStream bis = null;
145     try {
146         bis = new BufferedInputStream(new FileInputStream(new File("java-Buffered.txt")));
147     } catch (FileNotFoundException e) {
148         // TODO 自动生成的 catch 块
149         e.printStackTrace();
150     }
151        BufferedOutputStream bos = null;
152     try {
153         bos = new BufferedOutputStream(new FileOutputStream(new File("java-Buffered-copy.txt")));
154     } catch (FileNotFoundException e) {
155         // TODO 自动生成的 catch 块
156         e.printStackTrace();
157     }
158        byte[] b=new byte[1024];
159        int len;
160        try {
161         while((len=bis.read(b))!=-1){
162                bos.write(b,0,len);
163            }
164     } catch (IOException e) {
165         // TODO 自动生成的 catch 块
166         e.printStackTrace();
167     }
168        try {
169         bis.close();
170     } catch (IOException e) {
171         // TODO 自动生成的 catch 块
172         e.printStackTrace();
173     }
174        try {
175         bos.close();
176     } catch (IOException e) {
177         // TODO 自动生成的 catch 块
178         e.printStackTrace();
179     }
180    }
181    
182    
183    
184  //字符流实现复制
185    @Test
186    public void copyChar(){
187        BufferedReader bis = null;
188     try {
189         bis = new BufferedReader(new FileReader(new File("java-Buffered.txt")));
190     } catch (FileNotFoundException e) {
191         // TODO 自动生成的 catch 块
192         e.printStackTrace();
193     }
194        BufferedWriter bos = null;
195     try {
196         bos = new BufferedWriter(new FileWriter(new File("java-Buffered-copy2.txt")));
197     } catch (IOException e) {
198         // TODO 自动生成的 catch 块
199         e.printStackTrace();
200     }
201        char[] b=new char[1024];
202        int len;
203        try {
204         while((len=bis.read(b))!=-1){
205                bos.write(b,0,len);
206            }
207     } catch (IOException e) {
208         // TODO 自动生成的 catch 块
209         e.printStackTrace();
210     }
211        try {
212         bis.close();
213     } catch (IOException e) {
214         // TODO 自动生成的 catch 块
215         e.printStackTrace();
216     }
217        try {
218         bos.close();
219     } catch (IOException e) {
220         // TODO 自动生成的 catch 块
221         e.printStackTrace();
222     }
223    }
224 }

Practice

  1 package com.btp.t4;
  2 
  3 import java.io.File;
  4 import java.io.FileInputStream;
  5 import java.io.FileOutputStream;
  6 import java.io.IOException;
  7 import java.io.ObjectInputStream;
  8 import java.io.ObjectOutputStream;
  9 import java.io.Serializable;
 10 
 11 import org.junit.Test;
 12 
 13 public class TestObjectInputOutputStream {
 14     //对象的序列化过程：将内存中的对象通过ObjectOutputStream转换为二进制流，存储在硬盘文件中
 15     @Test
 16     public void testObjectOutputStream(){
 17         Persons p1=new Persons("超人",10000,new Pet("花花"));
 18         Persons p2=new Persons("蜘蛛侠",20,new Pet("章鱼"));
 19         ObjectOutputStream oos = null;
 20         try {
 21             oos = new ObjectOutputStream(new FileOutputStream(new File("chaoren.txt")));
 22             oos.writeObject(p1);
 23             oos.flush();
 24             oos.writeObject(p2);
 25             oos.flush();
 26         } catch (IOException e) {
 27             // TODO 自动生成的 catch 块
 28             e.printStackTrace();
 29         }finally{
 30         try {
 31             oos.close();
 32         } catch (IOException e) {
 33             // TODO 自动生成的 catch 块
 34             e.printStackTrace();
 35         }
 36         }
 37     }
 38     
 39     //对象的反序列化过程：将硬盘中的文件通过ObjectInputStream转换为相应的对象
 40     @Test
 41     public void testObjectInputStream(){
 42         ObjectInputStream ois = null;
 43         try {
 44             ois = new ObjectInputStream(new FileInputStream(new File("chaoren.txt")));
 45             Persons p1=(Persons) ois.readObject();
 46             Persons p2=(Persons) ois.readObject();
 47             System.out.println(p1);
 48             System.out.println(p2);
 49         } catch (ClassNotFoundException | IOException e) {
 50             // TODO 自动生成的 catch 块
 51             e.printStackTrace();
 52         }
 53         finally{
 54         try {
 55             ois.close();
 56         } catch (IOException e) {
 57             // TODO 自动生成的 catch 块
 58             e.printStackTrace();
 59         }
 60         }
 61     }
 62 }
 63 
 64 
 65 //
 66 /*
 67  * 要实现序列化的类：
 68  * 1.要求此类是可序列化的，必须实现Serializable接口
 69  * 2.要求类的属性同样要实现Serializable接口
 70  * 3.提供一个版本号，private static final long serialVersionUID
 71  * 4.不能序列化static和transient修饰的成员属性
 72  */
 73 class Persons implements Serializable{
 74     private static final long serialVersionUID=546541684;//用来表明类的不同版本间的兼容性
 75     String name;//static String name;
 76     Integer age;//transient Integer age;
 77     Pet pet;
 78     public Persons(String name,Integer age,Pet pet){
 79         this.name=name;
 80         this.age=age;
 81         this.pet=pet;
 82     }
 83     public Persons() {
 84         super();
 85     }
 86     @Override
 87     public String toString() {
 88         return "Persons [name=" + name + ", age=" + age + ", pet=" + pet + "]";
 89     }
 90     
 91 }
 92 
 93 class Pet implements Serializable{
 94     String name;
 95 
 96     public Pet(String name) {
 97         super();
 98         this.name = name;
 99     }
100 
101     public Pet() {
102         super();
103         // TODO 自动生成的构造函数存根
104     }
105 
106     @Override
107     public String toString() {
108         return "Pet [name=" + name + "]";
109     }
110     
111 }

ObjectInputOutputStream

  1 package com.btp.t4;
  2 
  3 import java.io.File;
  4 import java.io.IOException;
  5 import java.io.RandomAccessFile;
  6 
  7 import org.junit.Test;
  8 
  9 /*
 10  * RandomAccessFile:支持随机访问
 11  * 1.即可以充当一个输入流，又可以充当一个输出流
 12  * 2.支持从文件的开头读取，写入
 13  * 3.支持从任意位置的读取，写入（插入）
 14  */
 15 public class TestRandomAccessFile {
 16     //进行文件的读，写
 17     @Test
 18     public void test1(){
 19         RandomAccessFile raf1 = null;
 20         RandomAccessFile raf2 = null;
 21         try {
 22             raf1 = new RandomAccessFile(new File("hello1.txt"), "r");
 23             raf2 = new RandomAccessFile(new File("RandomAccess.txt"), "rw");
 24             
 25             byte[] b=new byte[1024];
 26             int len;
 27             while((len=raf1.read(b))!=-1){
 28                 raf2.write(b, 0, len);
 29             }
 30         } catch (IOException e) {
 31             // TODO 自动生成的 catch 块
 32             e.printStackTrace();
 33         }
 34         
 35         try {
 36             raf1.close();
 37         } catch (IOException e) {
 38             // TODO 自动生成的 catch 块
 39             e.printStackTrace();
 40         }
 41         try {
 42             raf2.close();
 43         } catch (IOException e) {
 44             // TODO 自动生成的 catch 块
 45             e.printStackTrace();
 46         }
 47     }
 48     //实现的实际上是覆盖的效果
 49     @Test
 50     public void test2(){
 51         RandomAccessFile raf2 = null;
 52         try {
 53             raf2 = new RandomAccessFile(new File("RandomAccess.txt"), "rw");
 54             raf2.seek(0);//在0的位置写入
 55             raf2.write(new String("Man in black!").getBytes());
 56         } catch (IOException e) {
 57             // TODO 自动生成的 catch 块
 58             e.printStackTrace();
 59         }
 60         try {
 61             raf2.close();
 62         } catch (IOException e) {
 63             // TODO 自动生成的 catch 块
 64             e.printStackTrace();
 65         }
 66     }
 67     
 68     //实现插入的效果（文件只有一行）
 69     @Test
 70     public void test3(){
 71         RandomAccessFile raf2 = null;
 72         try {
 73             raf2 = new RandomAccessFile(new File("RandomAccess.txt"), "rw");
 74             raf2.seek(0);//在0的位置写入
 75             String str=raf2.readLine();//把插入位置的后面的内容读出来
 76             
 77             System.out.println(raf2.getFilePointer());
 78             raf2.seek(0);//指针再调回要插入的位置
 79             raf2.write(new String("hehe!!").getBytes());//插入
 80             raf2.write(str.getBytes());//在插入 内容后还原原来后面的内容
 81         } catch (IOException e) {
 82             // TODO 自动生成的 catch 块
 83             e.printStackTrace();
 84         }
 85         try {
 86             raf2.close();
 87         } catch (IOException e) {
 88             // TODO 自动生成的 catch 块
 89             e.printStackTrace();
 90         }
 91     }
 92     
 93     //实现插入的效果（文件有多行，比较复杂的文件）
 94         @Test
 95         public void test4(){
 96             RandomAccessFile raf2 = null;
 97             try {
 98                 raf2 = new RandomAccessFile(new File("RandomAccess.txt"), "rw");
 99                 raf2.seek(0);
100                 byte[] b=new byte[20];
101                 int len;
102                 StringBuffer sb=new StringBuffer();
103                 while((len=raf2.read(b))!=-1){
104                     sb.append(new String(b,0,len));//每一次字符串都会加长
105                 }
106                 raf2.seek(0);
107                 raf2.write(new String("Kobe!!!!").getBytes());
108                 raf2.write(sb.toString().getBytes());
109                 
110             } catch (IOException e) {
111                 // TODO 自动生成的 catch 块
112                 e.printStackTrace();
113             }
114             try {
115                 raf2.close();
116             } catch (IOException e) {
117                 // TODO 自动生成的 catch 块
118                 e.printStackTrace();
119             }
120         }
121 }

RandomAccessFile

  1 package com.btp.t4;
  2 
  3 import java.io.BufferedReader;
  4 import java.io.BufferedWriter;
  5 import java.io.DataInputStream;
  6 import java.io.DataOutputStream;
  7 import java.io.File;
  8 import java.io.FileInputStream;
  9 import java.io.FileNotFoundException;
 10 import java.io.FileOutputStream;
 11 import java.io.IOException;
 12 import java.io.InputStream;
 13 import java.io.InputStreamReader;
 14 import java.io.OutputStreamWriter;
 15 import java.io.UnsupportedEncodingException;
 16 
 17 import org.junit.Test;
 18 
 19 public class TestOtherStream {
 20     /*
 21      * 如何实现字节流和字符流之间的转换
 22      * 转换流：InputStreamReader  OutputStreamWriter
 23      * 编码：字符串--->字节数组
 24      * 解码：字节数组--->字符串
 25      */
 26     @Test
 27     public void test1(){
 28         //解码
 29         File file=new File("hello1.txt");
 30         FileInputStream fis = null;
 31         try {
 32             fis = new FileInputStream(file);
 33         } catch (FileNotFoundException e1) {
 34             // TODO 自动生成的 catch 块
 35             e1.printStackTrace();
 36         }
 37         InputStreamReader isr = null;
 38         try {
 39             isr = new InputStreamReader(fis,"GBK");
 40         } catch (UnsupportedEncodingException e) {
 41             // TODO 自动生成的 catch 块
 42             e.printStackTrace();
 43         }
 44         BufferedReader br=new BufferedReader(isr);
 45         //编码
 46         File file1=new File("hello15.txt");
 47         FileOutputStream fos = null;
 48         try {
 49             fos = new FileOutputStream(file1);
 50         } catch (FileNotFoundException e) {
 51             // TODO 自动生成的 catch 块
 52             e.printStackTrace();
 53         }
 54         OutputStreamWriter osw = null;
 55         try {
 56             osw = new OutputStreamWriter(fos,"GBK");
 57         } catch (UnsupportedEncodingException e) {
 58             // TODO 自动生成的 catch 块
 59             e.printStackTrace();
 60         }
 61         BufferedWriter bw=new BufferedWriter(osw);
 62         String str;
 63         try {
 64             while((str=br.readLine())!=null){
 65                 bw.write(str);
 66                 bw.newLine();
 67                 bw.flush();
 68             }
 69         } catch (IOException e) {
 70             // TODO 自动生成的 catch 块
 71             e.printStackTrace();
 72         }
 73         try {
 74             fis.close();
 75         } catch (IOException e) {
 76             // TODO 自动生成的 catch 块
 77             e.printStackTrace();
 78         }
 79         try {
 80             isr.close();
 81         } catch (IOException e) {
 82             // TODO 自动生成的 catch 块
 83             e.printStackTrace();
 84         }
 85         try {
 86             fos.close();
 87         } catch (IOException e) {
 88             // TODO 自动生成的 catch 块
 89             e.printStackTrace();
 90         }
 91         try {
 92             osw.close();
 93         } catch (IOException e) {
 94             // TODO 自动生成的 catch 块
 95             e.printStackTrace();
 96         }
 97         try {
 98             br.close();
 99         } catch (IOException e) {
100             // TODO 自动生成的 catch 块
101             e.printStackTrace();
102         }
103         try {
104             bw.close();
105         } catch (IOException e) {
106             // TODO 自动生成的 catch 块
107             e.printStackTrace();
108         }
109     }
110     
111     
112     /*
113      * 标准的输入输出流：
114      * 标准的输入流：System.in
115      * 标准的输出流：System.out
116      */
117     @Test
118     public void test2()
119     {
120         InputStream is=System.in;//字节流输入
121         InputStreamReader isr=new InputStreamReader(is);//转换为字符流
122         BufferedReader br=new BufferedReader(isr);//变为带缓冲的字符流
123         
124         String str = null;
125         while(true){
126             System.out.println("请输入字符串：");
127             try {
128                 str=br.readLine();
129             } catch (IOException e) {
130                 // TODO 自动生成的 catch 块
131                 e.printStackTrace();
132             }
133             if(str.equalsIgnoreCase("e")||str.equalsIgnoreCase("exit")){
134                 break;
135             }
136             String str1=str.toUpperCase();
137             System.out.println(str1);
138         }
139         try {
140             br.close();
141         } catch (IOException e) {
142             // TODO 自动生成的 catch 块
143             e.printStackTrace();
144         }
145     }
146     
147     
148     /*
149      * 打印流：    字节流：PrintStream，字符流：PrintWriter
150      */
151     @Test
152     public void test3(){
153         
154     }
155     
156     /*
157      * 数据流：    DataInputStream，DataOutputStream
158      */
159     @Test
160     public void test4(){
161         DataOutputStream dos = null;
162         try {
163             dos = new DataOutputStream(new FileOutputStream(new File("data.txt")));
164             dos.writeInt(123);
165             dos.writeUTF("我喜欢Java");
166             dos.writeLong(157571959);
167             dos.writeBoolean(false);
168         } catch (IOException e) {
169             // TODO 自动生成的 catch 块
170             e.printStackTrace();
171         }
172         finally{
173         try {
174             dos.close();
175         } catch (IOException e) {
176             // TODO 自动生成的 catch 块
177             e.printStackTrace();
178         }
179         }
180         
181         DataInputStream dis=null;
182         try {
183             dis = new DataInputStream(new FileInputStream(new File("data.txt")));
184             System.out.println(dis.readInt());
185             System.out.println(dis.readUTF());
186             System.out.println(dis.readLong());
187             System.out.println(dis.readBoolean());
188         } catch (IOException e) {
189             // TODO 自动生成的 catch 块
190             e.printStackTrace();
191         }
192         try {
193             dis.close();
194         } catch (IOException e) {
195             // TODO 自动生成的 catch 块
196             e.printStackTrace();
197         }
198     }
199     
200 }

OtherStream

 1 package com.btp.t4;
 2 
 3 import java.io.BufferedReader;
 4 import java.io.IOException;
 5 import java.io.InputStreamReader;
 6 
 7 public class MyInput {
 8     public String nextString(){
 9         InputStreamReader isr=new InputStreamReader(System.in);
10         BufferedReader br=new BufferedReader(isr);
11         String str = null;
12         try {
13             str = br.readLine();
14         } catch (IOException e) {
15             // TODO 自动生成的 catch 块
16             e.printStackTrace();
17         }
18         return str;
19         
20     }
21     
22     public int nextInt(){
23         return Integer.parseInt(nextString());
24     }
25     
26     public boolean nextBoolean(){
27         return Boolean.parseBoolean(nextString());
28     }
29     
30     public static void main(String[] args){
31         MyInput i=new MyInput();
32         System.out.println("请输入一个字符串：");
33         String str=i.nextString();
34         System.out.println(str);
35         
36         int j=i.nextInt();
37         System.out.println(j+1);
38     }
39     
40 }

MyInput

你可能感兴趣的:(JavaSE-IO流)

c++ 的iostream 和 c++的stdio的区别和联系黄卷青灯77 c++算法开发语言 iostream stdio
在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
《庄子.达生9》钱江潮369
【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
运城寻访重逢石头纪实【严建设老照片395 集】我简直能把你想透，当我走进运城的时候。我已急得热汗直流，访问了十九个老头，把晋南的小城转了三周。虽然是悠久的思旧，我仍然是牛样的执... 严建设
运城寻访重逢石头纪实【严建设老照片395集】我简直能把你想透，当我走进运城的时候。我已急得热汗直流，访问了十九个老头，把晋南的小城转了三周。虽然是悠久的思旧，我仍然是牛样的执拗。说什么变换的世情，泛起了过去的逝流，你就是真正的故友。踏破铁鞋的淡愁，已化为不废功夫的范畴，是就像远在天涯近在咫尺，就像是梦乡的邂逅，我紧紧地攥着你的手。你已长成了高高的个头，俊逸的容颜却很清瘦，你那样顽皮的童音，已变到老
人生的每一步路都算数 sheli
如果你想打工，一直靠打工赚钱，那你就会不断的希望自己变得更专业，不断的希望能够获得更好的工作机会，升职加薪。如果你的目标志不在此，而是拥有自己的企业，那你的选择就会出现差别。在认真打工的人眼里，会“不务正业”，会总是选择不同岗位，甚至放弃高薪机会。但是这背后都是有更加长远的规划。成功富人所必需的管理技能包括：1．对现金流的管理。2．对系统的管理。3．对人员的管理。所以，在没有获得这些能力之前，只要
Rust基础知识 GRKF15 rust 开发语言后端
1.Rust语言简介1.1基础语法变量声明：let关键字用于声明变量，可以指定或不指定类型，如leta=10;和letmutc=30i32;。函数定义：使用fn关键字定义函数，并指定参数类型及返回类型，如fnadd(i:i32,j:i32)->i32{i+j}。控制流：包括if、else等，控制语句后需要使用;来结束语句。1.2数据类型整数类型：i8、i16、i32、i64、i128，以及无符号的
《太虚游》第六十二章。玄牝之威。古楼臭道士
“好好好，流云这孩子深得我心，想必长爻知道是你的话定然会惊喜不已的。”白玄牝听得风流云应了下来，脸色慈和，伸手在他头顶轻轻抚了抚，如同抚在怀中九尾小狐一样自然，极其温柔。身后的四位青丘长老同时一怔，嘴角微动，似要开口劝阻。风流云只感到一道霞光瑞气如有实质一般顺着头顶百会大穴直沉在下丹田内，随后这股气息又逐渐凝聚，似乎给自己吃了什么东西一般。啊喔不好，这祖奶奶该不会是看中我这肉身，像人魔一样，要给她
网络编程基础记得开心一点啊网络
目录♫什么是网络编程♫Socket套接字♪什么是Socket套接字♪数据报套接字♪流套接字♫数据报套接字通信模型♪数据报套接字通讯模型♪DatagramSocket♪DatagramPacket♪实现UDP的服务端代码♪实现UDP的客户端代码♫流套接字通信模型♪流套接字通讯模型♪ServerSocket♪Socket♪实现TCP的服务端代码♪实现TCP的客户端代码♫什么是网络编程网络编程，指网络上
Linux sh命令 fengyehongWorld Linux linux
目录一.基本语法二.选项2.1-c字符串中读取内容，并执行2.1.1基本用法2.1.2获取当前目录下失效的超链接2.2-x每个命令执行之前，将其打印出来2.3结合Here文档使用一.基本语法⏹Linux和Unix系统中用于执行shell脚本或运行命令的命令。sh[选项][脚本文件][参数...]⏹选项-c：从字符串中读取内容，并执行。-x：在每个命令执行之前，将其打印出来。-s：从标准流中读取内容
白骑士的Java教学基础篇 2.5 控制流语句白骑士所长 Java 教学 java 开发语言
欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
Java：爬虫框架 dingcho Java java 爬虫
一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
组诗·三国群英颂（周瑜、马超、贾诩、赵云）颍川荀清
念奴娇·怀周郎矶头万仞、若关情，仍叹当年英物！一揽长江，龙流怒，化作孙吴阵壁。浪里船城，铁锁平川，袖挽千堆雪。烈胆豪情，斗牛惊认奇杰！但看戎马余生，纵横万里，正英姿勃发。宏图霸业弹指间，惟见涛生云灭。苍天轻狂，妒意猖作，帅将难华发。难忆郎顾，青史相伴别月。古体·西凉天将军大漠狂烟起，孑然佩青锋。神威震羌月，锦袍曜汉空。终囚蜀山险，瘴疠掩长虹。天地一孤啸，匹马又西风。水调歌头·文和乱武山水应将残，清
妖孽宫廷（四）安好是佳
1.“纸糊三阁老，泥塑六尚书”与商辂堂堂文官言官，数年苦读儒家经典，应该是皇帝的智囊团，但是在这个时期的明朝政坛下居然是这样的评价，成为皇帝的后腿子团，成为国家发展的智障团，可见其背后有很强的推动力，让言官们躲避刚正不阿，做出祸国殃民的举措。我想，这个推动力应该是首先保住性命，而后同流而强取豪夺他人财物。在监派出头的环境下，尤其在监派强大的特务机构和惩罚机构，让那些发现问题的言官们不敢言。这可是脑
windows下python opencv ffmpeg读取摄像头实现rtsp推流拉流图像处理大大大大大牛啊 opencv实战代码讲解视觉图像项目 windows python opencv
windows下pythonopencvffmpeg读取摄像头实现rtsp推流拉流整体流程1.下载所需文件1.1下载rtsp推流服务器1.2下载ffmpeg2.开启RTSP服务器3.opencv读取摄像头并调用ffmpeg进行推流4.opencv进行拉流5.opencv异步拉流整体流程1.下载所需文件1.1下载rtsp推流服务器下载RTSP服务器下载页面https://github.com/blu
【加密算法基础——对称加密和非对称加密】 XWWW668899 网络安全服务器笔记
对称加密与非对称加密对称加密和非对称加密是两种基本的加密方法，各自有不同的特点和用途。以下是详细比较：1.对称加密特点密钥:使用相同的密钥进行加密和解密。发送方和接收方必须共享这个密钥。速度:通常速度较快，适合处理大量数据。实现:算法相对简单，计算效率高。常见算法AES(高级加密标准)DES(数据加密标准)3DES(三重数据加密标准)RC4(流密码)应用场景文件加密磁盘加密传输大量数据时的加密2.
《爱情》杜文霞
杜文霞坚持原创分享第39天（20190214）图片发自App对爱情的认识我越来越清晰了。真正的爱情是成年人的游戏，双方在关系中是平等的。就像舒婷《致橡树》中写的：我如果爱你——绝不学痴情的鸟儿，为绿荫重复单调的歌曲；必须是你近旁的一株木棉，作为树的形象和你站在一起。我们共享雾霭、流岚、虹霓。仿佛永远分离，却又终身相依。爱情中的爱是相互的，是爱与被爱的流动，不是控制和占有。如果一方总觉得另一方“应该
DVBS 卫星波段设置晨春计 TV Android TV android
目录背景DVBS介绍LNB(LowNoiseBlock)LNBC(LowNoiseBlockController)Tuner接收频率范围卫星波段范围卫星波段降频Ku波段降频C波段降频码流机和DVBS菜单设置背景不经常使用DVBS频率设置，容易忘记，整理如下。DVBS介绍在DVBS/S2信号通过同轴线进入电视/机顶盒的同时，LNBC会通过同轴线向外输出0/22K，13V/18V等信号，以控制LNB的
保研日记--哈工大威海计算机学院 faaarii 保研
传送门保研日记--中国海洋大学计算机系保研日记--中国人民大学信息学院（人大信院）保研日记--北京交通大学计算机学院保研材料模板（自我介绍，个人简历，个人陈述，推荐信）哈工大威海计算机学院这次夏令营给我的感觉非常的朴素，哈哈哈哈营员就有四个群，985/211、双一流、双非、四非？？没有宣讲会、见面会，在面试开始之前放了一个简短的宣传片。（傲娇，绝对不整那些花里胡哨的哈哈哈）面试有三组老师，分别问你
孩子初三马上毕业，学习成绩不好，想读3+2大专，有前途吗？英语时代
目前，我国高等教育出现了“强者恒强、弱者恒弱”的现象，清华北大等一批985高校(现在叫一流大学)，基本上处在象牙塔之顶，无论是学校平台、师资力量、学生水平还是企业的认可度，都可以说是面面俱到，学生们享受着我国最好的教育资源，将来的就业质量都非常高，之后再反馈给母校，母校名气更大，生源质量更好，一直如此，良性循环！而地方院校，例如地级市大学／学院等，基本上在各个方面都不如上述顶尖院校，因为学校基础薄
python中的迭代器有什么用 hakesashou python基础知识 python 开发语言
什么是Python迭代器？迭代器（Iterator）：迭代器可以看作是一个特殊的对象，每次调用该对象时会返回自身的下一个元素，从实现上来看，一个迭代器对象必须是定义了__iter__()方法和next()方法的对象。1、Python的Iterator对象表示的是一个数据流，可以把这个数据流看做是一个有序序列，但我们却不能提前知道序列的长度，所以Iterator的计算是惰性的，只有在需要返回下一个数
【财富流教练认证打卡7/30】 1c60b2f691e2
今天是4月4日，我是北斗，今天是我推演总第67场，教练第30盘。教练:北斗波波玩家:祚然(13，男)，奕鸣(12，男)，张何(11，女)，张苗(9，女)主题:青少年公益盘①今天作为教练，让我难忘的情景有哪些？地域差异性、或许也有年龄差异的原因？来自内蒙古的两位男生初次接触沙盘，线上无盘推演，学业安排较紧张。祚然补课回来匆忙上线参加沙盘推演，奕鸣即使是参加游戏也不是很放松，但他们两个仍然能够专注投入
Kafka详细解析与应用分析芊言芊语 kafka 分布式
Kafka是一个开源的分布式事件流平台（EventStreamingPlatform），由LinkedIn公司最初采用Scala语言开发，并基于ZooKeeper协调管理。如今，Kafka已经被Apache基金会纳入其项目体系，广泛应用于大数据实时处理领域。Kafka凭借其高吞吐量、持久化、分布式和可靠性的特点，成为构建实时流数据管道和流处理应用程序的重要工具。Kafka架构Kafka的架构主要由
MATLAB语言基础教程、小项目1：简单的计算器、小项目2：有页面的计算器、使用App Designer创建GUI计算器 azuredragonz 学习教程 matlab 开发语言
MATLABMATLAB语言基础教程1.MATLAB简介2.基本语法变量与赋值向量与矩阵矩阵运算数学函数控制流3.函数4.绘图案例：简单方程求解小项目1：简单的科学计算器功能代码项目说明小项目2：有页面的计算器使用AppDesigner创建GUI计算器主要步骤：完整代码（使用MATLAB编写）说明：如何运行：小项目总结MATLAB语言基础教程1.MATLAB简介MATLAB（矩阵实验室）是一种用于
算法笔试-编程练习-好题-05 Glen 997 大厂校招-编程集训算法动态规划双指针
【题目类型：动规+双指针】题目内容有N个基站采用链式组网，按照从左到右编码为1到N编号。已知定义“业务”概念为三元组(基站起始编号，基站结束编号，利润)，意味着需要占据基站起始编号到基站结束编号的所有基站，打通信号流，可以获得对应利润。现在外部存在多个“业务"需求待接纳，但基站使用具有排他性，也就是说一旦某一个业务占据某个基站，其他业务不可以再使用此基站。那么接纳哪些业务需求，可以使得利润最大化?
ODOO不同版本与平台选择 chouchengyin2080 c#操作系统运维
1.10.0vs11.0vs8.0截至2017年底，最新的ODOO发布版为ODOO11.0，但功能上有一定精简（去除财务模块，去除工作流支持），技术上变动较大（代码逐步迁移至Python3，前端框架改写得抽象）。所以如果是从生产使用的角度来讲，ODOO10.0是当前最好选择，因为其更稳定，第三方模块也更多更全面。而如果是ODOO技术爱好从业者，则逐步迁移至ODOO11.0也有必要，因为其底层技术架
Xilinx 7系列FPGA架构之器件配置（一） FPGA技术实战 FPGA器件架构 Xinx FPGA硬件设计 fpga开发
引言：本系列博文描述7系列FPGA配置的技术参考。作为开篇，简要概述了7系列FPGA的配置方法和功能。随后的博文将对每种配置方法和功能进行更详细的描述。本文描述的配置方法和功能适用于所有7系列家族器件，只有少数例外。1.概述Xilinx®7系列FPGA通过将特定于应用程序的配置数据（位流）加载到内存中进行配置。7系列FPGA可以主动从外部非易失性存储设备加载，也可以通过外部智能源（如微处理器、DS
悠悠岁月——（法）安妮·埃尔诺欧阳云飞
崭新的风格和出色的语言使《悠悠岁月》成为一部杰作，安妮·埃尔诺也因此当之无愧地跻身于法国当代第一流作家之列。——“21世纪年度最佳外国小说”评选委员会一种无人称自传，刚开始读还不了解作者的写作样式，有点茫然，摸不着头脑。但是读着读着就明白了作者的写作脉络，而且有点上头，停不下来。读的时候很畅快，有一种似曾相识的感觉，回想过去，再看看现在，仿佛两个平行时空串联起来，我们也恨不得穿越回去亲身经历时代的
七步成诗（三） d1698df63db8
第四步：熟练掌握专业方法、工具流和业务模板。要组织力量编写《咨询方法、工具和业务模板集锦》并开展系列讲座，组织力量编写《用图表说话》并讲座。各位同事，尤其是年轻同事一定要能快又好地使用各种专业方法和工具，把这当作吃饭家伙，当作就象我们中国人用筷子一样的基本功。有的咨询师连做个PPT文件都画得粗鄙不堪，连画个图表都不会，居然还心安理得。这个样子，老人也就罢了，年轻人还这样，就令人失望、让人看不起、让
平淡无奇但又与众不同的日子——春节我是铃儿
千晓教育段老师引领大家学习“心流”写作营训练。今天是第三天打卡练习，主题是《春节的故事》。“心流”顾名思义即是内心真实情感的流动。说到春节，我已经历了40个这样即平凡又别具意义的日子。跟随记忆回溯到小时候，不免有温暖和丝丝感动。说她平淡无奇是因为这一天跟平常一样都是24个小时，说她与众不同是因为赋予她一个名字——春节。在这个日子里人们会尽力做充分的准备，迎接她、祝贺她。记事起家境贫寒，但年会被父母
为什么越来越多的女性开始重视学习和成长温暖的小太阳2019
不知大家有没有发现这样一种现象：以前朋友圈的人喜欢秀恩爱，秀工作，秀娃，现在他们换了风格，开始秀学习了，秀自我反思和成长了。打开朋友圈一看，A秀去健身房锻炼的马甲线——坚持了三个月，汗水没有白流。B秀自己最近看的书——这个月看书3本，收获颇多，“人丑”就是要多读书，然后配上三本书的照片加自己的“丑照”。C分享自己当妈的经验——父母和孩子需要多沟通，本以为小孩要钱是为了买游戏机，没想到是今天母亲节，
解决前端导出excel文件，打开为乱码荔枝，你让我拿什么荔枝！ vue 前端 elementui vue.js
前端开发中，导入和导出文件是比较常见的业务场景，常见的情况是：后端返回一个二进制的流文件，前端将其转化为excel文件即可。但是往往会出现转化后的excel文件内容位乱码的情况，本文中提供了两个解决方案：方案一：用户自定义上传方法添加附件添加附件代码解读：上述代码采用了element-ui的el-upload文件上传的组件。改组件有两种文件上传的方式：1.组件自带的上传方法，只需要给其设置acti
ztree异步加载 3213213333332132 JavaScript Ajax json Web ztree
相信新手用ztree的时候,对异步加载会有些困惑，我开始的时候也是看了API花了些时间才搞定了异步加载，在这里分享给大家。我后台代码生成的是json格式的数据，数据大家按各自的需求生成，这里只给出前端的代码。设置setting，这里只关注async属性的配置 var setting = { //异步加载配置
thirft rpc 具体调用流程 BlueSkator 中间件 rpc thrift
Thrift调用过程中，Thrift客户端和服务器之间主要用到传输层类、协议层类和处理类三个主要的核心类，这三个类的相互协作共同完成rpc的整个调用过程。在调用过程中将按照以下顺序进行协同工作：（1）将客户端程序调用的函数名和参数传递给协议层（TProtocol），协议
异或运算推导, 交换数据 dcj3sjt126com PHP 异或 ^
/* * 5 0101 * 9 1010 * * 5 ^ 5 * 0101 * 0101 * ----- * 0000 * 得出第一个规律: 相同的数进行异或, 结果是0 * * 9 ^ 5 ^ 6 * 1010 * 0101 * ---- * 1111 * * 1111 * 0110 * ---- * 1001
事件源对象周华华 JavaScript
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml&q
MySql配置及相关命令 g21121 mysql
MySQL安装完毕后我们需要对它进行一些设置及性能优化，主要包括字符集设置，启动设置，连接优化，表优化，分区优化等等。一修改MySQL密码及用户
[简单]poi删除excel 2007超链接 53873039oycg Excel
采用解析sheet.xml方式删除超链接，缺点是要打开文件2次,代码如下: public void removeExcel2007AllHyperLink(String filePath) throws Exception { OPCPackage ocPkg = OPCPac
Struts2添加 open flash chart 云端月影
准备以下开源项目： 1. Struts 2.1.6 2. Open Flash Chart 2 Version 2 Lug Wyrm Charmer (28th, July 2009) 3. jofc2，这东西不知道是没做好还是什么意思，好像和ofc2不怎么匹配，最好下源码，有什么问题直接改。 4. log4j 用eclipse新建动态网站，取名OFC2Demo，将Struts2 l
spring包详解 aijuans spring
下载的spring包中文件及各种包众多，在项目中往往只有部分是我们必须的，如果不清楚什么时候需要什么包的话，看看下面就知道了。 aspectj目录下是在Spring框架下使用aspectj的源代码和测试程序文件。Aspectj是java最早的提供AOP的应用框架。 dist 目录下是Spring 的发布包，关于发布包下面会详细进行说明。 docs&nb
网站推广之seo概念 antonyup_2006 算法 Web 应用服务器搜索引擎 Google
持续开发一年多的b2c网站终于在08年10月23日上线了。作为开发人员的我在修改bug的同时，准备了解下网站的推广分析策略。所谓网站推广，目的在于让尽可能多的潜在用户了解并访问网站，通过网站获得有关产品和服务等信息，为最终形成购买决策提供支持。网站推广策略有很多，seo，email，adv
单例模式,sql注入,序列百合不是茶单例模式序列 sql注入预编译
序列在前面写过有关的博客,也有过总结,但是今天在做一个JDBC操作数据库的相关内容时需要使用序列创建一个自增长的字段居然不会了,所以将序列写在本篇的前面 1,序列是一个保存数据连续的增长的一种方式; 序列的创建; CREATE SEQUENCE seq_pro 2 INCREMENT BY 1 -- 每次加几个 3
Mockito单元测试实例 bijian1013 单元测试 mockito
Mockito单元测试实例： public class SettingServiceTest { private List<PersonDTO> personList = new ArrayList<PersonDTO>(); @InjectMocks private SettingPojoService settin
精通Oracle10编程SQL(9)使用游标 bijian1013 oracle 数据库 plsql
/* *使用游标 */ --显示游标 --在显式游标中使用FETCH...INTO语句 DECLARE CURSOR emp_cursor is select ename,sal from emp where deptno=1; v_ename emp.ename%TYPE; v_sal emp.sal%TYPE; begin ope
【Java语言】动态代理 bit1129 java语言
JDK接口动态代理 JDK自带的动态代理通过动态的根据接口生成字节码(实现接口的一个具体类)的方式，为接口的实现类提供代理。被代理的对象和代理对象通过InvocationHandler建立关联 package com.tom; import com.tom.model.User; import com.tom.service.IUserService;
Java通信之URL通信基础白糖_ java jdk webservice 网络协议 ITeye
java对网络通信以及提供了比较全面的jdk支持，java.net包能让程序员直接在程序中实现网络通信。在技术日新月异的现在，我们能通过很多方式实现数据通信，比如webservice、url通信、socket通信等等，今天简单介绍下URL通信。学习准备：建议首先学习java的IO基础知识 URL是统一资源定位器的简写，URL可以访问Internet和www，可以通过url
博弈Java讲义 - Java线程同步 (1) boyitech java 多线程同步锁
在并发编程中经常会碰到多个执行线程共享资源的问题。例如多个线程同时读写文件，共用数据库连接，全局的计数器等。如果不处理好多线程之间的同步问题很容易引起状态不一致或者其他的错误。同步不仅可以阻止一个线程看到对象处于不一致的状态，它还可以保证进入同步方法或者块的每个线程，都看到由同一锁保护的之前所有的修改结果。处理同步的关键就是要正确的识别临界条件（cri
java-给定字符串，删除开始和结尾处的空格，并将中间的多个连续的空格合并成一个。 bylijinnan java
public class DeleteExtraSpace { /** * 题目：给定字符串，删除开始和结尾处的空格，并将中间的多个连续的空格合并成一个。 * 方法1.用已有的String类的trim和replaceAll方法 * 方法2.全部用正则表达式，这个我不熟 * 方法3.“重新发明轮子”，从头遍历一次 */ public static v
An error has occurred.See the log file错误解决！ Kai_Ge MyEclipse
今天早上打开MyEclipse时，自动关闭！弹出An error has occurred.See the log file错误提示！很郁闷昨天启动和关闭还好着！！！打开几次依然报此错误，确定不是眼花了！打开日志文件！找到当日错误文件内容： --------------------------------------------------------------------------
[矿业与工业]修建一个空间矿床开采站要多少钱? comsci
地球上的钛金属矿藏已经接近枯竭........... 我们在冥王星的一颗卫星上面发现一些具有开采价值的矿床..... 那么,现在要编制一个预算,提交给财政部门..
解析Google Map Routes dai_lm google api
为了获得从A点到B点的路劲，经常会使用Google提供的API，例如 [url] http://maps.googleapis.com/maps/api/directions/json?origin=40.7144,-74.0060&destination=47.6063,-122.3204&sensor=false [/url] 从返回的结果上，大致可以了解应该怎么走，但
SQL还有多少“理所应当”？ datamachine sql
转贴存档，原帖地址：http://blog.chinaunix.net/uid-29242841-id-3968998.html、http://blog.chinaunix.net/uid-29242841-id-3971046.html！ ------------------------------------华丽的分割线--------------------------------
Yii使用Ajax验证时，如何设置某些字段不需要验证 dcj3sjt126com Ajax yii
经常像你注册页面,你可能非常希望只需要Ajax去验证用户名和Email,而不需要使用Ajax再去验证密码,默认如果你使用Yii 内置的ajax验证Form,例如: $form=$this->beginWidget('CActiveForm', array( 'id'=>'usuario-form',&
使用git同步网站代码 dcj3sjt126com crontab git
转自:http://ued.ctrip.com/blog/?p=3646?tn=gongxinjun.com 管理一网站，最开始使用的虚拟空间，采用提供商支持的ftp上传网站文件，后换用vps，vps可以自己搭建ftp的，但是懒得搞，直接使用scp传输文件到服务器，现在需要更新文件到服务器，使用scp真的很烦。发现本人就职的公司，采用的git+rsync的方式来管理、同步代码，遂
sql基本操作蕃薯耀 sql sql基本操作 sql常用操作
sql基本操作 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年6月1日 17:30:33 星期一 &
Spring4+Hibernate4+Atomikos3.3多数据源事务管理 hanqunfeng Hibernate4
Spring3+后不再对JTOM提供支持，所以可以改用Atomikos管理多数据源事务。Spring2.5+Hibernate3+JTOM参考：http://hanqunfeng.iteye.com/blog/1554251Atomikos官网网站：http://www.atomikos.com/ 一.pom.xml <dependency> <
jquery中两个值得注意的方法one()和trigger()方法 jackyrong trigger
在jquery中，有两个值得注意但容易忽视的方法，分别是one()方法和trigger()方法,这是从国内作者<<jquery权威指南》一书中看到不错的介绍 1） one方法 one方法的功能是让所选定的元素绑定一个仅触发一次的处理函数，格式为 one(type,${data},fn) &nb
拿工资不仅仅是让你写代码的 lampcy 工作面试咨询
这是我对团队每个新进员工说的第一件事情。这句话的意思是，我并不关心你是如何快速完成任务的，哪怕代码很差，只要它像救生艇通气门一样管用就行。这句话也是我最喜欢的座右铭之一。这个说法其实很合理：我们的工作是思考客户提出的问题，然后制定解决方案。思考第一，代码第二，公司请我们的最终目的不是写代码，而是想出解决方案。话粗理不粗。付你薪水不是让你来思考的，也不是让你来写代码的，你的目的是交付产品
架构师之对象操作----------对象的效率复制和判断是否全为空 nannan408 架构师
1.前言。如题。 2.代码。 (1)对象的复制，比spring的beanCopier在大并发下效率要高，利用net.sf.cglib.beans.BeanCopier Src src=new Src(); BeanCopier beanCopier = BeanCopier.create(Src.class, Des.class, false);
ajax 被缓存的解决方案 Rainbow702 JavaScript jquery Ajax cache 缓存
使用jquery的ajax来发送请求进行局部刷新画面，各位可能都做过。今天碰到一个奇怪的现象，就是，同一个ajax请求，在chrome中，不论发送多少次，都可以发送至服务器端，而不会被缓存。但是，换成在IE下的时候，发现，同一个ajax请求，会发生被缓存的情况，只有第一次才会被发送至服务器端，之后的不会再被发送。郁闷。解决方法如下： ① 直接使用 JQuery提供的 “cache”参数，
修改date.toLocaleString()的警告 tntxia String
我们在写程序的时候，经常要查看时间，所以我们经常会用到date.toLocaleString()，但是date.toLocaleString()是一个过时的API，代替的方法如下： package com.tntxia.htmlmaker.util; import java.text.SimpleDateFormat; import java.util.
项目完成后的小总结 xiaomiya js 总结项目
项目完成了，突然想做个总结但是有点无从下手了。做之前对于客户端给的接口很模式。然而定义好了格式要求就如此的愉快了。先说说项目主要实现的功能吧 1，按键精灵 2，获取行情数据 3，各种input输入条件判断 4，发送数据（有json格式和string格式） 5，获取预警条件列表和预警结果列表， 6，排序， 7，预警结果分页获取 8，导出文件（excel，text等） 9，修