Java 输入输出流笔记

最新推荐文章于 2024-07-23 22:47:23 发布
最新推荐文章于 2024-07-23 22:47:23 发布
阅读量251 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40161523/article/details/81413608
版权
本文主要介绍了Java中的File类常用方法以及文件流的处理，包括流的分类、基础用法、缓冲流、转换流、打印流、内存流、对象流、数据流、序列流和RandomAccessFile的使用。
摘要由CSDN通过智能技术生成

目录

 

File类的常用方法

 

文件流（Stream）的处理

流的基础用法

缓冲流

转换流

打印流

内存流

对象流

数据流

序列流

RandomAccessFile

File类的常用方法

构造方法

File ( File parent,String child )

从父抽象路径名和子路径名字符串创建新的 File实例

File ( String pathname )

通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例

File ( String parent ,String child )

通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例

File( URL uri)

通过将给定的 file: URI转换为抽象路径名来创建新的 File实例

文件判断

public boolean canRead()

测试应用程序是否可以读取由此抽象路径名表示的文件

public boolean canWrite()

测试应用程序是否可以修改由此抽象路径名表示的文件

public boolean exists()

测试此抽象路径名表示的文件或目录是否存在

public boolean isDirectory()

测试此抽象路径名表示的文件是否为目录

public boolean isFile()

测试此抽象路径名表示的文件是否为普通文件

public boolean isHidden()

测试此抽象路径名命名的文件是否为隐藏文件

获取文件的信息

public long lastModified()

返回此抽象路径名表示的文件上次修改的时间

public long length()

返回由此抽象路径名表示的文件的长度

public String getName()

返回由此抽象路径名表示的文件或目录的名称

public String getPath()

将此抽象路径名转换为路径名字符串

public String getAbsolutePath() 

返回此抽象路径名的绝对路径名字符串

public File getAbsoluteFile()

返回此抽象路径名的绝对形式

public String getParent()

返回此抽象路径名的父 null的路径名字符串，如果此路径名未命名为父目录，则返回null

文件基本操作

public boolean createNewFile() throws IOException

当且仅当具有该名称的文件尚不存在时，原子地创建一个由该抽象路径名命名的新的空文件

public boolean delete()

删除由此抽象路径名表示的文件或目录

public void deleteOnExit()

请求在虚拟机终止时删除由此抽象路径名表示的文件或目录

public boolean mkdir()

创建由此抽象路径名命名的目录

public boolean mkdirs()

创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录

public boolean renameTo(File dest)

重命名由此抽象路径名表示的文件

文件列表

public String[] list()

返回一个字符串数组，命名由此抽象路径名表示的目录中的文件和目录

public File[] listFiles()

返回一个抽象路径名数组，表示由该抽象路径名表示的目录中的文件

public File[] listFiles(FilenameFilter filter)

该方法的行为与listFiles()方法的行为相同，只是返回的数组中的路径名必须满足过滤器

package packagepath;

import java.io.File;
import java.io.FilenameFilter;
//关于listFiles()和listFiles(new FilenameFilter(){accept})的使用示例
public class ListFilesDemo {
	public static void main(String[] args) {
		// showFiles("filename");
		filterFiles("filename");
	
	}

	// 显示目录下的文件
	public static void showFiles(String path) {
		File file = new File(path);
		File[] files = file.listFiles();
		for (File f : files) {
			System.out.println(f);
			if (f.isDirectory()) {
				showFiles(f.getPath());
			}
		}
	}

	// 过滤后缀为.chm文件
	public static void filterFiles(String path) {
		FilenameFilter filter = (dir, name) -> name.endsWith(".chm");
		File[] files = new File(path).listFiles(filter);
		for (File f : files)
			System.out.println(f);
	}
}

 

