转换流

由于字节流操作中文不是特别方便，所以java中提供了转换流

编码表：由现实世界的字符和对应的数值组成的一张表

编码：把看得懂的变成看不懂的(String-------byte[])

解码：把看不懂的变成看得懂的(byte[]-------String)

  • String-----bytes[]
  1. import java.util.Arrays;
  2. import java.io.UnsupportedEncodingException;
  3. public class StringDemo{
  4. 	public static void main(String[] args)throws UnsupportedEncodingException{
  5. 		String s = "你好";
  7. 		//String-----bytes[]
  8. /*
  9. 		byte[] bys = s.getBytes();//将字符串转换成字节数组
  10. 		System.out.println(Arrays.toString(bys));//输出结果：[-28, -67, -96, -27, -91, -67]
  11. */
  13. /*
  14. 		byte[] bys = s.getBytes("GBK");//指定编码方式
  15. 		System.out.println(Arrays.toString(bys));//输出结果：[-60, -29, -70, -61]
  16. */
  18. 		byte[] bys = s.getBytes("utf-8");
  19. 		System.out.println(Arrays.toString(bys));//输出结果：[-28, -67, -96, -27, -91, -67]
  21. 	}
  22. }
  • bytes[]-----String
  1. import java.io.UnsupportedEncodingException;
  2. public class StringDemo{
  3. 	public static void main(String[] args)throws UnsupportedEncodingException{
  4. 		String s = "你好";
  6. 	//	byte[] bys = s.getBytes();//默认是utf-8编码
  7. 		byte[] bys = s.getBytes("utf-8");
  9. 		//byte[] ---Sttring
  10. //		String ss = new String(bys);//utf-8编码的，utf-8解码的
  11. //		System.out.println(ss);//转换成字符串;输出结果是你好
  13. 		String ss = new String(bys,"GBK");//utf-8编的,GBK解码的
  14. 		System.out.println(ss);//输出结果是：浣犲ソ
  16. 	}
  17. }

OutputStreamWriter


  2. OutputStreamWriter(OutputStream out) :使用默认编码把字节流的数据转换为字符流
  3. OutputStreamWriter(OutputStream out, String charseName)：根据指定编码把字节流数据转换成字符流

OutputStreamWriter(或FileWriter)写数据

  1. public void write(int c):写一个字符
  2. public void write(char[] cbuf):写一个字符数组
  3. public void write(char[] cbuf,int off,int len):写一个字符数组的一部分
  4. public void write(String str):写一个字符串
  5. public void write(String str,int off,int len):写一个字符串的一部分

代码练习

  1. import java.io.FileOutputStream;
  2. import java.io.OutputStreamWriter;
  3. import java.io.IOException;
  5. public class OutputStreamWriteDemo{
  6. 	public static void main(String[] args)throws IOException{
  7. 		//创建对象
  8. 		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("/home/hadoop/a.txt"));
  10. /*
  11. 		//写数据
  12. 		//public void write(int c):写一个字符
  13. 		osw.write("\na\n");
  14. 		osw.write(87);
  16. */
  18. 		//public void write(char[] cbuf):写一个字符数组
  19. 		char[] chs = {'a','b','c','d'};//不能使用双引号？
  20. //		osw.write(chs);
  22. 		//public void write(char[] cbuf,int off,int len):写一个字符数组的一部分
  23. //		osw.write(chs,1,3);
  25. 		//public void write(String str):
  26. //		osw.write("自学java");
  28. 		//public void write(String str,int off, int len):写一个字符串的一部分
  29. 		osw.write("邬家栋自学java",3,6);
  31. 		osw.flush();
  32. 		osw.close();
  34. 	}
  35. }

InputStreamReader

  1. InputStreamReader(InputStream in) :用默认的编码读取数据
  2. InputStreamReader(InputStream in, String charsetName) :用指定的编码读取数据

InputStreamReader(或FileReader)读取数据

  1. int read():一次读取一个字符
  2. int read(char[] chs):一次读取一个字符数组

