精华内容
参与话题
问答
  • 文件和文件流

    千次阅读 2019-08-08 20:16:26
    文件和文件流 1. File类 Java.io.File类可以获取文件以及文件夹的一些基本的属性 常用的方法 文件名称,路径,大小,判断是否存在,删除,创建 // 创建一个文件对象(可以是文件,可以是文件夹) File file = new ...

    文件和文件流

    1. File类

    Java.io.File类可以获取文件以及文件夹的一些基本的属性
    常用的方法 文件名称,路径,大小,判断是否存在,删除,创建

    // 创建一个文件对象(可以是文件,可以是文件夹)
    		File file = new File("e:/java_text.txt");
    		// 基本属性
    		boolean canWriter = file.canWrite();
    		System.out.println("是否可写:" + canWriter);
    		boolean canRead = file.canRead();
    		System.out.println("是否可读:" + canRead);
    		long size = file.length(); // 常用
    		System.out.println("文件大小:" + size);
    		boolean isFile = file.isFile(); // 常用
    		System.out.println("是否是文件:" + isFile);
    		boolean isDirectory = file.isDirectory();
    		System.out.println("是否是文件夹:" + isDirectory);
    		String filename = file.getName(); // 常用
    		System.out.println("文件的名称:" + filename);
    		String absolutePath = file.getAbsolutePath(); // 常用
    		System.out.println("文件的绝对路径:" + absolutePath);
    		String filepath = file.getPath();
    		System.out.println("文件的绝对路径:" + filepath);
    		boolean isExists = file.exists(); // 常用
    		System.out.println("是否存在:" + isExists);
    		boolean isDelete = file.delete(); // 常用
    		System.out.println("是否已经被删除:" + isDelete);
    		boolean isCreate = file.createNewFile();
    		System.out.println("创建了没有:" + isCreate);
    
    

    File类的listFile获取文件夹下面的所有文件内容,可以通过递归调用的方法把某一个文件夹下的所有的文件查询出来

    // 测试文件目录的属性(递归遍历文件夹中所有的文件信息)
    	public static void testDirectoryDeme(File file) {
    		if (file.isDirectory()) {
    			File[] files = file.listFiles();
    			System.out.println("文件夹"+file.getName()+"有"+files.length+"个文件");
    			// 利用for遍历所有的文件
    			for (int i = 0; i < files.length; i++) {
    				File childFile = files[i];
    				if (childFile.isFile()) {
    					// 这是一个文件
    					System.out.println("\t这是一个文件:" + childFile.getName());
    				} else {
    					// 文件夹:继续递归调用
    					testDirectoryDeme(childFile);
    				}
    			}
    		} else {
    			// 这是一个文件
    			System.out.println("\t这是一个文件:" + file.getName());
    		}
    	}
    
    

    2. Files 和 paths是一个工具类,提供了对文件的基本功能的实现在java.nio包下面

    文件的创建,删除,判断是否存在,移动,拷贝. 因为提供了静态的方法,所以不需要创建对象直接调用方法即可
    
    // 如果文件不存在复制
    if (!Files.exists(Paths.get("e:/a/cart1.jpg"))) {
    	// java.nio.Files(文件的工具类) Paths(文件路径工具类)
    	Files.copy(Paths.get("e:/cart1.jpg"), Paths.get("e:/a/cart1.jpg"));
    }
    Files.move(Paths.get("e:/a/cart1.jpg"), Paths.get("e:/a/b/cart1" + ((int) (Math.random() * 100)) + ".jpg"));
    Files.delete(Paths.get("e:/cart1.jpg"));
    
    

    3. 文件流

    文件流的分类:
    根据功能分为:输入流(读取文件) 和 输出流(写入文件)
    根据操作内容:字符流(读取字符数组) 和 字节流(读取字节数组)
    字节输入流,字节输出流,字符输入流,字符输出流
    在这里插入图片描述
    使用字节流实现文件的读取

    //利用字节输入流实现文件的内容读取(inputStream 接口的  FileInputStream )
    	public static void testInputStream() throws Exception{
    		File file = new File("e:/a/file.txt");
    		InputStream is = new FileInputStream(file);
    		if(!file.exists()){
    			System.out.println("文件不存在");
    		}
    		//开始读取文件
    		byte[] temp_bytes = new byte[1024];
    		int size = 0;  //用于记录读取文件的字节个数,如果没有读取任何的内容返回-1
    		//因为文件不可能一次读取完毕,需要循环读取
    		do{ 
    			size =is.read(temp_bytes);
    			if(size!=-1){
    				String info = new String(temp_bytes,0,size,"GBK");
    				System.out.println("读取的内容是:" + info);
    			}
    		}while(size !=-1); 
    		//文件流是必须要关闭的(像水管子一样)
    		is.close(); 
    
    

    利用字节输出流实现文件的写入

    //利用字节输出流实现文件内容的写入(OutputStream 接口的FileOutputStream)
    	public static void testOuputStream() throws Exception{
    		File file = new File("e:/a/file_new.txt");
    		if(file.exists()){
    			file.createNewFile();
    		}
    		//文件写入
    		String info = "这就是我们要写入文件的内容";
    		//创建文件写入对象
    		OutputStream os = new FileOutputStream(file);
    		os.write(info.getBytes());
    		//写入完毕后,关闭
    		os.flush();  //清空缓存区
    		os.close();
    	}
    
    

    利用字节输入流和字节输出流实现文件的拷贝

    //利用字节输入输入输出流,实现文件的复制,为了防止文件名称重复,需要对文件名称重命名
    	public static void testCopy(String filepath) throws Exception
    	{
    		//创建文件对象
    		File file = new File(filepath);
    		//判断文件是否存在,且必须是一个文件而不能是一个文件夹
    		if(!file.exists())
    			throw new Exception("文件不存在");
    		if(file.isDirectory())
    			throw new Exception("只能拷贝文件,不能拷贝文件夹");
    		//默认目标地址就是e:/a 文件夹
    		
    		//开始拷贝
    		//创建一个文件输入流对象,读取文件的内容
    		InputStream is = new FileInputStream(file);
    		//创建一个文件输出流对象,写入文件的内容
    		String filename = getFileName(file.getName());
    		String targetpath="e:/a/"+filename;
    		OutputStream os = new FileOutputStream(targetpath);
    		//利用循环,边读取内容,边写入内容即可
    		byte[] temp_info = new byte[1024];  //利用临时数组保存读取的内容
    		int size = 0; //保存读取的字节个数,如果没有读取到内容返回-1
    		do{
    			//先读取
    			size = is.read(temp_info);
    			//判断是否读取到了文件的内容
    			if(size!=-1){
    				//写入文件
    				os.write(temp_info, 0, size);
    			}
    		}while(size!=-1);
    		
    		//关闭,先关闭输出流,后关闭输入流
    		os.flush();
    		os.close();
    		is.close();
    	}
    	//根据原有的文件名称获取新的文件名称
    	public static String getFileName(String fileName){
    		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddhhmmss");
    		//abc.mp4  ---abc_20190805164520.mp4
    		//根据.分别获取文件名称和扩展名
    		String[] name_infos = fileName.split("\\.");
    		//获取当前日期的字符串
    		Date date = new Date();
    		String dateStr = sdf.format(date);
    		 
    		return name_infos[0]+"_"+dateStr+"."+name_infos[1];
    	}
    
    

    重点是熟练使用FileInputStream 和FileOutputStream 的使用

    // 利用字节流复制某一个文件夹中的所有文件
    	public static void testCopyDirectory() throws Exception {
    		File file = new File("e:/file_source");
    		// 实现复制
    		// 创建文件输入输出流对象
    		InputStream is = null;
    		OutputStream os = null;
    		try {
    			// 遍历这个文件夹下的所有的文件信息
    			File[] files = file.listFiles();
    			for (int i = 0; i < files.length; i++) {
    				File childFile = files[i];
    				// 如果是一个文件就复制
    				if (childFile.isFile()) {
    					is = new FileInputStream(childFile);
    					// 根据原有的文件名称获取新的文件名称
    					String newFileName = getNewFileName(childFile.getName());
    					os = new FileOutputStream("e:/a/b/" + newFileName);
    					byte[] temp_info = new byte[1024];
    					int size = -1;
    					do {
    						// 先读取
    						size = is.read(temp_info);
    						// 后写入(写入的内容多去取决于读取的内容多少)
    						if (size != -1) {
    							os.write(temp_info, 0, size);
    						}
    					} while (size != -1);
    				}
    			}
    		} catch (Exception ex) {
    			throw new Exception(ex);
    		} finally {
    			if (os != null)
    				os.close();
    			if (is != null)
    				is.close();
    		}
    	}
    
    	// 根据原有的文件名称,获取新的文件名称
    	public static String getNewFileName(String oldFileName) {
    		// oldname :上机作业.docx newnmae : 上机作业_20180222.docx;
    		// 根据原有的文件名称获取文件名字和文件的类型
    		int index = oldFileName.lastIndexOf(".");
    		if (index == -1) {
    			return oldFileName;
    		}
    		// 获取文件名: 上机作业
    		String name = oldFileName.substring(0, index);
    		// 获取文件类型: docx
    		String type = oldFileName.substring(index + 1);
    		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddhhmmss");
    		Date date = new Date();
    		String formatstr = sdf.format(date);
    		// 上机作业_20180222.docx;
    		return name + "_" + formatstr + "." + type;
    	}
    
    

    使用对象输入输出流实现对象的序列化和反序列化

    public static void testObjectInputStream() throws Exception{
    		File file = new File("e:/a/stu.txt");
    		InputStream is = new FileInputStream(file);
    		ObjectInputStream ois = new ObjectInputStream(is);
    		List<Student>  stuList= (List<Student>)ois.readObject(); 
    		ois.close();
    		is.close();
    		
    		for(Student stu: stuList){
    			System.out.println(stu);
    		}
    	}
    	//对象序列化(实现JAVA对象的保存和读取 ObjectInputStream)
    	public static void testObjectOutputStream()  throws Exception{
    		Student stu3 = new Student("赵丽丽","女","河北廊坊");
    		stuList.add(stu3);
    		//把集合保存到文件中 
    		File file = new File("e:/a/stu.txt");
    		OutputStream os = new FileOutputStream(file);
    		ObjectOutputStream oos = new ObjectOutputStream(os);
    		oos.writeObject(stuList);
    		oos.flush();
    		oos.close();
    		os.close();
    		
    	}
    
    

    字符流的读取和写入(只能读取字符文件的信息)

    //使用字符流读取文件
    	public static void testReader() throws Exception{
    		//创建文件对象
    		File file = new File("e:/a/file.txt");
    		//创建字符输入流对象
    		Reader reader = new FileReader(file);
    		//创建字符输出流对象
    		File file2 = new File("e:/a/b/file_3.txt");
    		Writer writer = new FileWriter(file2);
    		char[] temp = new char[1000];
    		int size =0;
    		//通过循环边度编写
    		do{
    			size= reader.read(temp);  //读取字符内容
    			if(size!=-1)
    			{
    				writer.write(temp, 0, size);
    			}
    		}while(size!=-1);
    		//关闭
    		writer.flush();
    		writer.close();
    		reader.close();
    	}
    
    

    释放资源的新方法

    //新的关闭资源的方法
    		//try(  定义必须要关闭的对象; ){}catch(Exception ex){}; 
    		// 创建输出流对象
    		try(	OutputStream os = new FileOutputStream(FILE_PATH);
    				ObjectOutputStream oos = new ObjectOutputStream(os); ) {
    
    			oos.writeObject(stuList);
    		} catch (Exception e) {
    			throw new Exception(e);
    		} 
    
    

    4. 线程的状态

    初始状态(创建了对象)
    可运行状态(调用了start方法)
    运行状态(调用了run方法)
    阻塞状态 (调用了seleep,join,wait方法)
    终结状态 (运行完毕)
    在这里插入图片描述

    5. 线程的常用方法

    Start() 启动方法 表示线程进入了可运行状态
    Seleep(int) 随眠方法,当前线程进入阻塞状态,在一定时间以后苏醒
    Join() 方法 被调用者优先执行,执行完毕后当前线程在执行(阻塞的的是当前线程)
    Wait() 方法 当前线程进入阻塞状态,一直到对方唤醒自己才可以继续执行
    notifyAll()唤醒被阻塞的线程
    需要注意:wait(),notify()两个方法是Object类提供的

    package com.xja.sxnd.filedemo;
    public class ThreadDemo {
    
    	public static void main(String[] args) {
    		MyThread mt = new MyThread();
    		MyRunable mr = new MyRunable();
    		Thread thread = new Thread(mr);
    		mt.start();
    		thread.start();
    		for(int i = 0;i< 50;i++){
    			if(i == 20){
    				try{
    					//主线程执行到20的时候,先让第一个线程执行完毕,然后主线程在接着执行
    				mt.join(); 
    				}catch(Exception ex){
    					ex.printStackTrace();
    				}
    			}
    			System.out.println("主线程中的内容:" +i);
    		}	
    	}
    }
    class MyThread extends Thread
    { 
    	@Override
    	public void run() {
    		 for(int i =0;i< 50;i++){
    			 try{
    			 if(i==20)
    				 Thread.sleep(500); //停止运行0.5秒,时间到了以后自动执行
    			 }catch(Exception ex){
    				 ex.printStackTrace();
    			 }
    			 System.out.println("第一个线程的对象:" +i);
    		 }
    	}
    }
    class MyRunable implements Runnable{
    	@Override
    	public void run() {
    		 for(int i =0;i< 50;i++){
    			 System.out.println("第二个线程的对象:"+i);
    		 }
    	}	
    }
    
    

    .

    6. 线程的死锁

    如果两个线程同时调用对方线程的JOIN方法,互相希望对方先运行就会出现死锁的问题

    public class MyRunnable implements Runnable {
    	public Thread myThread;
    	@Override
    	public void run() {
    		try {
    			for (int i = 0; i < 100; i++) { 
    				Thread.sleep(10); 
    				if(i == 5){
    					System.out.println("MyRunnable运行到了5,也休息,让Thread先走");
    					myThread.join();
    				}
    				System.out.println("第二个线程:" + i);
    			}
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    	} 
    }
    
    public class MyThread extends Thread {
    	public Thread myRun;
    	@Override
    	public void run() {
    		try {
    			for (int i = 0; i < 10; i++) { 
    				Thread.sleep(10); 
    				
    				if(i==5){
    					System.out.println("Thread 运行到了5 就需要对方先走");
    					myRun.join();
    				}
    				System.out.println("第一个线程的内容:" + i);
    			}
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    	} 
    }
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		try { 
    			// 创建一个线程对象
    			MyThread myThread = new MyThread();
    			// 创建第二个线程
    			MyRunnable myRunn = new MyRunnable(); 
    			Thread thread = new Thread(myRunn); 
    			// 启动线程 启动线程不能直接调用run 只能调用start 
    			myThread.myRun = thread;
    			myRunn.myThread = myThread;
    			 
    			myThread.start();
    			thread.start();
    }
    
    

    7. 线程的同步

    StringBuilder和StringBuffer ArrayList 和vector HashMap 和HashTable

    当两个线程同时操作同一个对象的时候,因为两个线程互相影响对方的结果,导致数据不统一,这种现象称之为线程不同步
    例如:银行卡存取钱的问题。(两种方式操作一个账户)

    public class Card {
    	private int balance =500;
    	public void takeMoney(int money){
    		if(balance>money){
    			System.out.println("取钱之前的余额:" + balance); 
    			int temp_balance = balance - money;
    			balance = temp_balance;
    			System.out.println("取钱之后的余额:" + balance);
    		}
    	}
    	public void saveMoney(int money){
    		System.out.println("存钱之前的余额:" + balance); 
    		int temp_balance = balance + money;
    		balance = temp_balance;
    		System.out.println("存钱之后的余额:" + balance);	
    	}
    }
     
    public class ThreadDemo {
    	public static void main(String[] args) {
    		Card card = new Card();
    		MyThread mt = new MyThread(card);
    		MyRunable mr = new MyRunable(card);
    		Thread thread = new Thread(mr);
    		mt.start();
    		thread.start();
    		System.out.println("程序结束");
    	}
    }
    class MyThread extends Thread
    { 
    	private Card card;
    	public MyThread(Card card){
    		this.card = card;
    	}
    	@Override
    	public void run() { 
    		 for(int i =0;i< 10;i++){ 
    			 card.takeMoney(50);
    		 } 
    	} 
    }
    class MyRunable implements Runnable{
    	private Card card;
    	public MyRunable(Card card){
    		this.card = card;
    	}
    	@Override
    	public void run() { 
    		 for(int i =0;i< 10;i++){ 
    			card.saveMoney(50);
    		 } 
    	}	
    }
    
    

    通过synchronized关键字修饰方法就是线程同步的方法,线程同步的方法要求同一个对象同时只能调用一个方法

    public class Card {
    	private int balance = 500;
    	public void takeMoney(int money) {
    		synchronized (this) {
    			if (balance > money) {
    				System.out.println("取钱之前的余额:" + balance);
    				int temp_balance = balance - money;
    				balance = temp_balance;
    				System.out.println("取钱之后的余额:" + balance);
    			}
    		}
    	}
    
    	public void saveMoney(int money) {
    		synchronized (this) {
    			System.out.println("存钱之前的余额:" + balance);
    			int temp_balance = balance + money;
    			balance = temp_balance;
    			System.out.println("存钱之后的余额:" + balance);
    		}
    	}
    }
    
    

    8. 线程的经典案例(生产者和消费者)

    public class Card {
    	private int balance = 500;
    
    	public synchronized void takeMoney(int money) throws Exception {
    		if (balance -money<0) {
    			System.out.println("家里没有钱了,需要减少消费");
    			this.wait();
    			return;
    		}
    		System.out.println("取钱之前的余额:" + balance);
    		int temp_balance = balance - money;
    		balance = temp_balance;
    		System.out.println("取钱之后的余额:" + balance);
    
    		// 一旦我花费了钱,就可以让生成者继续生成
    		this.notify();
    	}
    
    	public synchronized void saveMoney(int money) throws Exception {
    		// 如果挣钱的足够,则需要休息,让消费者消费
    		if (balance > 700) {
    			System.out.println("钱以够多了,可以休息一下");
    			this.wait();
    			return;
    		}
    		System.out.println("存钱之前的余额:" + balance);
    		int temp_balance = balance + money;
    		balance = temp_balance;
    		System.out.println("存钱之后的余额:" + balance);
    		// 一旦有钱就可以让消费者消费
    		this.notifyAll();
    	}
    }
    
    
    展开全文
  • Java自动获取文件和文件流编码

    千次阅读 2017-07-26 14:50:12
    在读取文件时,如果不清楚文件编码或者在不同的编码环境拷贝文件,这时中文数据很可能会出现乱码,参考了博客:... * 检测文件的编码文本的编码 * 参考: http://blog.csdn.net/servermanage/article/details/8

    在读取文件时,如果不清楚文件编码或者在不同的编码环境拷贝文件,这时中文数据很可能会出现乱码,参考了博客:http://blog.csdn.net/servermanage/article/details/8595676,有了如下的代码:

    /**
     * 检测文件的编码和文本流的编码
     * 参考: http://blog.csdn.net/servermanage/article/details/8595676
     * @author Administrator
     *
     */
    public class CpdetectorUtils {
    	//获取文本编码
    	private static final String FILE_ENCODE_TYPE = "file";
    	//获取文件流编码
    	private static final String IO_ENCODE_TYPE = "io";
    	/** 
    	 * 获取探测到的文件对象
    	 * 
    	 * @param path
    	 *            要判断文件编码格式的源文件的路径
    	 */
    	private  CodepageDetectorProxy getDetector() {
    		/*
    		 * detector是探测器,它把探测任务交给具体的探测实现类的实例完成。
    		 * cpDetector内置了一些常用的探测实现类,这些探测实现类的实例可以通过add方法 加进来,如ParsingDetector、
    		 * JChardetFacade、ASCIIDetector、UnicodeDetector。
    		 * detector按照“谁最先返回非空的探测结果,就以该结果为准”的原则返回探测到的
    		 * 字符集编码。使用需要用到三个第三方JAR包:antlr.jar、chardet.jar和cpdetector.jar
    		 * cpDetector是基于统计学原理的,不保证完全正确。
    		 */
    		CodepageDetectorProxy detector = CodepageDetectorProxy.getInstance();
    		
    		/*
    		 * ParsingDetector可用于检查HTML、XML等文件或字符流的编码,构造方法中的参数用于
    		 * 指示是否显示探测过程的详细信息,为false不显示。
    		 */
    		detector.add(new ParsingDetector(false));
    		/*
    		 * JChardetFacade封装了由Mozilla组织提供的JChardet,它可以完成大多数文件的编码
    		 * 测定。所以,一般有了这个探测器就可满足大多数项目的要求,如果你还不放心,可以
    		 * 再多加几个探测器,比如下面的ASCIIDetector、UnicodeDetector等。
    		 */
    		detector.add(JChardetFacade.getInstance());// 用到antlr.jar、chardet.jar
    		// ASCIIDetector用于ASCII编码测定
    		detector.add(ASCIIDetector.getInstance());
    		// UnicodeDetector用于Unicode家族编码的测定
    		detector.add(UnicodeDetector.getInstance());
    		
    		return detector;
    	}
    	
    	/**
    	 * 根据"encodeType"获取文本编码或文件流编码
    	 */
    	public String getFileOrIOEncode(String path,String encodeType){
    		CodepageDetectorProxy detector = getDetector();
    		File file = new File(path);
    		Charset charset = null;
    		try {
    			switch (encodeType) {
    			case FILE_ENCODE_TYPE:
    				charset = detector.detectCodepage(file.toURI().toURL());
    				break;
    			case IO_ENCODE_TYPE:
    				charset = detector.detectCodepage(new BufferedInputStream(new FileInputStream(file)),128);//128表示读取128字节来判断文件流的编码,读得越多越精确,但是速度慢
    				break;
    			default:
    				charset = Charset.defaultCharset();
    				break;
    			}
    			
    		} catch (IOException e) {
    			//这里获取编码失败,使用系统默认的编码
    			charset = Charset.defaultCharset();
    			System.out.println(e.getMessage());
    		}
    		return charset.name();
    	}
    	
    	@Test
    	public void test(){
    		String path = "F:/DevelopmentSoftware/2016-04-18至2016-04-24记录.txt";
    		System.out.println("文件编码: " + getFileOrIOEncode(path, FILE_ENCODE_TYPE));
    		System.out.println("文件流编码: " + getFileOrIOEncode(path, IO_ENCODE_TYPE));
    	}
    	
    }

    测试结果如下:

    文件编码: GB2312
    文件流编码: GB2312

    尤其要注意在获取文件流编码时,重载方法detector.detectCodepage(new BufferedInputStream(new FileInputStream(file)),128);的第一个参数必须是包装的高级流,如果是FileInputStream会包参数异常错误.

    展开全文
  • 在开发项目中经常获取resources下的文件(配置文件及其他各种各样的文件),本文通过java代码获取其文件及输入; 主要用类加载器的两个重要方法 InputStream in = getClass().getClassLoader()....

    在开发项目中经常获取resources下的文件(配置文件及其他各种各样的文件),本文通过java代码获取其文件及输入流;

    主要用类加载器的两个重要方法

    • InputStream in = getClass().getClassLoader().getResourceAsStream("log4j.properties");// 获取文件的输入流
    • URL url = getClass().getClassLoader().getResource("log4j.properties");// 获取文件的URL

    一、通过类加载器获取资源文件的文件流,输入流的用途很多,看你自己怎么用都可以,如用在Properties获取配置信息,或者用来读图片,文本等等......例子:读取resources下的log4j配置文件信息;

    @Test
    public void testStream() throws IOException, URISyntaxException {
    	// 获取输入流
    	InputStream in = getClass().getClassLoader().getResourceAsStream("log4j.properties");
    	// 新建配置对象
    	Properties p = new Properties();
    	// 通过输入流加载
    	p.load(in);
    	// 读取key
    	String log4j = p.getProperty("log4j.rootLogger");
    	System.out.println(log4j);
    }

    运行后如下:

     

    、通过类加载器获取资源文件的URL,URL的用法也是更加强大,可用用URL对象干很多,比如生成File对象,等可查看URL的API,例子:读取resources下的log4j生成File对象

    @Test
    public void testStream() throws IOException, URISyntaxException {
    	// 获取URL
    	URL url = getClass().getClassLoader().getResource("log4j.properties");
    	// 通过url获取File的绝对路径
    	File f = new File(url.getFile());
    	System.out.println("文件的名子是:" + f.getName());
    	System.out.println("文件的大小是:" + f.length());
    }

    运行后如下:

    以上两个方法对于获取resources下的文件很有用途,多多利用,能幻化出多种用途,以后有关于获取路径及相对路径的内容继续更新(完)

    展开全文
  • 今天文件转码碰到个文件文件转码的时候抛出异常(conversion failed: input document is null after loading),从服务器当下文件查看,发现文件大小为6kb,文件内容为空,上传了其他文件测试发现转码正常,所以...

    今天文件转码碰到个文件:

    文件转码的时候抛出异常(conversion failed: input document is null after loading),

    从服务器当下文件查看,发现文件大小为6kb,文件内容为空,上传了其他文件测试发现转码正常,

    所以不是转码线程的问题,把问题定位到文件,

    新建了一个Excel文件,没有增加内容,文件大小正好是6kb,

    所以转码失败的原因是6kb是文件的大小而不是文件中数据流的大小,然后文件转码在读取数据流的时候,读取到的为null,所以就报错了;

    规避方法:

    1,在文件流读取之前判断文件流是否为null,如果是null则不执行转码操作(这里是用的ExecutorService的submit方法);

    2,在上传文件的接口处进行判断,如果文件数据流为null,则提示不能上传空文件等;

    展开全文
  • TS文件解码TS文件解密TS批量下载解码工具

    万次阅读 热门讨论 2018-05-21 11:02:15
    TS的全称则是Transport Stream,即传输,DVD节目中的MPEG2格式,是MPEG2-PS,MPEG2-TS格式的特点就是要求从视频的任一片段开始都是可以独立解码的。现主流视频网站都采用这种模式。 m3u8是一个TS切片列表文件...
  • 这几天在写STM32的ISP烧录工具,因此有涉及到输入hex文件或bin文件进行烧录的问题,所以对hex文件和bin文件进行了些总结。 1 hex介绍 Hex 全称 (Intel HEX)文件是由一行行符合Intel HEX文件格式的文本所构成的...
  • 调试往往不能一次成功,每次运行时,都要重新输入一遍测试数据,对于有大量输入数据的题目,输入数据需要花费大量时间。 使用freopen函数可以解决测试数据输入问题,避免重复输入,不失为一种简单而有效的解决方法...
  • 要在 C++ 中进行文件处理,必须在 C++ 源代码文件中包含头文件 。 1、打开文件 在从文件读取信息或者向文件写入信息之前,必须先打开文件。ofstream  fstream 对象都可以用来打开文件进行写操作,...
  • filefile文件流

    千次阅读 2016-07-20 12:13:29
    **io是程序中比较常用的功能,基本上涉及到文件上传下载的都要用到这功能,比如上传头像,上传附件等等。 对于一个java程序员来说,io也是必须掌握的,因此这里对比较常用的或者说曾经用过的方法进行简单的归纳...
  • C++流和文件流

    千次阅读 2010-08-12 01:09:00
    C++流和文件流收藏   在程序设计中,数据输入/输出(I/O)操作是必不可少的,C++语言的数据输入/输出操作是通过I/O流库来实现的。C++中把数据之间的传输操作称为流,流既可以表示数据从内存传送到...
  • 文件流和转换流乱码

    千次阅读 2017-04-18 10:33:38
    前言: 实际开发中经常会遇到文本类文件的读写或者是文件复制传输等等 如果这个时候搞不清楚使用什么样的就会乱码,复制后的文件...要用什么由你的文件的存储结构(字符文件还包括编码集)用途决定 /* *
  • java文件流和管道流

    千次阅读 2017-12-06 18:19:08
    文件流是指专门用于操作数据源中的文件的流,主要有FileInputStream、FileOutStream、FileReader、FileWriter四个类。管道流包括**字节流PipedInputStream类、PipedOutputStream类****字符流PipedReader类、...
  • C++流和文件流操作

    千次阅读 2012-10-22 16:40:01
    在程序设计中,数据输入/输出(I/O)操作是必不可少的,C++语言的数据输入/...在进行I/O操作时,首先是打开操作,使流和文件发生联系,建立联系后的文件才允许数据流入和流出,输入或输出结束后,使用关闭操作使文件与
  • 文件流和二进制流

    千次阅读 2014-11-13 23:31:11
    C语言读写文件有两种方式ASCII 二进制。现在举例说明: 内存中的字符或字符串都是文本模式(unicode编码存储,统一长度,定长码,方便) 内存中的其他变量都是以二进制编码存储 程序的代码以文本模式ASCII码...
  • 文件和IO

    千次阅读 2019-12-07 10:07:46
    IO文件和流 回顾 Collection |_____List (特点:有序的,可以重复) |___ArrayList (存储结构:数组) |___LinkedList (存储结构:链表) |___Vector 数组 |___Stack 数组(栈)先进后出 |_____...
  • File file = new File("e:/11.txt"); FileReader fileReader = new FileReader(file); FileInputStream fileInputStream = new FileInputStream(file); ...FileWriter fileWriter = new FileWriter("...
  • C++ 输入输出流之文件操作和文件流

    千次阅读 2013-12-01 18:46:23
    ASCII文件(文本文件或者字符文件):它的每个字节存放一个ASCII代码,代表一个字符(一一对应),易于阅读,方便显示打印。 例如:43,00000100 00000011 二进制文件(内部格式文件或字符文件):是把内存中的数据...
  • Java输入输出流和文件操作

    千次阅读 2015-06-23 14:46:45
    文件和流操作系统中的文件和目录概念文件与文件系统文件是信息的一种组织形式,是存储在外部存储介质上的具有标志名的一组相关信息集合。 文件系统用文件概念来组织和管理存放在各种介质上的信息。文件系统提供目录...
  • 文件读写和流

    千次阅读 2009-02-20 23:44:00
    是字节序列的抽象概念,或者说是计算机在处理文件或数据时产生的二进制序列。例如文件、输入/输出设备、内部进程通信管道或者 TCP/IP 套接字。Stream 类及其派生类提供这些不同类型的输入输出的一般视图,使...
  • 文件类型和流

    千次阅读 2006-06-30 22:42:00
    正如wolfsecond(自己很敬佩的一个同学)所说,每个人要有承认自己无知的勇气,这对程序员的灵魂是有好处的(不知道这句话是不是他的原创,但确实是我们每个人都应当努力做到的)。计算机的领域是如此之广,也许我们每个...
  • Java文件流关闭垃圾回收问题

    万次阅读 2011-05-09 10:18:00
      周末碰到一段代码,是关于Java IO的,代码中出现在一个多线程的系统中,其中一段代码在打开一个文件操作用完以后没有及时关闭,开始以为很快会出现打开文件太多或者导致内存溢出,但是在运行了很...
  • 文件输入流和输出详解

    千次阅读 2018-06-24 14:30:38
    按照流向划分为输入流和输出 输入:就是以程序为中心点,硬盘上的文件内容流入到程序中可以存储数据的东西中比如说数组,用read方法 输出:就是以程序为中心点,程序中的数组或者其他的可以存储数据的东西中...
  • ajax携带文件流和参数上传文件

    千次阅读 2018-05-05 09:51:25
    一、首先创建一个FormData();可以理解为form表单,请求方式为POST,内部封装ectype='Mutiparat/fromData'图片上传必须的类型。var formData = new FormData()... //获得文件上传的输入框的文件流formData.append('f...
  • 1. 文本文件的操作 直接 用文件流对象 的 > 来操作, cout>x,一样:  ofile 就是把 字符串 写入到 ofile对象关联的文件名中  ifile>>s ------> 就是从ifile关联的文件中读取一个单词(不一定是一个单词,就是遇到...
  • package com.cfkyit.io;import java.io.File;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOException;import java.io.In
  • c++之文件和流

    千次阅读 2018-02-09 10:44:12
    C++ 文件和流到目前为止,我们已经使用了 iostream 标准库,它提供了 cin 和 cout 方法分别用于从标准输入读取和向标准输出写入。本教程介绍如何从文件读取和向文件写入。这就需要用到 C++ 中另一个...
  • java字符 加密文件和解密文件

    千次阅读 2018-11-21 14:02:35
    准备一个文本文件(非二进制),其中包含ASCII码的字符中文字符。 设计一个方法 public static void encodeFile(File encodingFile, File encodedFile); 在这个方法中把encodingFile的内容进行加密,然后保存到...
  • 文件和流的区别

    2019-04-13 10:34:02
    以下的区别有助于澄清文件和流的差异。文件是一些具有永久存储及特定顺序的...正如除磁盘外存在多种后备存储一样,除文件流之外也存在多种流。例如,还存在网络流、内存流和磁带流等。(以上摘自MSDN) 我的理解...
  • 这里来分析那个拷贝文件更快点:import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import...

空空如也

1 2 3 4 5 ... 20
收藏数 50,378
精华内容 20,151
关键字:

文件和文件流