`
whp0731
  • 浏览: 176021 次
  • 性别: Icon_minigender_1
  • 来自: 杭州
社区版块
存档分类
最新评论

java(IO操作)第一部分

    博客分类：
  • J2SE
JavaF#threadJ# 
阅读更多

java(IO操作)第一部分 --------I/O流

一、file文件操作

1、file类是唯一代表文件本身的对象，以下代码表示如果文件不存在则创建，若存在则删除

 

 

import java.io.* ;

public class IODemo04
{
	public static void main(String args[]) throws Exception
	{
		File f = new File("f:\\abc.txt") ;
		if(f.exists())
		{
			f.delete() ;
		}
		else
		{
			f.createNewFile() ;
		}
	}
};

 

2、列出某目录下的全部文件

import java.io.* ;

public class IODemo06
{
	public static void main(String args[])
	{
		loop("d:\\") ;
	}
	public static void loop(String dir)
	{
		File f = new File(dir) ;
		String str[] = null ;
		if(f.isDirectory())
		{
			str = f.list() ;
			for(int i=0;i<str.length;i++)
			{
				loop(dir+"\\"+str[i]) ;
			}
		}
		else
		{
			System.out.println(dir) ;
		}
		
	}
};

 

今天想下午对代码完善了下，按层次输出。。。。。。。。。。

import java.io.File;
  
public class IODemo06   
{   
    public static void main(String args[])   
    {   
        loop("d:\\常用软件",0);   
    }   
    public static void loop(String dir , int i)   
    {   
        File f = new File(dir) ;   
        String str[] = null;
        String s = "";
        int j;
        j = i;
        ++j;
        if(f.isDirectory())   
         {
         
                  
            for (int t = 1; t < j; t++) {
                
                s = s + "--";
            }
                        System.out.println(s + f); 
            str = f.list() ; 
            for(int k=0;k<str.length;k++)   
            {
                
                loop(dir+"\\"+str[k],j) ;   
            }   
        }   
        else  
        {
       
            for (int u = 1; u < j; u++) {

                s = s + "--";
            }
            System.out.println(s + dir);   
        }   
           
    }   
    }

 

二、随机读取类 RandomAccessFile 介绍

1、随机读取

import java.io.* ;

public class IODemo07
{
	public static void main(String args[]) throws Exception
	{
		// 随机读取
		RandomAccessFile raf1 = new RandomAccessFile("f:\\mldn.txt","rw") ;
		// 随机读取有一个限制，就是说如果要进行操作，则必须指定好数据的存储长度
		// 保存姓名（8位字符串）和年龄（int 4）：
		String name = "zhangsan" ;
		int age = 20 ;
		raf1.write(name.getBytes()) ;
		raf1.writeInt(age) ;
		

		name = "lisi    " ;
		age = 30 ;
		raf1.write(name.getBytes()) ;
		raf1.writeInt(age) ;

		name = "wangwu   " ;
		age = 33 ;
		raf1.write(name.getBytes()) ;
		raf1.writeInt(age) ;

		raf1.close() ;

		RandomAccessFile raf2 = new RandomAccessFile("f:\\mldn.txt","r") ;
		// 读取第二个人的数据
		raf2.skipBytes(12) ;
		byte b[] = new byte[8] ;
		raf2.read(b) ;
		int age2 = raf2.readInt() ;
		System.out.println(new String(b)+" --> "+age2) ;

	}
};

 

三、节点流处理流综述

1、流的抽象根类

 

2、继承从上面四个类的节点流



 

3、从上面1）承来的处理流


 

四、节点流介绍

 

1、字节流FileOutputStream的使用

import java.io.* ;
public class IODemo08
{
	public static void main(String args[])
	{
		// 1、表示要操作lxh.txt文件
		File f = new File("f:\\lxh.txt") ;
		OutputStream out = null ;
		// 2、通过子类实例化
		// 使用FileOutputStream子类
		try
		{
			out = new FileOutputStream(f) ;
		}
		catch (Exception e)
		{
		}
		// 将字符串转化为byte数组
		String str = "HELLO MLDN ..." ;
		byte b[] = str.getBytes() ;
		// 3、将byte数组写入到文件之中，写的是byte数组中的内容
		try
		{
			out.write(b) ;
		}
		catch (Exception e)
		{
		}
		// 4、关闭文件操作
		/*
		try
		{
			out.close() ;
		}
		catch (Exception e)
		{
		}
		*/
	}
};

 

2、字节流FileInputStream的使用

import java.io.* ;
public class IODemo09
{
	public static void main(String args[])
	{
		File f = new File("f:\\lxh.txt") ;
		InputStream in = null ;
		try
		{
			in = new FileInputStream(f) ;
		}
		catch (Exception e)
		{
		}
		// 声明一个byte数组，用于接收内容
		byte b[] = new byte[500] ;
		int len = 0 ;
		try
		{
			// 所有的数据都在byte数组中
			len = in.read(b) ;
		}
		catch (Exception e)
		{
		}
		try
		{
			in.close() ;
		}
		catch (Exception e)
		{
		}
		System.out.println(new String(b,0,len)) ;
		// 输出打印的内容

	}
};

 


 3、字符流FileWriter的使用

注意：字符流不同于字节流在程序的最后若没有调用out.close() ;
则内容不会被写入文件中，因为最根本的原因是字符流晕运用了缓存，所以可以在下面程序中

out.write(str) ;语句后面加 out.flush() ;// 表示清空缓存，立即写入文件。

import java.io.* ;
public class IODemo10
{
	public static void main(String args[])
	{
		// 1、表示要操作lxh.txt文件
		File f = new File("f:\\lxh.txt") ;
		Writer out = null ;
		// 2、通过子类实例化
		try
		{
			out = new FileWriter(f) ;
		}
		catch (Exception e)
		{
		}
		String str = "HELLO MLDN ..." ;
		// 3、将字符串写入到文件之中
		try
		{
			out.write(str) ;
		}
		catch (Exception e)
		{
		}
		// 4、关闭文件操作
		/*
		try
		{
			out.close() ;
		}
		catch (Exception e)
		{
		}
		*/
	}
};

 

4、字符流FileReader的使用

import java.io.* ;
public class IODemo11
{
	public static void main(String args[])
	{
		File f = new File("f:\\lxh.txt") ;
		Reader in = null ;
		try
		{
			in = new FileReader(f) ;
		}
		catch (Exception e)
		{
		}
		// 声明一个char数组，用于接收内容
		char b[] = new char[500] ;
		int len = 0 ;
		try
		{
			// 所有的数据都在byte数组中
			len = in.read(b) ;
		}
		catch (Exception e)
		{
		}
		try
		{
			in.close() ;
		}
		catch (Exception e)
		{
		}
		System.out.println(new String(b,0,len)) ;
		// 输出打印的内容

	}
};

 

5、管道流PipedOutputStream 、PipedInputStream 使用

import java.io.* ;
// 定义一个发送者
class SendDemo implements Runnable
{
	private PipedOutputStream out ;
	public SendDemo()
	{
		out = new PipedOutputStream() ;
	}
	public PipedOutputStream getOut()
	{
		return this.out ;
	}
	public void run()
	{
		String str = "Hello MLDN" ;
		try
		{
			out.write(str.getBytes()) ;
			out.close() ;
		}
		catch (Exception e)
		{
		}
		System.out.println("SendDemo --> 发送的内容："+str) ;
	}
};

class ReceDemo implements Runnable
{
	private PipedInputStream in = null ;
	public ReceDemo()
	{
		in = new PipedInputStream() ;
	}
	public PipedInputStream getIn()
	{
		return this.in ;
	}
	public void run()
	{
		byte b[] = new byte[1024] ;
		int len = 0 ;
		try
		{
			len = in.read(b) ;
			in.close() ;
		}
		catch (Exception e)
		{
			System.out.println(e) ;
		}
		System.out.println("ReceDemo --> 收到的内容是："+new String(b,0,len)) ;
	}
};

public class IODemo12
{
	public static void main(String args[])
	{
		SendDemo sd = new SendDemo() ;
		ReceDemo rd = new ReceDemo() ;
		Thread send = new Thread(sd) ;
		Thread rece = new Thread(rd) ;
		// 将两个线程进行连接
		PipedOutputStream out = sd.getOut() ;
		PipedInputStream in = rd.getIn() ;
		// 将输出连接到输入
		try
		{
			out.connect(in) ;
		}
		catch (Exception e)
		{
		}
		send.start() ;
		rece.start() ;
	}
};

五、处理流介绍 

 

1、PrintStream的使用（System.out 是一个PrintStream对象，PrintStream类型又是OutputStream子类
）

    

    

import java.io.* ;
public class IODemo14
{
	public static void main(String args[]) throws Exception 
	{
		// 通过子类完成不同的功能
		OutputStream out = null ;
		// System.out是PrintStream类型，是OutputStream子类
		out = System.out ;
		// 现在的out对象具备了向屏幕上打印内容的能力
		String str = "HELLO MLDN --> LXH" ;
		out.write(str.getBytes()) ;
		out.close() ;
	}
};

 

2、printStream/printWrite实际上是一个打印流，他比那些普通的流OutputStream/Write更加擅长打印。（可以打印或写入文件中各种类型）

     但是需要在OutputStream/Write的基础上装配（即此处“处理流”需要装配在“节点流”上）

     相当于java的装饰模式

import java.io.* ;
public class IODemo15
{
	public static void main(String args[]) throws Exception
	{
		File f = new File("f:\\lxh.txt") ;
		// 使用PrintWriter
		 PrintWriter out = new PrintWriter(new FileWriter(f)) ;
		// 具备了向文件中打印数据的能力
		out.println(true) ;
		out.println(30) ;
		out.println("HELLO MLDN") ;
		out.close() ;
	}
};

 

import java.io.* ;
public class IODemo15
{
	public static void main(String args[]) throws Exception
	{
		//File f = new File("f:\\lxh.txt") ;
		// 使用PrintWriter
		// PrintWriter out = new PrintWriter(new FileWriter(f)) ;
		PrintWriter out = new PrintWriter(System.out) ;
		// 向屏幕中打印数据
		out.println(true) ;
		out.println(30) ;
		out.println("HELLO MLDN") ;
		out.close() ;
	}
};

 

 3、System.in的使用（System.in是InputStream的实例）



 

 如以下两例就刚好出现了以上1、2两点情况：

import java.io.* ;
public class IODemo17
{
	public static void main(String args[]) throws Exception
	{
		InputStream in = null ;
		// 数据等待键盘的输入
		in = System.in ;
		byte b[] = new byte[7] ;
		// 读的时候是等待用户的输入
		int len = in.read(b) ;
		in.close() ;
		System.out.println("输入的内容为："+new String(b,0,len)) ;
	}
};

 

import java.io.* ;
public class IODemo18
{
	public static void main(String args[]) throws Exception
	{
		InputStream in = null ;
		// 数据等待键盘的输入
		in = System.in ;
		String str = "" ;
		int c = 0 ;
		while((c=in.read())!=-1)
		{
			str += (char)c;
		}
		in.close() ;
		System.out.println("输入的内容为："+str) ;
	}
};

  

4、缓冲流BufferReader具有缓冲功能得到一次性读，刚好可以解决以上两个问题

但是BufferReader需要接受的是一个之类Reader对象，所以需要将System.in这个InputStream对象转换为Reader对象，刚好用到了很常用的转换类（如下图）



（上图说明： 存放在文件中的都是字节，而读到内存中才变成字符）

 

（此处“处理流”也是装配在“节点流”上）

import java.io.* ;
public class IODemo19
{
	public static void main(String args[])
	{
		BufferedReader buf = null ;
		// 此处只是准备了要从键盘中读取数据
		buf = new BufferedReader(new InputStreamReader(System.in)) ;
		String str = null ;
		try
		{
			System.out.print("请输入内容：") ;
			str = buf.readLine() ;
		}
		catch (Exception e)
		{
		}
		System.out.println("输入的内容为："+str) ;
	}
};

 

  • 大小: 36.5 KB
  • 大小: 35.5 KB
  • 大小: 49.4 KB
  • 大小: 24 KB
  • 大小: 19.6 KB
分享到：
| java（内存、异常）
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    常用java IO操作以及用jxl读写excel 工具源代码

    Java IO操作是Java编程中非常基础且重要的部分，它提供了对输入输出流的处理，使得程序能够与外部设备（如硬盘、网络、键盘、显示器等）进行数据交换。本工具结合了Java IO操作和JXL库，实现了读取Excel文件并进行...

    JAVA IO同步，异步

    在Linux 环境下，默认情况下所有的Socket 都是阻塞的，一个典型的读操作流程大概是这样：当用户进程调用了recvfrom 这个系统调用，kernel 就开始了IO 的第一个阶段：准备数据。对于 network io 来说，很多时候数据在...

    java io 文件操作大全

    writer.write("第一行\n"); writer.write("第二行\n"); writer.close(); ``` #### 十一、如何将数据追加写入到文件 如果想向文件追加数据而不是覆盖现有内容，可以在构造`FileWriter`时指定`true`作为第二个参数。...

    java（IO）第二部分

    这篇博客“java（IO）第二部分”可能深入探讨了Java IO体系结构的高级概念，特别是那些在第一部分没有涵盖的部分。虽然具体的博文内容无法直接提供，但我们可以基于常见的Java IO主题进行详细的解释。 首先，Java ...

    Java IO 工具类大全

    Java IO（Input/Output）是Java平台中处理输入与输出数据的核心部分，它提供了丰富的类库，使得开发者能够高效地进行文件、网络、内存以及其他I/O流的操作。本篇文章将全面解析Java IO工具类，帮助你理解并掌握其在...

    java io读写文件

    // 解析第一行，确定“SEX”列的位置 StringTokenizer stn = new StringTokenizer(s); for (pos = 0; stn.hasMoreElements(); pos++) { if (((String) stn.nextElement()).equals("SEX")) break; } // 写入...

    Java IO流完整解读

    4. **第三方库Apache Commons IO**：在`FileCopyByCommonsTest()`方法中，使用了Apache Commons IO库的`IOUtils.copy()`方法，它提供了一种简洁的方式来复制文件，包括多张图片的批量复制。这个库提供了很多实用的I/...

    java IO流操作详解源代码下载

    Java IO流操作是Java编程中不可或缺的一部分，它用于在程序和外部资源（如磁盘、网络、内存等）之间传输数据。在这个详细的源代码下载中，我们可以通过四篇相关的CSDN博客文章来深入理解Java IO流的工作原理和实际...

    java 文件操作及IO流

    Java 文件操作与IO流是Java编程中的核心概念，主要用于数据的读取、写入和传输。在Java中，文件操作通常涉及到`java.io`包下的类，如`File`、`FileOutputStream`、`OutputStreamWriter`和`BufferedWriter`等。下面将...

    Java基础篇：IO流.pdf

    Java IO流是Java编程语言中用于处理输入输出操作的一个重要概念。它允许程序读取数据源或向数据目的地写入数据。Java中的IO流主要分为输入流和输出流两大类，每类又可以根据数据处理方式的不同细分为多种具体实现。...

    第一行代码Java源代码第11章课程代码JavaIO编

    总的来说，《第一行代码Java源代码第11章》的课程内容会涵盖以上所述的Java IO基础知识，并通过实例代码帮助读者实践这些概念。通过学习这一章，开发者能够熟练掌握Java中的文件操作、流处理和网络通信，为后续的...

    java IO输出

    Java IO输出是Java编程中非常基础且重要的概念，它涉及到数据的读取和写入操作。在Java中，IO（Input/Output）被用来处理设备间的数据传输，如磁盘、网络、内存等。本篇将深入探讨Java IO输出的相关知识点。 首先，...

    Java IO, NIO and NIO.2

    2. Limit（限制）：表示缓冲区第一个不应读取或写入的元素的基于零的索引，即标识了缓冲区中活跃数据的数量。 3. Position（位置）：表示下一个可以读取的数据项的基于零的索引，或数据项可以被写入的位置。 4. Mark...

    Java IO学习基础之读写文本文件

    `: 读取文件的第一行。 - `while (temp != null) { ... }`: 循环读取文件直至文件结束。 - `bw.write(temp + "\r\n");`: 将读取到的一行文本写入目标文件，并添加换行符`\r\n`。 - `temp = br.readLine();`: 继续...

    java中的io流详解

    IO 流的概念是在 1984 年由 C 语言第一次引入的，后来被 Java 语言所采用。 Java 中的 IO 流可以分为两种基本形式：输入流和输出流。输入流用于从数据文件读取数据，而输出流用于向数据文件写入数据。程序可以通过...

    java io tutorial overview

    ### Java IO 教程概述：理解输入与输出 在深入探讨Java IO（输入输出）教程之前，我们首先需要澄清一个常见的...对于初学者而言，理解输入与输出的概念，熟悉不同类型的流及其用法，是进入Java IO 领域的关键第一步。

    Java-IO.rar_java IO

    Java IO 是Java编程语言中处理输入/输出操作的重要部分，它允许程序与各种类型的设备（如硬盘、网络、内存等）进行数据交换。在给定的"Java-IO.rar_java IO"主题中，有两个主要的知识点：文件拷贝和序列化。 首先，...

    JAVA IO流缓冲字节流缓冲字符流等流经典代码示例加注释总结.rar

    1、博客地址：...3、JAVA IO流经典代码示例，示例从易到难。代码功能涉及字节、字符、字符串、文本文件、图片、音频、视频。演示错误用法和经典用法。 4、代码的结构可查看README文件。

Magicbox
Global site tag (gtag.js) - Google Analytics