代码练习

  1. import java.io.FileInputStream;
  2. import java.io.InputStreamReader;
  3. import java.io.IOException;
  5. public class InputStreamReadDemo{
  6. 	public static void main(String[] args)throws IOException{
  7. 		//创建对象
  8. 		InputStreamReader isr = new InputStreamReader(new FileInputStream("/home/hadoop/javatest/IO/OutputStreamWriteDemo.java"));
  10. /*
  11. 		int ch = 0;
  12. 		while((ch = isr.read())!= -1){
  13. 			System.out.print((char)ch);
  14. 		}
  16. */
  18. 		//一次读取一个字符数组
  19. 		char[] chs = new char[1024];
  20. 		int len = 0;
  21. 		while((len = isr.read(chs)) != -1){
  22. 			System.out.print(new String(chs,0,len));
  23. 		}
  25. 		isr.close();
  27. 	}
  28. }

字符流读写数据（复制文本文件）

  1. import java.io.InputStreamReader;
  2. import java.io.OutputStreamWriter;
  3. import java.io.FileInputStream;
  4. import java.io.FileOutputStream;
  5. import java.io.IOException;
  7. public class CopyFileDemo{
  8. 	public static void main(String[] args)throws IOException{
  9. 		//封装数据源
  10. 		InputStreamReader isr = new InputStreamReader(new FileInputStream("/home/hadoop/a.txt"));
  11. 		//封装目的地
  12. 		OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("/home/hadoop/b.txt"));
  14. /*
  15. 		//方式一
  16. 		int ch = 0;
  17. 		while((ch = isr.read()) != -1){
  18. 			osw.write(ch);
  19. 		}
  20. */
  22. 		//方式二
  23. 		char[] chs = new char[1024];
  24. 		int len = 0;
  25. 		while((len = isr.read(chs)) != -1){
  26. 			osw.write(chs,0,len);
  27. 			osw.flush();
  29. 		}
  31. 		isr.close();
  32. 		osw.close();
  34. 	}
  35. }

字符缓冲流BufferedWriter写数据

  1. import java.io.BufferedWriter;
  2. import java.io.FileWriter;
  3. import java.io.IOException;
  4. import java.io.FileOutputStream;
  5. import java.io.OutputStreamWriter;
  7. public class BufferedWriterDemo{
  8. 	public static void main(String[] args)throws IOException{
  10. 		//BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("bw.txt")));
  11. 		BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
  13. 		bw.write("hello\n");
  14. 		bw.write("wujiadong\n");
  16. 		bw.close();
  18. 	}
  19. }

字符缓冲流BufferedReader读数据

  1. import java.io.BufferedReader;
  2. import java.io.FileReader;
  3. import java.io.IOException;
  5. public class BufferedReaderDemo{
  6. 	public static void main(String[] args)throws IOException{
  7. 		//创建字符缓冲输入流对象
  8. 		BufferedReader br = new BufferedReader(new FileReader("bw.txt"));
  10. /*
  11. 		//方式1
  12. 		int ch = 0;
  13. 		while((ch = br.read()) != -1){
  14. 			System.out.print((char) ch);
  15. 		}
  16. */
  18. 		//方式2
  19. 		char[] chs = new char[1024];
  20. 		int len = 0;
  21. 		while((len = br.read(chs)) != -1){
  22. 			System.out.print(new String(chs,0,len));
  23. 		}
  25. 		br.close();
  26. 	}
  27. }

字符缓存流复制文件

  1. import java.io.BufferedReader;
  2. import java.io.BufferedWriter;
  3. import java.io.FileReader;
  4. import java.io.FileWriter;
  5. import java.io.IOException;
  7. public class CopyFileDemo{
  8. 	public static void main(String[] args)throws IOException{
  9. 		//
  10. 		BufferedReader br = new BufferedReader(new FileReader("a.txt"));
  12. 		BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
  14. 		//方式1
  15. 		//方式2
  16. 		char[] chs = new char[1024];
  17. 		int len = 0;
  18. 		while((len = br.read(chs)) != -1){
  19. 			bw.write(chs,0,len);
  21. 		}
  23. 		br.close();
  24. 		bw.close();
  25. 	}
  26. }

特殊功能（一次读一行）

  • readLine(): 无换行符
  • newline(): 换行
  1. import java.io.BufferedWriter;
  2. import java.io.FileWriter;
  3. import java.io.IOException;
  4. import java.io.BufferedReader;
  5. import java.io.FileReader;
  7. public class BufferedDemo{
  8. 	public static void main(String[] args)throws IOException{
  9. 	//	write();
  10. 		read();
  11. 	}
  13. 	public static void read()throws IOException{
  14. 		BufferedReader br = new BufferedReader(new FileReader("bw2.txt"));
  16. 		String line = null;
  17. 		while((line = br.readLine()) != null){
  18. 			System.out.println(line);
  19. 		}
  21. 		br.close();
  23. 	}
  25. 	public static void write() throws IOException{
  26. 		BufferedWriter bw = new BufferedWriter (new FileWriter("bw2.txt"));
  28. 		for(int i=0;i<10;i++){
  29. 			bw.write("wujiadong");
  30. 			bw.newLine(); //换行
  31. 			bw.flush();
  32. 		}
  34. 		bw.close();
  35. 	}
  37. }

