Comment convertir des chaînes et des flux d'entrée en Java

Conversion mutuelle entre les chaînes et les flux d'entrée

Lors de la lecture des ressources réseau, la conversion mutuelle entre les chaînes et les flux d'entrée est souvent utilisée.

Convertissez la chaîne en flux d'entrée, le code est le suivant :

public static InputStream getStringStream(String sInputString){ 
　　if (sInputString != null && !sInputString.trim().equals("")){ 
　　    try{ 
　　        ByteArrayInputStream tInputStringStream = new ByteArrayInputStream(sInputString.getBytes()); 
　　        return tInputStringStream; 
　　    }catch (Exception ex){ 
　　        ex.printStackTrace(); 
　　    } 
　　} 
　　return null; 
}

Convertissez le flux d'entrée en chaîne, le code est le suivant :

public static String getStreamString(InputStream tInputStream){ 
　　if (tInputStream != null){ 
　　     try{ 
　　          BufferedReader tBufferedReader = new BufferedReader(new InputStreamReader(tInputStream)); 
　　          StringBuffer tStringBuffer = new StringBuffer(); 
　　          String sTempOneLine = new String(""); 
　　          while ((sTempOneLine = tBufferedReader.readLine()) != null){ 
　　              tStringBuffer.append(sTempOneLine); 
　　          } 
　　         return tStringBuffer.toString(); 
　　    }catch (Exception ex){ 
　　         ex.printStackTrace(); 
　　    } 
　　} 
　　return null; 
}

Ou La méthode suivante, le code est le suivant :

public class StreamTool {
    /**
     * 把输入流的内容转化成字符串
     * @param is
     * @return
     */
    public static String readInputStream(InputStream is){
        try {
            ByteArrayOutputStream baos=new ByteArrayOutputStream();
            int length=0;
            byte[] buffer=new byte[1024];
            while((length=is.read(buffer))!=-1){
                baos.write(buffer, 0, length);
            }
            is.close();
            baos.close();
            //或者用这种方法
            //byte[] result=baos.toByteArray();
            //return new String(result);
            return baos.toString();
        } catch (Exception e) {
            e.printStackTrace();
            return "获取失败";
        }
    }
}

Flux d'entrée et de sortie de caractères

Flux d'entrée de caractères

java. L'abstraction io.Reader est composée uniquement d'entrées de caractères. La classe parent du flux, utilisée pour lire le contenu du fichier. 🎜#

#🎜 🎜#Afin de faciliter la lecture, Java propose une classe pratique pour lire les fichiers de caractères.

Classe FileReader

Méthode de construction :

# 🎜🎜#FileReader(File file); Crée un nouveau FileReader à partir d'un fichier à partir duquel lire les données.

FileReader(String fileName); Crée un nouveau FileReader en fonction du nom d'un fichier à partir duquel lire les données.

• Méthodes de lecture courantes : FileReader(File file); 在给定从中读取数据的 File 的情况下创建一个新 FileReader。

• FileReader(String fileName); 在给定从中读取数据的文件名的情况下创建一个新 FileReader。

常用读取方法：

方法名	说明
int read()	读入一个字符，都到结尾则返回-1
int read(char[] cbuf)	将读取的cbuf.length个字符读取到char数组中
int read(char[] cbuf, int off, int len)	从此字符输入流中偏移量off到len个字符读取到char数组中
void reset()	重置该流
boolean ready()	判断是否准备读取此流
void close()	关闭字符输入流，并释放所有系统资源
long skip(long n)	跳过读取n个字符，并返回跳过字符的数量
void mark(int readLimit)	将此输入流标记，当使用reset方法时就返回到该位置，从此位置开始读入字符

