Android: Comment lire le fichier en octets?
J'essaie d'obtenir le contenu du fichier en octets dans l'application Android. J'ai obtenir le fichier dans la carte SD veulent maintenant obtenir le fichier sélectionné en octets. J'ai googlé mais pas un tel succès. S'il vous plaît aider
Vous trouverez ci-dessous le code permettant d’obtenir des fichiers avec une extension. Grâce à cela, je récupère des fichiers et les affiche dans spinner. Sur la sélection de fichier, je veux obtenir le fichier en octets.
private List<String> getListOfFiles(String path) {
File files = new File(path);
FileFilter filter = new FileFilter() {
private final List<String> exts = Arrays.asList("jpeg", "jpg", "png", "bmp", "gif","mp3");
public boolean accept(File pathname) {
String ext;
String path = pathname.getPath();
ext = path.substring(path.lastIndexOf(".") + 1);
return exts.contains(ext);
}
};
final File [] filesFound = files.listFiles(filter);
List<String> list = new ArrayList<String>();
if (filesFound != null && filesFound.length > 0) {
for (File file : filesFound) {
list.add(file.getName());
}
}
return list;
}
ici c'est simple:
File file = new File(path);
int size = (int) file.length();
byte[] bytes = new byte[size];
try {
BufferedInputStream buf = new BufferedInputStream(new FileInputStream(file));
buf.read(bytes, 0, bytes.length);
buf.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Ajouter une autorisation dans le fichier manifest.xml:
<uses-permission Android:name="Android.permission.READ_EXTERNAL_STORAGE" />
Voici une solution qui garantit que tout le fichier sera lu, qui ne nécessite aucune bibliothèque et qui est efficace:
byte[] fullyReadFileToBytes(File f) throws IOException {
int size = (int) f.length();
byte bytes[] = new byte[size];
byte tmpBuff[] = new byte[size];
FileInputStream fis= new FileInputStream(f);;
try {
int read = fis.read(bytes, 0, size);
if (read < size) {
int remain = size - read;
while (remain > 0) {
read = fis.read(tmpBuff, 0, remain);
System.arraycopy(tmpBuff, 0, bytes, size - remain, read);
remain -= read;
}
}
} catch (IOException e){
throw e;
} finally {
fis.close();
}
return bytes;
}
Remarque: il suppose que la taille du fichier est inférieure à MAX_INT octets, vous pouvez ajouter un traitement pour cela si vous voulez
La solution la plus simple aujourd'hui consiste à utiliser Apache common io:
byte bytes[] = FileUtils.readFileToByteArray(photoFile)
Le seul inconvénient est d'ajouter cette dépendance dans votre application build.gradle:
implementation 'commons-io:commons-io:2.5'
+ 1562 Nombre de méthodes
Puisque le BufferedInputStream#read accepté n'est pas garanti pour tout lire, plutôt que de garder moi-même la taille des tampons, j'ai utilisé cette approche:
byte bytes[] = new byte[(int) file.length()];
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
DataInputStream dis = new DataInputStream(bis);
dis.readFully(bytes);
Bloque jusqu'à ce qu'une lecture complète soit terminée et ne nécessite pas d'importations supplémentaires.
Si vous souhaitez utiliser une méthode openFileInput à partir d'un contexte, vous pouvez utiliser le code suivant.
Cela créera un BufferArrayOutputStream et ajoutera chaque octet au fur et à mesure de la lecture du fichier.
/**
* <p>
* Creates a InputStream for a file using the specified Context
* and returns the Bytes read from the file.
* </p>
*
* @param context The context to use.
* @param file The file to read from.
* @return The array of bytes read from the file, or null if no file was found.
*/
public static byte[] read(Context context, String file) throws IOException {
byte[] ret = null;
if (context != null) {
try {
InputStream inputStream = context.openFileInput(file);
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
int nextByte = inputStream.read();
while (nextByte != -1) {
outputStream.write(nextByte);
nextByte = inputStream.read();
}
ret = outputStream.toByteArray();
} catch (FileNotFoundException ignored) { }
}
return ret;
}
Un simple InputStream fera
byte[] fileToBytes(File file){
byte[] bytes = new byte[0];
try(FileInputStream inputStream = new FileInputStream(file)) {
bytes = new byte[inputStream.available()];
//noinspection ResultOfMethodCallIgnored
inputStream.read(bytes);
} catch (IOException e) {
e.printStackTrace();
}
return bytes;
}
Vous pouvez aussi le faire de cette façon:
byte[] getBytes (File file)
{
FileInputStream input = null;
if (file.exists()) try
{
input = new FileInputStream (file);
int len = (int) file.length();
byte[] data = new byte[len];
int count, total = 0;
while ((count = input.read (data, total, len - total)) > 0) total += count;
return data;
}
catch (Exception ex)
{
ex.printStackTrace();
}
finally
{
if (input != null) try
{
input.close();
}
catch (Exception ex)
{
ex.printStackTrace();
}
}
return null;
}
Voici la solution de travail pour lire le fichier entier en morceaux et sa solution efficace pour lire les gros fichiers en utilisant une classe de scanner.
try {
FileInputStream fiStream = new FileInputStream(inputFile_name);
Scanner sc = null;
try {
sc = new Scanner(fiStream);
while (sc.hasNextLine()) {
String line = sc.nextLine();
byte[] buf = line.getBytes();
}
} finally {
if (fiStream != null) {
fiStream.close();
}
if (sc != null) {
sc.close();
}
}
}catch (Exception e){
Log.e(TAG, "Exception: " + e.toString());
}