复制文件

  1. import java.io.BufferedReader;
  2. import java.io.BufferedWriter;
  3. import java.io.IOException;
  4. import java.io.FileReader;
  5. import java.io.FileWriter;
  7. public class CopyFileDemo1{
  8. 	public static void main(String[] args)throws IOException{
  9. 		//封装数据源
  10. 		BufferedReader br = new BufferedReader(new FileReader("CopyFileDemo.java"));
  12. 		//封装目的地
  13. 		BufferedWriter bw = new BufferedWriter(new FileWriter("bw3.txt"));
  15. 		String line = null;
  16. 		while((line = br.readLine()) != null){
  17. 			bw.write(line);
  18. 			bw.newLine();
  19. 			bw.flush();
  20. 		}
  22. 		br.close();
  23. 		bw.close();
  24. 	}
  25. }

练习1：复制文本文件

  1. import java.io.FileReader;
  2. import java.io.FileWriter;
  3. import java.io.IOException;
  5. import java.io.BufferedReader;
  6. import java.io.BufferedWriter;
  8. public class CopyFileDemo{
  9. 	public static void main(String[] args)throws IOException{
  10. 		String srcString = "bw3.txt";
  11. 		String desString = "wu.txt";
  13. //		method1(srcString,desString);
  14. // 		method2(srcString,desString);
  15. //		method3(srcString,desString);
  16. //		method4(srcString,desString);
  17. 		method5(srcString,desString);
  19. 	}
  21. 	//字符缓存流一次读写一个字符串
  22. 	private static void method5(String srcString,String desString)throws IOException{
  23. 		BufferedReader br = new BufferedReader(new FileReader(srcString));
  24. 		BufferedWriter bw = new BufferedWriter(new FileWriter(desString));
  26. 		String line = null;
  27. 		while((line = br.readLine()) != null){
  28. 			bw.write(line);
  29. 			bw.newLine();
  30. 			bw.flush();
  31. 		}
  33. 		br.close();
  34. 		bw.close();
  35. 	}
  37. 	//字符缓存流一次读写一个字符数组
  38. 	private static void method4(String srcString,String desString)throws IOException{
  39. 		BufferedReader br = new BufferedReader(new FileReader(srcString));
  40. 		BufferedWriter bw = new BufferedWriter(new FileWriter(desString));
  42. 		char[] ch = new char[1024];
  43. 		int len = 0;
  44. 		while((len = br.read(ch)) != -1){
  45. 			bw.write(ch);
  46. 		}
  48. 		br.close();
  49. 		bw.close();
  50. 	}
  52. 	//字符缓冲流一次读写一个字符
  53. 	private static void method3(String srcString,String desString)throws IOException{
  54. 		BufferedReader fr = new BufferedReader(new FileReader(srcString));
  55. 		BufferedWriter fw = new BufferedWriter(new FileWriter(desString));
  57. 		int ch = 0;
  58. 		while((ch = fr.read()) != -1){
  59. 			fw.write(ch);
  60. 		}		
  62. 		fr.close();
  63. 		fw.close();
  65. 	}
  67. 	//基本字符流一次读取一个字符数组
  68. 	private static void method2(String srcString,String desString)throws IOException{
  69. 		FileReader fr = new FileReader(srcString);
  70. 		FileWriter fw = new FileWriter(desString);
  72. 		char[] ch = new char[1024];
  73. 		int len = 0;
  74. 		while((len = fr.read(ch)) != -1){
  75. 			fw.write(ch, 0 ,len);
  76. 		}
  78. 		fr.close();
  79. 		fw.close();
  80. 	}
  82. 	//基本字符流一次读写一个字符
  83. 	private static void method1(String srcString,String desString)throws IOException{
  84. 		FileReader fr = new FileReader(srcString);
  85. 		FileWriter fw = new FileWriter(desString);
  87. 		int ch = 0;
  88. 		while((ch = fr.read()) != -1){
  89. 			fw.write(ch);
  90. 		}
  92. 		fr.close();
  93. 		fw.close();
  94. 	}
  95. }