1.单个读取，如果文件太大不建议使用。

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class dome2{
	public static void main(String[] args){
	  File file=new File("D:/../...txt");   //创建file对象
	  FileReader fr=null;
	  
	  try {
		fr=new FileReader(file);
		int c;  
		while((c=fr.read())!=-1) { 
			System.out.print((char)c);  //强制转换成字符
		}
	} catch (FileNotFoundException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}finally {
		if(fr!=null) {
			try {
				fr.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
   }
}

2.读取多个字符输出。

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class dome2{
	public static void main(String[] args){
	  File file=new File("D:/../...txt");   
	  FileReader fr=null;
	  
	  try {
		fr=new FileReader(file);
		char[] c=new char[100];
		int length;
		while((length=fr.read(c))!=-1) {
			System.out.println(new String(c,0,length));  
		}
	} catch (FileNotFoundException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}finally {
		if(fr!=null) {
			try {
				fr.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
   }
}

字符输出流

java.io.Writer抽象类是所有字符输出流的父类，用于对文件写入数据。

字符输出流结构：

为了写入Java提供了一种字符写入的便捷类。

FileWriter类

构造方法：

• FileWriter(File file) 与 FileWriter(String fileName); 使用给定的file对象或者给定的文件路径名构造一个FileWriter对象。

• FileWriter(File file, boolean append) 与 FileWriter(String fileName, boolean append);

nom de la méthode

DescriptionLisez un caractère, il retournera -1int read(char[] cbuf, int off, int len)Décalage de ce flux d'entrée de caractères Lire les caractères len dans le tableau de caractères void reset()Réinitialiser le fluxboolean ready( )void close()# 🎜🎜#Fermer la saisie du caractère diffuser et libérer toutes les ressources systèmelong skip(long n)Sauter la lecture Prendre n caractères et renvoyer le nombre de caractères ignorés #🎜 🎜# Marquer ce flux d'entrée lors de l'utilisation Lorsque la méthode de réinitialisation est appelée, revenez à cette position et commencez à lire les caractères 1. La lecture unique n'est pas recommandée si le fichier est trop volumineux.

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
public class dome2{
	public static void main(String[] args){
	  File file=new File("D:/../...txt");   //创建file对象
       FileWriter  fw=null;
       
       try {
		fw=new FileWriter(file);
		char c='你';
		fw.write((int)c);
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}finally {
		if(fw!=null) {
			try {
				fw.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}       
   }
}

2. Lisez plusieurs caractères et sortie.

	int read()
int read(char[] cbuf)	Read cbuf.length caractères Mettez-le dans le tableau de caractères #🎜🎜 #
	#🎜 🎜#
Déterminer si ce flux est prêt à être lu
	void mark(int readLimit)

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
public class dome2{
	public static void main(String[] args){
	  File file=new File("D:/../...txt");   //创建file对象
       FileWriter  fw=null;
       
       try {
		fw=new FileWriter(file);
		String str="你好,java";
		fw.write(str);  //写入一个字符串，等价于write(str,0,str.length);
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}finally {
		if(fw!=null) {
			try {
				fw.close();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}       
   }
}

Flux de sortie de caractères

java.io.Writer La classe abstraite est la classe parent de tous les flux de sortie de caractères et est utilisée pour écrire des données dans des fichiers.

#🎜🎜##🎜🎜#Structure du flux de sortie des personnages : #🎜🎜##🎜🎜##🎜🎜##🎜🎜##🎜🎜#Pour écrire, Java fournit une classe pratique pour l'écriture de caractères. #🎜🎜##🎜🎜##🎜🎜#Classe FileWriter#🎜🎜##🎜🎜##🎜🎜##🎜🎜#Méthode de construction : #🎜🎜##🎜🎜##🎜🎜##🎜🎜## 🎜🎜#FileWriter(File file) et FileWriter(String fileName Construisez un objet FileWriter en utilisant l'objet fichier donné ou le nom de chemin de fichier donné. #🎜🎜##🎜🎜##🎜🎜##🎜🎜#FileWriter(File file, boolean append) et FileWriter(String fileName, boolean append); en donnant Construisez un objet FileWriter avec un certain objet fichier ou un certain nom de chemin de fichier, et indiquez s'il faut l'ajouter ou l'écraser. #🎜🎜##🎜🎜##🎜🎜##🎜🎜##🎜🎜#Méthodes de lecture courantes#🎜🎜##🎜🎜##🎜🎜##🎜🎜##🎜🎜##🎜🎜#Nom de la méthode # 🎜🎜##🎜🎜#Description#🎜🎜##🎜🎜##🎜🎜##🎜🎜##🎜🎜##🎜🎜#void write(char[] cbuf)#🎜🎜##🎜🎜#will All les tableaux de caractères spécifiés par cbuf sont écrits dans le flux de sortie de caractères #🎜🎜##🎜🎜##🎜🎜##🎜🎜#void write(char[] cbuf,int off,int len)#🎜🎜##🎜🎜#décalera le caractère dans le tableau cbuf de off à write longueur len caractères dans ce flux de sortie. #🎜🎜##🎜🎜##🎜🎜##🎜🎜#void write(String str )#🎜🎜##🎜🎜#Écrire une chaîne dans le flux d'entrée de caractères#🎜🎜##🎜🎜##🎜 🎜# #🎜🎜#void write(String str, int off,int len)#🎜🎜##🎜🎜#Écrivez une chaîne str à partir du décalage désactivé, longueur de la chaîne len dans ce flux de sortie. #🎜🎜##🎜🎜##🎜🎜##🎜🎜#Abstract void flush()#🎜🎜##🎜🎜#Actualise le flux de sortie actuel et force l'écriture de toutes les données de caractères #🎜🎜##🎜🎜# # 🎜🎜##🎜🎜#abstract void close()#🎜🎜##🎜🎜#Fermer ce flux de sortie#🎜🎜##🎜🎜##🎜🎜##🎜🎜##🎜🎜#1.writer(int c );Écrivez un caractère#🎜🎜#rrreee#🎜🎜#2.writer(String str);Écrivez une chaîne#🎜🎜#rrreee

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!