文件流（Stream）的处理

  1. 流的逻辑概念
    1. 相当于数据传输的通道，属于底层的资源，使用完成后需要释放资源
  2. 流的分类
    1. 按流的方向
      1. 输入流     InputStream Reader
      2. 输出流     OutputStream Writer
    2. 按数据单元
      1. 字节流     字节流操作的数据单元是8 位的字节    二进制数据    InputStream OutputStream 
      2. 字符流     字符流操作的数据单元是16位的字符   对字符性能方面提升    Reader Writer 
    3. 按功能分类
      1. 节点流     最基本的文件流 直接和底层文件关联
      2. 处理流     必须在节点流的基础上创建|包装  >  修饰器设计模式

    4. 流的基础用法

      1. InputStream > FileInputStream
        1. 方法
          1. int read()            逐个字节读取 ，并返回读取的内容（int单个字节） IO的频率最高
          2. int read( byte[] )  一次读取字节到byte[]数组中，并返回读取的数据长度
        2. 	//read()
	private void read1() {
		InputStream is = null;
		try {
			is = new FileInputStream(filePath);
			int c = 0;
			do {
				c = is.read();
				System.out.print((char) c);
			} while (c != -1);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (is != null) {
					is.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	

	//read(byte)
	private void read2() {
		InputStream is = null;
		try {
			is = new FileInputStream(filePath);
			byte[] b = new byte[1024];
			int len = 0;
			do {
				len = is.read(b);
				for (int i = 0; i < len; i++) {
					System.out.print((char) b[i]);
				}
			} while (len != -1);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				if (is != null) {
					is.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
      2. OutputStream > FileOutputStream
        1. 方法
          1. void write( int i )     单个字节写入
          2. void write( byte[] )  写入一批字节
        2. 
	/**
	 * write(byte) write()
	 * @param str 写入内容
	 */
	private void write1(String str) {
		OutputStream ops = null;
		try {
			ops = new FileOutputStream(filePath, true);
			// int
			ops.write((char) 65);
			// String
			ops.write(str.getBytes());
			// String offset length
			ops.write(str.getBytes(), 0, str.length());
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				ops.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
      3. Reader > FileReader
        1. 方法
          1. int read()
          2. int read( char[] )
        2. private void read1() {
		Reader r = null;
		try {
			r = new FileReader(new File("iotest.txt"));
			char[] buffer = new char[1024];
			StringBuffer sb = new StringBuffer();
			while (true) {
				int len = r.read(buffer);
				if (len == -1)
					break;
				sb.append(buffer, 0, len);
			}
			System.out.println(sb.toString());
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				r.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
      4. Writer > FileWriter
        1. 方法
          1. void write( int i )
          2. void write( String str )
        2. private void write1() {
		Writer w = null;
		try {
			/*
			 * FileWriter(File file, boolean append)
			 * 参数append为true时，则续写反之重写
			 */
			w = new FileWriter(new File("iotest.txt"), true);
			char[] cbuf = "\nbyteTest".toCharArray();
			String str = "\nHelloWorld3.......\r\n你好世界";
			// int
			w.write(65);
			// char[]
			w.write(cbuf);
			// char[] offset length
			w.write(cbuf, 0, cbuf.length);
			// String
			w.write(str);
			// String offset length
			w.write(str, 0, str.length());
			// 清除缓存
			w.flush();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			// close在調用時會調用flush
			try {
				w.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

      5. 综合

        	private void copyText(String readFilePath,String writeFilePath) {
		Reader read = null;
		Writer write = null;
		try {
			read = new FileReader(new File(readFilePath));
			write = new FileWriter(new File(writeFilePath));
			char[] buffer = new char[1024];
			int len = 0;
			while ((len = read.read(buffer)) != -1) {
				write.write(buffer, 0, len);
				write.flush();
			}
			System.out.println("copy complete");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				read.close();
				write.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

	}

	private void copyImage(String readFilePath,String writeFilePath) {
		InputStream in = null;
		OutputStream out = null;
		try {
			in = new FileInputStream(new File(readFilePath));
			out = new FileOutputStream(new File(writeFilePath));
			byte[] buffer = new byte[1024];
			int len = 0;
			while ((len = in.read(buffer)) != -1) {
				out.write(buffer, 0, len);
				out.flush();
			}
			System.out.println("copy complete");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				in.close();
				out.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

         

    5. 缓冲流

      1. 特点
        1. 不能单独创建，必须借助节点流创建
      2. 类别
        1. BufferedInputStream       > int read read( byte offset length ) 数据读取到末尾时返回-1
        2. BufferedOutputStream    > void write weite(byte offset length)
          1. 综合 
                private void copyFile() {
	BufferedInputStream bis = null;
	BufferedOutputStream bos = null;
	try {
	    bos = new BufferedOutputStream(
                            new FileOutputStream("iotest2.txt"));
	    bis = new BufferedInputStream(
                            new FileInputStream("iotest.txt"));
	    byte[] arr = new byte[1024];
            int len = -1;
            while ((len = bis.read(arr)) != -1) {
	        bos.write(arr, 0, len);
            }
        } catch (FileNotFoundException e) {
	    e.printStackTrace();
        } catch (IOException e) {
	    e.printStackTrace();
        } finally {
	        try {
		        bis.close();
		        bos.close();
	    } catch (IOException e) {
		    e.printStackTrace();
	    }
    }
}
        3. BufferedReader  > readLine数据读取到末尾时返回null 
          1. private void bufferRead() {
	BufferedReader br = null;
	try {
		FileReader r = new FileReader(
                            new File("iotest.txt"));
		br = new BufferedReader(r);
		MyBufferedReader mb = new MyBufferedReader(r);
		String str = null;
		// while ((str = mb.myReadLine()) != null) {
		while ((str = br.readLine()) != null) {
			System.out.println(str);
		}
	} catch (FileNotFoundException e) {
		e.printStackTrace();
	} catch (IOException e) {
		e.printStackTrace();
	} finally {
		try {
			br.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}
        4. BufferedWriter  > 写入后需要刷新flush，关闭前会先刷新 
          1. public void bufferWrite() {
	BufferedWriter bw = null;
	try {
		bw = new BufferedWriter(
                        new FileWriter("iotest2.txt"));
		bw.write("bufferWrite重写");
		bw.flush();
	} catch (IOException e) {
		e.printStackTrace();
	} finally {
		try {
			bw.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

    6. 转换流

      1. 类别
        1. public class OutputStreamWriter extends > WriterOutputStreamWriter ( OutputStream out ) 
        2. public class InputStreamReader extends >  ReaderInputStreamReader ( InputStream in ) 
      2.         //在控制台输入字符回车后，打印大写字符
        private void test1() throws IOException {
		InputStream is = System.in;
		OutputStream ou = System.out;
		BufferedReader br = new BufferedReader(
                                       new InputStreamReader(is));
		BufferedWriter bw = new BufferedWriter(
                                       new OutputStreamWriter(ou));
		String line = null;

		while ((line = br.readLine()) != null) {
			if ("end".equals(line))
				break;
			bw.write(line.toUpperCase());
			bw.newLine();
			bw.flush();
		}

		br.close();
		bw.close();

	}

        //在控制台输入字符回车后，打印大写字符在文件中
	private void test2() throws IOException {
		InputStream is = System.in;

		BufferedReader br = new BufferedReader(
                                new InputStreamReader(is));
		BufferedWriter bw = new BufferedWriter(
                                new FileWriter("iotest.txt"));
		String line = null;

		while ((line = br.readLine()) != null) {
			if ("end".equals(line))
				break;
			bw.write(line.toUpperCase());
                        //newLine()可跨平台换行
			bw.newLine();
			bw.flush();
		}
		br.close();
		bw.close();
	}

        //读取文件中字符，打印到控制台中
	private void test3() throws IOException {
		OutputStream ou = System.out;

		BufferedReader br = new BufferedReader(
                                new FileReader("iotest.txt"));
		BufferedWriter bw = new BufferedWriter(
                                new OutputStreamWriter(ou));
		String line = null;

		while ((line = br.readLine()) != null) {
			if ("end".equals(line))
				break;
			bw.write(line.toUpperCase());
			bw.newLine();
			bw.flush();
		}
		br.close();
		bw.close();
	}


        private void test4() throws IOException {
	    InputStream is = System.in;
	    OutputStream ou = System.out;

	    BufferedInputStream bis = new BufferedInputStream(is);
	    BufferedOutputStream bos = new BufferedOutputStream(ou);
	
            byte[] buffer = new byte[1024];
	    bis.read(buffer);
	    bos.write(buffer);
	    bos.close();
        }

    7. 打印流

      1. PrintWriter(OutputStream out, boolean autoFlush)  autoFlush为true,自动刷新 
        private void test1() throws IOException {
		InputStream is = System.in;
		PrintWriter out = new PrintWriter(System.out, true);
		BufferedReader br = new BufferedReader(
                                        new InputStreamReader(is));
		String str = null;
		while ((str = br.readLine()) != null) {
			if ("end".equals(str))
				break;
			out.println(str.toUpperCase());
		}
		out.close();
		br.close();
	}

    8. 内存流

      1. 特点
        1. io 的行为并不是对文件进行操作，而是对内存中byte[]数组进行操作
        2. byte[ ] 在程序中，是一个临时存放数据的空间，并不是底层的资源，所以并不需要关闭流
      2. 类别
        1. ByteArrayInputStream(byte[] buf) 
        2. ByteArrayOutputStream() 
      3. 	// 将bos读取到的input中的内容，写入bais中toString返回输出
	public String getTextByInputStream(InputStream input) {
		BufferedInputStream bos = null;
		ByteArrayOutputStream bais = null;
		try {
			bos = new BufferedInputStream(input);
			bais = new ByteArrayOutputStream();
			int len = -1;
			while ((len = bos.read()) != -1) {
				bais.write(len);
			}
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				bos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
		return bais.toString();
	}

	private void test1() {
		BufferedInputStream bis = null;
		BufferedOutputStream bos = null;
		try {
			// 将图片文件读取，存入到内存流中
			bis = new BufferedInputStream(
				   new FileInputStream("image.png"));
			bos = new BufferedOutputStream(
                                   new FileOutputStream("copyimage.png"));
			ByteArrayOutputStream baos = 
                                   new ByteArrayOutputStream();
			byte[] buffer = new byte[1024];
			int i = -1;
			// while ((i = bis.read()) != -1) {
			// baos.write(i);
			// }
			while ((i = bis.read(buffer)) != -1) {
				baos.write(buffer, 0, i);
			}
			System.out.println("完成存入内存操作");

			// 将内存流中的图片读取，写入到文件中
			ByteArrayInputStream bais = 
                        new ByteArrayInputStream(baos.toByteArray());
			int j = -1;
			while ((j = bais.read()) != -1) {
				bos.write(j);
			}
			System.out.println("完成磁盘写入操作");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				bis.close();
				bos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

    9. 对象流

      1. 序列化：把对象状态（内部数据等）保存到某种介质中，该介质可以是文件、网络等
      2. 反序列化：从介质中根据所保存的对象状态信息，重构对象
      3. 类别
        1. ObjectInputStream(InputStream in) 将对象保存到二进制文件中序列化（串行化）
        2. ObjectOutputStream (OutputStream out)  在二进制文件中查找对象进行反序列化（并行化）
      4.         private void readObject() {
		ObjectInputStream ois = null;
		try {
			ois = new ObjectInputStream(
					new FileInputStream("iotest2.bin"));
			Person person = (Person) ois.readObject();
			System.out.println("——重构对象完成——");
			System.out.println(person);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}

	private void writeTo(Person person) {

		ObjectOutputStream oos = null;
		try {
			oos = new ObjectOutputStream(
					new FileOutputStream("iotest2.bin"));
			oos.writeObject(person);
			System.out.println("——写入对象完成——");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				oos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

        //只有支持java.io.Serializable接口的对象才能写入流中
        //只能从流中读取支持java.io.Serializable或 java.io.Externalizable接口的对象
        public class Person implements Serializable {
	    private static final long serialVersionUID = 1293810121342278585L;
	    private String name;
	    private String sex;

	    public Person(String name, String sex) {
		    super();
		    this.name = name;
		    this.sex = sex;
	    }
        //省略toString()
        }

    10. 数据流

      1. 特点：提供了各种数据类型对应的读取和写入的方式
      2. 类别
        1. DataInputStream (InputStream in)
        2. DataOutputStream (OutputStream out) 
      3.     public static void main(String[] args) {
		DataOutputStream dataOutput = null;
		DataInputStream dataInput = null;
		try {
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		dataOutput = new DataOutputStream(baos);
		dataOutput.writeBoolean(true);
		dataOutput.writeUTF("string");
		dataOutput.writeInt(1024);

		ByteArrayInputStream bais = 
				new ByteArrayInputStream(baos.toByteArray());
		dataInput = new DataInputStream(bais);

			System.out.println(
					dataInput.readBoolean() +
					":" + dataInput.readUTF() +
					":" + dataInput.readInt());
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				dataOutput.close();
				dataInput.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

         

    11. 序列流

      1. 类别
        1. SequenceInputStream (InputStream s1, InputStream s2)  合并两个输入字节流
        2. SequenceInputStream (Enumeration<? extends InputStream> e)  合并多个个输入字节流
      2.     
        /**
	 * 合并多個文件
	 */
	private void test2() {
		FileInputStream fis1 = null;
		FileInputStream fis2 = null;
		FileInputStream fis3 = null;
		FileOutputStream fos = null;
		SequenceInputStream sis = null;
		try {

			fis1 = new FileInputStream(new File("iotest.txt"));
			fis2 = new FileInputStream(new File("iotest2.txt"));
			fis3 = new FileInputStream(new File("iotest3.txt"));
			fos = new FileOutputStream(new File("iotest1.txt"));
			Vector<InputStream> v = new Vector<>();
			v.add(fis1);
			v.add(fis2);
			v.add(fis3);
			Enumeration<InputStream> enumeration = v.elements();
			sis = new SequenceInputStream(enumeration);
			byte[] buffer = new byte[1024];
			int len = -1;
			while ((len = sis.read(buffer)) != -1) {
				fos.write(buffer, 0, len);
			}
			System.out.println("——合并完成——");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				fis1.close();
				fis2.close();
				fis3.close();
				fos.close();
				sis.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

	/**
	 * 合并两个文件
	 */
	private void test1() {
		SequenceInputStream sis = null;
		FileOutputStream fos = null;
		InputStream f1 = null;
		InputStream f2 = null;
		try {
			f1 = new FileInputStream("iotest.txt");
			f2 = new FileInputStream("iotest2.txt");
			fos = new FileOutputStream("iotest3.txt");
			sis = new SequenceInputStream(f1, f2);
			int len = -1;
			byte[] buffer = new byte[1024];
			while ((len = sis.read(buffer)) != -1) {
				fos.write(buffer, 0, len);
			}
			System.out.println("————合并完成————");
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				f1.close();
				f2.close();
				sis.close();
				fos.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}

    12. RandomAccessFile

      1. 特点：RandomAccessFile（任意访问文件）实现 DataOutput和 DataInput 具备对文件读取和写入的功能
      2. 方法
        1. void seek(long pos)  设置文件指针偏移，从该文件的开头测量，发生下一次读取或写入
        2. long getFilePointer()  返回此文件中的当前偏移量
      3.         //写入对象	
        private void test2() throws IOException {
	  RandomAccessFile ra = new RandomAccessFile("002.bin", "rw");
	  Person person1 = new Person("make", "male");
	  Person person2 = new Person("mary", "female");
	  person1.writeToFile(ra);
	  person2.writeToFile(ra);
	  for (int i = 0; i < ra.length(); i = (int) ra.getFilePointer()){
              ra.seek(i);
	      System.out.println(ra.readUTF() + "," + ra.readUTF());
	  }
	  ra.close();
	  }

        //写入字符串
	private void test1() throws IOException {
          /**
           * r    以只读的方式打开文件   
           * rw   以读、写的方式打开文件，如果不存在尝试创建
           * rwd  相对rw模式，还要求对文件<内容>的每个更新都同步写入到底层存储设备中
           * rws  相对rw模式，还要求对文件的<内容或元数据>的每个更新都同步写入到底层存储设备中   
           */
	  RandomAccessFile raf = new RandomAccessFile("001.txt", "rw");
	  System.out.println(raf.getFilePointer());
	  raf.writeUTF("helloworld");

	  System.out.println(raf.getFilePointer());
	  raf.writeUTF("你好世界HelloWorld");
	  System.out.println("写入完成");
	  // raf.seek(0);
	  // System.out.println(raf.readUTF());
	  // raf.seek(12);
	  // System.out.println(raf.readInt());
	for (int i = 0; i < raf.length();i = (int) raf.getFilePointer()){
		raf.seek(i);
		System.out.println(raf.readUTF());
		}
		raf.close();
	}


        public class Person implements Serializable {	
	    private static final long 
                serialVersionUID = 1293810121342278585L;
	    private String name;
	    private String sex;

	    public Person(String name, String sex) {
	    	super();
	    	this.name = name;
	    	this.sex = sex;
	    }

	    public void writeToFile(RandomAccessFile ra) {
	    	try {
		    ra.writeUTF(this.name);
		    ra.writeUTF(this.sex);
	    	} catch (IOException e) {
		    	e.printStackTrace();
	    	}
    	    }

    	    @Override
    	    public String toString() {
	        return "Person [name=" + name + ", sex=" + sex + "]";
        	}
        }
削方
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java的输入输出流
blue丶的博客
08-24 638
一、输入输出流      读入一个字节序列的对象叫做输入流,写入一个字节序列的对象叫做输出流 抽象类InputStream和OutputStream是Java输入输出流的基础，字节相关操作的对象都继承自这两个。      InputStream和OutputStream有两个抽象的方法，由此衍生出来的类都实现了这两个方法，分别为: abstarct int read(); abstarct int write();     很多时候，我们需要处理Unicode形式的存储信息，因为各国文字的差异，Unico
JAVA输入输出流学习笔记
ABBY258的博客
01-10 385
输入流（Input Stream）：程序从输入流读取数据 输入流（Output Stream）：程序向输出流写入数据 数据流分类： 1.字节流：数据流中最小的数据单元是字节 2.字符流：数据流中最小的数据单元是字符，（java中的字符是Unicode编码，一个字符占2个字节。）但是字符流只能复制文本文件，字节流可以复制所有文件，包括图片、音乐等。
java输入输出笔记
请叫我杰哥
03-14 1110
<br /> <br />JAVA输入输出笔记<br />刚刚开始学习java的时候，发现java提供的输入输出流类有好多，名字也很容易搞混了，因此跳了过去没认真看。遇到了问题一直都是靠百度来临时性的解答。相信很多新手学习java的时候，应该也和我一样吧。这就遗留了一个问题，离开了百度自己就什么都写不出了，哪怕是最简单的文件复制。没辙，被整得实在是头疼，认真的翻了翻jdk，发现其实java的输入输出没想象中的那么复杂。只要理解了一些基本的类，以后无论是遇到什么框架下封装的输入输出流，都将能很快上手。以下是我
Java输入输出流
最新发布
qq_37676896的博客
07-23 861
输入流：读操作输入流（InputStream及其子类）用于从外部源（如文件、网络等）读取数据到程序中，即数据流向是“进”的，被称为读操作。输出流：写操作输出流（OutputStream及其子类）的主要目的是将数据（如文本、字节等）从内存（或程序内部）传输到外部设备或存储介质上。这个过程本质上是将数据写出到某个目标位置，即数据流向是“出”的，被称为写操作。
浅谈Java的输入输出流
12-22 867
Java语言的输入输出功能是十分强大而灵活的，美中不足的是看上去输入输出的代码并不是很简洁，因为你往往需要包装许多不同的对象。在Java类库中，IO部分的内容是很庞大的，因为它涉及的领域很广泛:标准输入输出，文件的操作，网络上的数据流，字符串流，对象流，zip文件流....本文的目的是为大家做一个简要的介绍。 　　流是一个很形象的概念，当程序需要读取数据的时候，就会开启一个通向数据源的流，
Java输入输出流笔记
sdjkjsdh的博客
06-01 463
1.IO流 1.1、输入输出相对于程序运行内存而言。从内存到硬盘是输出，从硬盘到程序是输入 1.2、输入流的基类包括InputStream和Reader，输出流的基类包括OutputStream和Writer。字节流包括InputStream、OutputStream；字符流包括Reader和Writer。字节是机器能读懂的二进制码1010、字符是经过解码的汉字字母等。 1.
Java 的 IO流笔记.md
03-08
- **InputStream/OutputStream**：字节的输入输出流的抽象类。 - 数据单位：字节（8比特，范围0-255） - **Reader/Writer**：字符的输入输出流的抽象类。 - 数据单位：字符（16比特，范围0-65535） #### 二、...
关于JAVA输入输出流造成的Runtime线程阻塞问题【新人笔记】
u013120579的博客
04-13 2026
萌新最近搬砖遇到一个问题，上面让我做一个dump文件的自动解析系统，至于解析的工具，准备用的是google的breakpad，项目部署环境是linux+jdk1.8。其他的无关紧要也就不谈了。一开始写了一个demo放到测试机上面跑，最初代码如下（只保留转换相关的代码，所以不可以运行）：import java.io.InputStreamReader; public class DumpAnaly...
Java学习笔记：基本输入、输出数据操作实例分析
08-19
* Java基本输入输出操作 * System.out.print()、System.out.println()和System.out.printf()函数 * Scanner类的用法 * 输入输出数据的格式字符串 扩展阅读： * 《Java面向对象程序设计入门与进阶教程》 * 《Java...
Java中的输入、输出流
Moonxiyue的博客
05-27 2340
输入输出流 内容概括： 存在java.io包中 所有输入流都是抽象类InputStream（字节输入流）和抽象类Reader（字符输入流）的子类。 所有输出流都是抽象类OutputStream（字节输出流）和抽象类Writer（字符输出流）的子类。 File类 不涉及对文件的读写操作，只获取文件信息，如文件所在目录、文件长度、文件读写权限等。 创建一个File对象的构造方法有： File(String filename); File(String directoryPath, String
Java基础 学习笔记 Markdownr版
06-27
3. 输入/输出（IO）流：Java的15IO流.md文件深入解析了IO流的使用，包括文件流、字符流、字节流以及缓冲流的处理。IO流是数据传输的桥梁，允许程序与外部设备进行数据交换。 4. 多线程：在10多线程.md中，介绍了...
Java-IO输入输出流笔记
weixin_38727550的博客
06-08 127
IO I 是 input 输入 O 是 output 输出 常用实例 /** * 1.如何创建File实例: * File(String filePath) * File(String pathname,String child) * File(File parentFile,String childPath) * * 2. * 相对路径：相对于某国的路径下 * 绝对路径：包含盘符在内的文件或者文件目录的路径 *
Java学习笔记-输入输出流
时间识人的博客
04-27 275
简介： 从外部储存或者其他程序读数数据为输入，将结果写到外部内存或者写到别的程序中为输出。java.io包提供大量的流类，所有的输入流都是抽象类InputStream（字节输入流）或者抽象类Read（字符输入流）的子类，而所有的输出流都是抽象类OutputStream（子节输出流）或者抽象类write（字符输出流）的子类。 File类 File类主要用来获取文件本身的一些信息，不涉及对文件的读写操作。创建一个File对象的三个构造方法： 1：File(String filename) 2:File(Stri
Java实用教程笔记 输入、输出流
zhanghanqmx的博客
12-15 622
输入、输出流期末考试会从10.1考到10.5源&目的地10.1File类创建一个File对象的构造方法文件属性目录创建目录列出目录中的文件FilenameFilter接口辨析文件的创建与删除运行可执行文件10.2文件字节输出流FileInputStream四步骤构造方法byte Java相对C++独有的数据类型使用输入流读取字节关闭流覆盖式vs追加式具体构造函数详看help文档示例10.3文件字节输出流FileOutputStream10.4文件字符输入流、输出流FileReader&Fil
java 输入输出 笔记
onejava0821的博客
01-28 208
一、File类 File类是java.io包下代表与平台无关的目录和文件。File能新建、删除、重命名文件等等，但是不能直接访问文件，需要通过输入输出流对文件进行操作。 （1）访问文件与目录 File类可以通过文件路径字符串来创建File实例，下面程序以几个简单测试File类的功能 package java_test; import java.io.*; public class File...
Java笔记——第九章 输入输出流
weixin_45775165的博客
05-06 670
第九章 输入输出流 一、File类 1、定义 一个File类的对象，表示了磁盘上的文件或文件夹，只负责文件的本身，而不负责文件的内容。 2、File类的构造方法 图片 3、File类常用方法 图片 图片 FilenameFilter 是一个接口。该接口只定义了一个名为accept的方法，对于列表中的每一个方法，都将调用该方法boolean accept(File dir,String filena...
Java中输入输出流
weixin_42207568的博客
05-29 416
        输入输出流都是相对于程序来讲的，程序要读取一个文件就叫做输入，程序要写入一个文件就叫做输出。对照的都是程序。    对文件进行操作的流FileInputStream（字节输入流），FileOutputStream（字节输出流），FileReader（字符输入流），FileWriter（字符输出流）...
Java-输入输出流
MP-214的博客
09-20 330
Java语言将程序中数据的输入输出过程看作是一种数据流动的过程 –将提供输入数据的数据源称作输入流（input stream） –将输出数据的目的地称作输出流（output stream） –键盘-输入流 –显示器-输出流 java程序的输入输出 –数据源：键盘，硬盘，网络 –目的地：显示器，硬盘，网络 –标准IO：一般是指键盘，显示器 –文件IO：磁盘读写 –字节流：byte 底层表示 例： ...
Java之输入输出流
weixin_41914179的博客
05-16 138
流是用来干什么的？ 使用流的主要目的是保持数据的永久性。 根据数据的流向分为输入流和输出流；根据处理数据的类型分为字符流和字节流。 JDK所提供的所有流都位于Java.IO包中，IO部分所涉及的流有：标准的输入输出流、文件的操作流、网络数据流、字符串流、对象流等等。 所有的输入流都是抽象类InputStream（字节输入流）或者抽象类reader（字符输入流）的子类；而所有的输出流都是抽象类OutputStream（字节输出流）或者抽象类write（字符输出流）的子类。 对输入输出流的可以理解为：
J2EE学习笔记：深入理解Java输入输出流与设计模式
在第一章中，主要介绍了Java的输入输出流，这是编程中至关重要的模块。Java的流分为字节流和字符流两大类，分别为InputStream和OutputStream，以及Reader和Writer。字节流如ByteArrayInputStream、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值