练习2：复制非文本文件的4种方法

  1. import java.io.File;
  2. import java.io.FileInputStream;
  3. import java.io.FileOutputStream;
  4. import java.io.IOException;
  6. import java.io.BufferedInputStream;
  7. import java.io.BufferedOutputStream;
  9. public class CopyImageDemo{
  10. 	public static void main(String[] args)throws IOException{
  11. 		//使用字符串作为路径
  12. //		String srcFile = "1.jpg";
  13. //		String desFile = "/home/hadoop/javatest/1.jpg";
  15. 		//使用File对象作为参数
  16. 		File srcFile = new File("/home/hadoop/1.jpg");
  17. 		File desFile = new File("/home/hadoop/javatest/1.jpg");
  19. //		method1(srcFile,desFile);
  20. //		method2(srcFile,desFile);
  21. //		method3(srcFile,desFile);
  22. 		method4(srcFile,desFile);
  23. 	}
  25. 	//基本字节流一次读取一个字节
  26. 	public static void method1(File srcFile,File desFile)throws IOException{
  27. 		FileInputStream fis = new FileInputStream(srcFile);
  28. 		FileOutputStream fos = new FileOutputStream(desFile);
  30. 		int by = 0;
  31. 		while((by = fis.read()) != -1){
  32. 			fos.write(by);
  33. 		}
  35. 		fis.close();
  36. 		fos.close();
  37. 	}
  39. 	//基本字节流一次读写一个字节数组
  40. 	public static void method2(File srcFile,File desFile)throws IOException{
  41. 		FileInputStream fis = new FileInputStream(srcFile);
  42. 		FileOutputStream fos = new FileOutputStream(desFile);
  44. 		byte[] by = new byte[1024];
  45. 		int len = 0;
  46. 		while((len = fis.read(by)) != -1){
  47. 			fos.write(len);
  48. 			fos.flush();
  49. 		}
  51. 		fis.close();
  52. 		fos.close();
  54. 	}	
  56. 	public static void method3(File srcFile,File desFile)throws IOException{
  57. 		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
  58. 		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desFile));
  60. 		int by = 0;
  61. 		while((by = bis.read()) != -1){
  62. 			bos.write(by);
  63. 		}
  65. 		bis.close();
  66. 		bos.close();
  67. 	}
  69. 	//字节缓冲流一次读取一个字节数组
  70. 	public static void method4(File srcFile,File desFile)throws IOException{
  71. 		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(srcFile));
  72. 		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(desFile));
  74. 		byte[] by = new byte[1024];
  75. 		int len = 0;
  76. 		while((len = bis.read()) != -1){
  77. 			bos.write(by);
  78. 			bos.flush();
  79. 		}
  81. 		bis.close();
  82. 		bos.close();
  84. 	}
  86. }

练习3：将集合中的数据存储到文本文件

  1. /*
  2.  * 需求：将ArrayList集合中的字符串数据存储到文本文件
  3.  *
  4.  */
  5. import java.util.ArrayList;
  6. import java.io.BufferedWriter;
  7. import java.io.IOException;
  8. import java.io.FileWriter;
  10. public class ArrayListToFileDemo{
  11. 	public static void main(String[] args)throws IOException{
  12. 		//创建集合对象
  13. 		ArrayList<String> array = new ArrayList<String>();
  15. 		array.add("java");
  16. 		array.add("python");
  17. 		array.add("scala");
  19. 		//封装目的地
  20. 		BufferedWriter bw = new BufferedWriter(new FileWriter("/home/hadoop/wu.txt"));	
  22. 		//遍历集合
  23. 		for(String s:array){
  24. 			bw.write(s);
  25. 			bw.newLine();
  26. 		}
  28. 		bw.close();
  29. 	}
  30. }

练习4：把文本文件的数据存储到集合

  1. /*
  2.  * 需求：从文本文件中读取数据（一行为一个字符串数据）到集合中,并遍历集合
  3.  *
  4.  *
  5.  */
  6. import java.util.ArrayList;
  7. import java.io.BufferedReader;
  8. import java.io.FileReader;
  9. import java.io.IOException;
  11. public class FileToArrayListDemo{
  12. 	public static void main(String[] args)throws IOException{
  13. 		//封装数据源
  14. 		BufferedReader br = new BufferedReader(new FileReader("/home/hadoop/wu.txt"));
  16. 		//封装目的地
  17. 		ArrayList<String> array = new ArrayList<String>();
  19. 		//读取数据存储到集合中
  20. 		String line = null;
  21. 		while((line = br.readLine()) != null){
  22. 			array.add(line);
  23. 		}
  25. 		br.close();
  27. 		//遍历集合
  28. 		for(String s:array){
  29. 			System.out.println(s);
  30. 		}
  31. 	}
  32. }

