精华内容
下载资源
问答
  • 下面小编就为大家带来一篇读取Java文件到byte数组的三种方法(总结)。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • BufferedInputStream in = new BufferedInputStream(new FileInputStream("f:/2.jpg"));  ByteArrayOutputStream out = new ByteArrayOutputStream(1024);     byte[] temp = new byte[10
    BufferedInputStream in = new BufferedInputStream(new FileInputStream("f:/2.jpg"));
            ByteArrayOutputStream out = new ByteArrayOutputStream(1024);    
           
            byte[] temp = new byte[1024];        
            int size = 0;        
            while ((size = in.read(temp)) != -1) {        
                out.write(temp, 0, size);        
            }        
            in.close();  
            byte[] content = out.toByteArray();  
    展开全文
  • 转载自 Java 文件和byte数组转换/** * 获得指定文件的byte数组 */ private byte[] getBytes(String filePath){ byte[] buffer = null; try { File file = new File(filePath); ...

    转载自   Java 文件和byte数组转换

    /** 
         * 获得指定文件的byte数组 
         */  
        private byte[] getBytes(String filePath){  
            byte[] buffer = null;  
            try {  
                File file = new File(filePath);  
                FileInputStream fis = new FileInputStream(file);  
                ByteArrayOutputStream bos = new ByteArrayOutputStream(1000);  
                byte[] b = new byte[1000];  
                int n;  
                while ((n = fis.read(b)) != -1) {  
                    bos.write(b, 0, n);  
                }  
                fis.close();  
                bos.close();  
                buffer = bos.toByteArray();  
            } catch (FileNotFoundException e) {  
                e.printStackTrace();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
            return buffer;  
        }
        
        /** 
         * 根据byte数组,生成文件 
         */  
        public static void getFile(byte[] bfile, String filePath,String fileName) {  
            BufferedOutputStream bos = null;  
            FileOutputStream fos = null;  
            File file = null;  
            try {  
                File dir = new File(filePath);  
                if(!dir.exists()&&dir.isDirectory()){//判断文件目录是否存在  
                    dir.mkdirs();  
                }  
                file = new File(filePath+"\\"+fileName);  
                fos = new FileOutputStream(file);  
                bos = new BufferedOutputStream(fos);  
                bos.write(bfile);  
            } catch (Exception e) {  
                e.printStackTrace();  
            } finally {  
                if (bos != null) {  
                    try {  
                        bos.close();  
                    } catch (IOException e1) {  
                        e1.printStackTrace();  
                    }  
                }  
                if (fos != null) {  
                    try {  
                        fos.close();  
                    } catch (IOException e1) {  
                        e1.printStackTrace();  
                    }  
                }  
            }  
        }  

    展开全文
  • Java获取文件的byte数组数据

    千次阅读 2019-04-09 19:17:55
    Java获取文件的byte数组数据 public static byte[] getFileByteArray(File file) { long fileSize = file.length(); if (fileSize > Integer.MAX_VALUE) { System.out.println("file too big....

    Java获取文件的byte数组数据

    public static byte[] getFileByteArray(File file) {
            long fileSize = file.length();
            if (fileSize > Integer.MAX_VALUE) {
                System.out.println("file too big...");
                return null;
            }
            byte[] buffer = null;
            try (FileInputStream fi = new FileInputStream(file)) {
                buffer = new byte[(int) fileSize];
                int offset = 0;
                int numRead = 0;
                while (offset < buffer.length
                        && (numRead = fi.read(buffer, offset, buffer.length - offset)) >= 0) {
                    offset += numRead;
                }
                // 确保所有数据均被读取
                if (offset != buffer.length) {
                    throw new IOException("Could not completely read file "
                            + file.getName());
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
            return buffer;
        }
    
    展开全文
  • 如果一个二维数组有很多的元素是重复的,那么存储这个数组就比较废空间,可以用这个数组的稀疏数组,达到缩小数组规模的目的。 上面那个二维数组的稀疏数组如下图: 这个稀疏数组的第一行各个元素具体是什么含义,...
    1. 如果一个二维数组有很多的元素是重复的,那么存储这个数组就比较废空间,可以用这个数组的稀疏数组,达到缩小数组规模的目的。
      在这里插入图片描述
      上面那个二维数组的稀疏数组如下图:
      在这里插入图片描述
      这个稀疏数组的第一行各个元素具体是什么含义,图中已经标明。
      至于第二行和第三行各个元素的含义,我只拿第二行举例(第三行可以类比)。
    • 第二行第3个元素:代表原数组中的元素“1”
    • 第二行第1个元素:元素“1”的行号索引,索引从0开始
    • 第二行第2个元素:元素“1”的列号索引,索引从0开始
      总之,第二行元素的含义,用一句话来讲,就是元素“1”在原数组中的第2行第3列(因为索引从0开始,也就是1+1行,2+1列)。
    1. 搞明白了稀疏数组的含义,那么,有两个任务去做
    • 原始数组→稀疏数组;
    • 稀疏数组→原始数组
      也就是在这两个数组之间进行转换。
      第一个任务相对复杂一点,第二个任务很简单。
    1. 下面是完整的代码,数组转换部分参考了教学视频,IO部分是教学视频给出的作业,自己随便写的,可能写得不好。
    package sparsearray;
    
    import java.io.BufferedReader;
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.FileReader;
    
    public class Demo2 
    {
    	public static void main(String[] args) throws Exception
    	{
    		//定义原始的数组
    		int [][] chessArray=new int[11][11];//元素的默认值是0
    		chessArray[1][2]=1;//黑色的棋子
    		chessArray[2][3]=2;	//蓝色的棋子
    		for (int[] is : chessArray)
    		{
    			for (int a : is) 
    			{
    				System.out.print(a+"\t");
    			}
    			System.out.println();
    		}
    		
    		int sum=0;//总共有多少个不同的值
    		for (int i = 0; i < chessArray.length; i++) //chessArray.length其实是二维数组的行数
    		{
    			for (int j = 0; j < chessArray.length; j++) //遍历一行,也就是一维数组,这里行数和列数相等,所以可以用chessArray.length
    			{
    				if(chessArray[i][j]!=0)
    				{
    					sum++;
    				}
    			}
    		}
    		
    		//定义一个稀疏数组
    		int [][] sparseArray=new int[sum+1][3];//稀疏数组的列数是固定的“3”
    		//给稀疏数组的元素赋值
    		sparseArray[0][0]=11;
    		sparseArray[0][1]=11;
    		sparseArray[0][2]=sum;
    		int count=0;
    		for (int i = 0; i < 11; i++) 
    		{
    			for (int j = 0; j < 11; j++) 
    			{
    				if(chessArray[i][j]!=0)
    				{
    					count++;
    					sparseArray[count][0]=i;
    					sparseArray[count][1]=j;
    					sparseArray[count][2]=chessArray[i][j];
    				}
    			}
    		}
    		
    		System.out.println("-----------------------------");
    		System.out.println("稀疏数组:");
    		//打印被赋值之后的稀疏数组
    		for (int[] is : sparseArray) 
    		{
    			for ( int s2 : is) 
    			{
    				System.out.print(s2+"\t");
    			}
    			System.out.println();
    		}
    		System.out.println("-----------------------------");
    		System.out.println("把稀疏数组保存到文件中。。。");
    		FileOutputStream fileOutputStream=new FileOutputStream(new File("chess.txt"));
    		
    		for (int i = 0; i < sparseArray.length; i++) 
    		{
    			for (int j = 0; j < 3; j++) 
    			{
    				int a=sparseArray[i][j];
    				if(j==2)//如果是最后一列就不加逗号
    				{
    					fileOutputStream.write((String.valueOf(a)).getBytes());
    				}
    				else //否则就加逗号
    				{
    					fileOutputStream.write((String.valueOf(a)+",").getBytes());
    				}
    			}
    			fileOutputStream.write("\n".getBytes());
    		}
    		System.out.println("------------------");
    		System.out.println("读取文件中的稀疏数组并恢复成原来的数组:");
    		
    		BufferedReader bufferedReader=new BufferedReader(new FileReader("chess.txt"));//字符缓冲流
    		String line=null;
    		int c=0;
    		String row=null;
    		String col=null;
    		int [][] chessRestore=null;
    		while((line=bufferedReader.readLine())!=null)
    		{
    			c++;
    			if(c==1)//如果是稀疏矩阵的第一行
    			{
    				String [] array=line.split(",");
    				row=array[0];
    				col=array[1];
    				chessRestore=new int[Integer.parseInt(row)][Integer.parseInt(col)];
    			}
    			else 
    			{
    				String [] array=line.split(",");
    				String hang=array[0];
    				String lie=array[1];
    				String val=array[2];
    				chessRestore[Integer.parseInt(hang)][Integer.parseInt(lie)]=Integer.parseInt(val);
    			}
    			
    			
    		}
    		
    		for (int[] is : chessRestore) 
    		{
    			for (int is2 : is) 
    			{
    				System.out.print(is2+"\t");
    			}
    			System.out.println();
    		}
    		
    		
    		
    	}
    
    }
    
    
    1. 运行结果:
      在这里插入图片描述
      之所以要把稀疏数组保存到文件中,是因为五子棋游戏要求有存档的功能,肯定要把棋盘保留下来。
    展开全文
  • Java IO之字节数组流

    2019-05-05 16:00:48
    字节数组流: 基于内存操作,内部维护着一个字节数组,我们可以利用流的读取机制来处理字符串 无需关闭 无文件无关,借鉴流的一个一个字节读取的机制,来操作字符串 ByteArrayInputStream 包含一个内部...
  • java 获得指定文件的byte数组 ,根据byte数组,生成文件
  • Main.java 文件 public class Main { public static void main(String args[]) { String[][] data = new String[2][5]; System.out.println("第一维数组长度: " + data.length); System.out.println("第二维数组长度...
  • FileInputStream和FileOutputStream的源是文件,存在硬盘中,Java虚拟机不能直接去操作,要通过操作系统(OS),所以用完后要通知操作系统去释放资源(close方法) ByteArrayInputStream的是字节数组,在内存中,...
  • Java语言中提供的数组用来存储固定大小的同类型元素。 在Java中,数组也可以认为是一种数据类型,它本身是一种引用类型。Java数组可以存储基本类型的数据,也可以存储引用类型的数据。比如存储int类型: //首先声明...
  • } } } /** * Mapped File way MappedByteBuffer 可以在处理大文件时,提升性能 * * @param filename * @return * @throws IOException */ public static byte[] toByteArray3(String filename) throws ...
  • Java 实例 – 获取数组长度 1.返回顶部 Java 实例 - 获取数组长度 Java 实例 本文我们将为大家介绍如何使用数组的属性 length 来获取数组的长度。 以下实例中我们定义了二维数组,并...
  • Java文件转为字节数组

    千次阅读 2016-12-22 11:44:00
    关键字:文件文件流,字节,字节数组,二进制 摘要:最近工作中碰到的需求是,利用http传输二进制数据到服务器对应接口,需要传输userId, file(加密后)等一系列混合后的二进制数据。本文旨在记录自己在使用Java...
  • Java 字节数组流

    2021-07-17 20:56:41
    字节数组流,即向内存数组读/取数据,实现数据在流与流之间的传递。 与字节流别无二致。 ByteInputStream: package SAMPLE.IO流; import java.io.*; /*文件 字节数组输入流 1、确定源:字节数组,不要太大 ...
  • 下面小编就为大家带来一篇Java 图片与byte数组互相转换实例。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 稀疏数组介绍:对于一个数组,大部分的元素都为同一个值。从节约空间的角度,可以用一个较小的数组只存储特定的几个值及这几个值的索引,这就是稀疏数组。 稀疏数组的实现很简单: 稀疏数组的第一行记录原始数组的...
  • java怎么接收js 数组对象数组对象[2021-02-04 22:25:34]简介:php数组转js数组对象的方法:首先获取【$arr】数组;然后使用函数【json_encode()】将数组每一个值进行json编码,;接着输出一个json的数组;最后使用arr...
  • import java.io.BufferedInputStream; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOExceptio
  • 场景:将五子棋盘(二维数组)中,有效的数据保存到稀疏数组中并将稀疏数组保存到本地文件。然后将读取文件中的数据,并将数据转换成二维数组。 因为五子棋该二维数组中有很多值是默认值 0, 因此记录了很多没有意义...
  • Java字节数组流操作

    2020-02-14 17:12:24
    了解Java字节数组流操作之前需要明白的东西: 之前学习的源头都是文件,FileInputStream,FileOutputStream,FileReader,FileWriter。 文件是存储在硬盘上的,我们的Java虚拟机无权访问的,我们必须借助于操作系统...
  • 方法获取不到对应的数组,打印的长度总是0。 我也是第一次写这东西,后来一网友说试试remote被动模式,我不知道还和这个连接模式有关系...... 原来只需要在创建连接对象的时候加上ftpClient....
  • log.warn("文件下载失败:{}", message); throw new IllegalArgumentException(JSON.parseObject(message).getString("message")); } return EntityUtils.toByteArray(httpResponse.getEntity()); } }
  • 根据文件行数创建对应的数组 array = new int[strList.size()][columnNum]; //13.记录输出当前行 int count = 0; //14.循环遍历集合,将集合中的数据放入数组中 for(String str : strList) { //...
  • package IO流_其他流_字节数组流; import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.File;...
  • 一、S02E156_01IO_其他流_字节数组流 二、S02E157_01IO_其他流_字节数组流、与文件流对接
  • 数组中的数据称为数组元素,我们使用索引来标识数组元素在数组中的存储位置,索引从0开始,步长是1,其后的索引依次递增: ​ 其中,数据类型包括以下两种: 基本数据类:byte,short,int,long,float,double,c...
  • java快速获取文件内容、java文件转byte[]数组、byte[]数组转String字符串并设置编码格式 private static final int CACHE_SIZE = 1024; public static byte[] fileToBytes(File file) throws Exception{ byte[] ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 347,057
精华内容 138,822
关键字:

java获取文件流数组

java 订阅