练习5：

  1. /*
  2.  * 需求：有一个文本文件存储了几个名称，写一个程序实现随机获取一个人的名字
  3.  *
  4.  */
  5. import java.io.BufferedReader;
  6. import java.io.FileReader;
  7. import java.io.IOException;
  8. import java.util.ArrayList;
  9. import java.util.Random;
  11. public class GetName{
  12. 	public static void main(String[] args)throws IOException{
  13. 		//把文本文件的数据存储到集合中
  14. 		BufferedReader br = new BufferedReader(new FileReader("/home/hadoop/wu.txt"));
  15. 		ArrayList<String> array = new ArrayList<String>();
  17. 		String line = null;
  18. 		while((line = br.readLine()) != null){
  19. 			array.add(line);
  20. 		}
  22. 		br.close();
  24. 		//产生一个随机索引
  25. 		Random r = new Random();
  26. 		int index = r.nextInt(array.size());
  28. 		//根据该索引获取一个值
  29. 		String name = array.get(index);
  30. 		System.out.println("幸运者是："+name);
  32. 	}
  33. }

练习6：复制单级文件夹


  2. import java.io.File;
  4. import java.io.BufferedInputStream;
  5. import java.io.BufferedOutputStream;
  6. import java.io.IOException;
  7. import java.io.FileInputStream;
  8. import java.io.FileOutputStream;
  10. public class CopyFolderDemo{
  11. 	public static void main(String[] args)throws IOException{
  12. 		//封装目录
  13. 		File srcFolder = new File("/home/hadoop/javatest/IO");
  14. 		File desFolder = new File("/home/hadoop/wu_test");
  16. 		//如果目的地文件夹不存在就创建
  17. 		if(!desFolder.exists()){
  18. 			desFolder.mkdir();
  19. 		}
  21. 		//获取该目录下的所有文本的File数组
  22. 		File[] fileArray = srcFolder.listFiles();
  24. 		//遍历该File数组，得到么一个File对象
  25. 		for(File file:fileArray){
  26. 			//System.out.println(file);
  27. 			//数据源：/home/hadoop/javatest
  28. 			//目的地：/home/hadoop/wu_test
  30. 			String name = file.getName();
  31. 			File newFile = new File(desFolder,name);
  33. 			copyFile(file,newFile);
  34. 		}
  35. 	}
  37. 	private static void copyFile(File file,File newFile)throws IOException{
  38. 		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file));
  39. 		BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(newFile));
  41. 		byte[] by = new byte[1024];
  42. 		int len = 0;
  43. 		while((len = bis.read(by)) != -1){
  44. 			bos.write(by,0,len);
  45. 		}
  47. 		bos.close();
  48. 		bis.close();
  50. 	}
  51. }

java基础11（IO流）-字符流的更多相关文章

  1. 【Java基础】【21IO(字符流)&字符流其他内容&递归】

    21.01_IO流(字符流FileReader) 1.字符流是什么 字符流是可以直接读写字符的IO流 字符流读取字符, 就要先读取到字节数据, 然后转为字符. 如果要写出字符, 需要把字符转为字节再写 ...

  2. java基础(23):字节流、字符流

    1. 字节流 在前面的学习过程中,我们一直都是在操作文件或者文件夹,并没有给文件中写任何数据.现在我们就要开始给文件中写数据,或者读取文件中的数据. 1.1 字节输出流OutputStream Out ...

  3. JAVA基础之字节流与字符流

    个人理解: IO流就是将数据进行操作的方式,因为编码的不同,所以对文件的操作就产生两种.最好用字节流,为了方便看汉字等,(已经确定文字的话)可以使用字符流.每个流派也就分为输入和输出,这样就可以产生复 ...

  4. Java基础：IO流之字节流和字符流

    1. 流的概念 流(stream)的概念源于UNIX中管道(pipe)的概念.在UNIX中,管道是一条不间断的字节流,用来实现程序或进程间的通信,或读写外围设备.外部文件等. 一个流,必有源端和目的端 ...

  5. java基础之IO流（二）之字符流

    java基础之IO流(二)之字符流 字符流,顾名思义,它是以字符为数据处理单元的流对象,那么字符流和字节流之间的关系又是如何呢? 字符流可以理解为是字节流+字符编码集额一种封装与抽象,专门设计用来读写 ...

  6. java基础之IO流（一）字节流

    java基础之IO流(一)之字节流 IO流体系太大,涉及到的各种流对象,我觉得很有必要总结一下. 那什么是IO流,IO代表Input.Output,而流就是原始数据源与目标媒介的数据传输的一种抽象.典 ...

  7. Java基础之IO流整理

    Java基础之IO流 Java IO流使用装饰器设计模式,因此如果不能理清其中的关系的话很容易把各种流搞混,此文将简单的几个流进行梳理,后序遇见新的流会继续更新(本文下方还附有xmind文件链接) 抽 ...

  8. Java IO: 其他字符流(下)

    作者: Jakob Jenkov 译者: 李璟(jlee381344197@gmail.com) 本小节会简要概括Java IO中的PushbackReader,LineNumberReader,St ...

  9. Java IO流字符流简介及基本使用

    Java IO流字符流简介及常用字符流的基本使用 字符流分为输入字符流(Writer)和输出字符流(Reader),这两种字符流及其子类字符流都有自己专门的功能.在编码中我们常用的输出字符流有File ...

  10. java中OutputStream字节流与字符流InputStreamReader 每一种基本IO流BufferedOutputStream，FileInputStream，FileOutputStream，BufferedInputStream，BufferedReader，BufferedWriter，FileInputStream，FileReader，FileWriter，InputStr

    BufferedOutputStream,FileInputStream,FileOutputStream,BufferedInputStream,BufferedReader,BufferedWri ...

随机推荐

  1. jpofiler监控JVM

    1.官方下载地址,选择自己想要的版本 https://www.ej-technologies.com/download/jprofiler/version_92 2.分为linux服务端.window ...

  2. Disable Client Certificate Revocation (CRL) Check on IIS

    Disable Client Certificate Revocation (CRL) Check on IIS: REGISTRY  : HKLM\SYSTEM\CurrentControlSet\ ...

  3. SharePoint解决方案及开发系列(2)-ECM

    很多次跟客户做咨询及沟通的时候,客户都问SharePoint能做什么?是不是就是做文档管理?为什么要花那么多的钱没SharePoint?高大上? 我上家公司面试的时候,我的那个BOSS面试官有一个问题 ...

  4. 《从零开始学Swift》学习笔记（Day 50）——扩展计算属性、方法

    原创文章,欢迎转载.转载请注明:关东升的博客 可以在原始类型上扩展计算属性,包括实例计算属性和静态计算属性.添加计算属性的定义,与普通的计算属性的定义是一样的. 实例计算属性示例:在网络编程时,为了减 ...

  5. 【穿插】Python基础之文件、文件夹的创建，对上一期代码进行优化

    在上一期妹子图的爬虫教程中,我们将图片都保存在了代码当前目录下,这样并不便于浏览,我们应该将同一个模特的图片都放在一个文件夹中. 今天我们就简单讲一下Python下如何创建文件.文件夹,今后就可以用上 ...

  6. Java+selenium自动化测试基础

    Java+selenium maven配置 maven的配置,但还需要建立maven的本地库,修改apach-maven的setting.xml http://www.cnblogs.com/haoa ...

  7. EasyNVR智能云终端硬件与EasyNVR解决方案软件综合对比

    背景分析 互联网视频直播越来越成为当前视频直播的大势,对于传统的安防监控,一般都是局限于内网,无法成批量上云台.传统的海康和大华的平台虽然可以通过自身私有协议上云平台 集总管控,但是往往只是支持自身的 ...

  8. java 多种判断key是否在map中存在的方法

    java 中有时候会遇到判断传过来的map里是否包含了指定的key,我目前只发现两种办法,如果有其他方法欢迎补充 我添加上去: HashMap map = new HashMap(); map.put ...

  9. Directory和HashTable的区别

    1:单线程程序中推荐使用 Dictionary, 有泛型优势, 且读取速度较快, 容量利用更充分.2:多线程程序中推荐使用 Hashtable, 默认的 Hashtable 允许单线程写入, 多线程读 ...

  10. <2013 12 17> 专业技能

    Specialties: • Mechanical design modeling using Pro/ENGINEER and SolidWorks.• Robot control, path pl ...