丶老邱

Java IO流经典练习题

本文对javaIO流的13道经典的练习题做解答，里面有详细的思路解析，做题时最好养成先写思路在编程的习惯。

一．练习的题目

（一）在电脑D盘下创建一个文件为HelloWorld.txt文件，判断他是文件还是目录，在创建一个目
录IOTest,之后将HelloWorld.txt移动到IOTest目录下去；之后遍历IOTest这个目录下的文
件

（二）递归实现输入任意目录，列出文件以及文件夹，效果看图

（三）递归实现列出当前工程下所有.java文件

（四）从磁盘读取一个文件到内存中，再打印到控制台

（五）在程序中写一个"HelloJavaWorld你好世界"输出到操作系统文件Hello.txt文件中

（六）拷贝一张图片，从一个目录到另外一个目录下(PS:是拷贝是不是移动)

（七）统计一个文件calcCharNum.txt（见附件）中字母'A'和'a'出现的总次数

（八）统计一个文件calcCharNum.txt（见附件）中各个字母出现次数：

A(8),B(16),C(10)...,a(12),b(10),c(3)....，括号内代表字符出现次数;

（九）统计一个文件calcCharNum2.txt（见附件）中各个字母出现次数：
A(8),B(16),C(10)...,a(12),b(10),c(3)....中(5),国(6)，括号内代表字符出现次数;

（十）使用随机文件流类RandomAccessFile将一个文本文件倒置读出。

（十一）编写一个Java应用程序，可以实现Dos中的type命令，并加上行号。

即将文本文件在控制台上显示出来，并在每一行的前面加上行号。

（十二）输入两个文件夹名称，将A文件夹内容全部拷贝到B文件夹，要求使用多线程来操作。

（十三）查看D盘中所有的文件和文件夹名称，并且使用名称升序降序，文件夹在前和文件夹在
后，文件大小排序等。

二．详细的解题过程

（一）第一题

 
             1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62 
           
              package com.xykj.lesson1;
             
              import java.io.File;
             
              import java.io.IOException;
             
              public class Test1 {
             
              	/**
             
              	 * 1. 在电脑D盘下创建一个文件为HelloWorld.txt文件，
             
              	 * 判断他是文件还是目录，再创建一个目录IOTest,
             
              	 * 之后将HelloWorld.txt移动到IOTest目录下去；
             
              	 * 之后遍历IOTest这个目录下的文件
             
              	 * 
             
              	 * 程序分析：
             
              	 * 1、文件创建使用File的createNewFile()方法
             
              	 * 2、判断是文件用isFile(),判断是目录用isDirectory
             
              	 * 3、创建目录用：mkdirs()方法
             
              	 * 4、移动文件用：renameTo
             
              	 * 5、遍历目录用：list（）方法获得存放文件的数组，foreach遍历的方法把文件打印出来
             
              	 * */
             
              	public static void main(String[] args) {
             
              		 //在电脑D盘下创建一个文件为HelloWorld.txt文件
             
              		File file=new File("D:","HelloWorld.txt");
             
              		//创建文件，返回一个布尔值
             
              		boolean isCreate;
             
              		try {
             
              			isCreate = file.createNewFile();
             
              			if (isCreate) {
             
              				System.out.println("创建文件成功！");
             
              			}else {
             
              				System.out.println("创建文件失败！文件已经存在");
             
              			}
             
              		} catch (IOException e) {
             
              			System.out.println("创建文件失败！");
             
              		}
             
              		// 判断他是文件还是目录，
             
              		if (file.isFile()) {
             
              			System.out.println("这是一个文件");
             
              		} else {
             
              			System.out.println("这是一个目录");
             
              		}
             
              		//再创建一个目录IOTest
             
              		File file2=new File("D:/IOTest");
             
              		file2.mkdirs();
             
              		//HelloWorld.txt移动到IOTest目录下去?失败？》
             
              		if (file.renameTo(file2)) {
             
              			System.out.println("文件移动成功！");
             
              		} else {
             
              			System.out.println("文件移动失败");
             
              		}
             
              		//遍历IOTest目录下的文件
             
              		String[] arr=file2.list();
             
              		for (String string : arr) {
             
              			System.out.println(string);
             
              		}
             
              	}
             
              }

来自CODE的代码片
snippet_file_0.txt

//上面移动文件要指明文件路径和文件名

上面的file.renameTo(file2）改为：

file.renameTo(file2.getPath + "/" + file.getName());

就不会有错了。

（二）第二题

1.先建一个FileUtile工具类

 
             1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51 
           
              package com.xykj.lesson2;
             
              import java.io.File;
             
              import java.util.ArrayList;
             
              import java.util.List;
             
              	/**
             
              	 * 这是一个获取目录下所有文件夹内的所有文件的封装类
             
              	 * 当然前提是你要传进来一个正确路径的文件夹
             
              	 * */
             
              public class FileUtils {
             
              	//获取文件夹下所有的文件
             
              	public static List getAllFiles(String dir){
             
              		//创建一个集合存放遍历到的File
             
              		List< File >files=new ArrayList();
             
              		File file=new File(dir);
             
              		//文件夹必须存在                并且要是文件夹
             
              		if (file.exists()&&file.isDirectory()) {
             
              			//重点！    这里要本身一直遍历
             
              			longErgodic(file,files);//把遍历得到的东西存放在files里面
             
              		}
             
              		return files;
             
              	}
             
              	//重点理解，这是一个递归方法，会不断来回调用本身，但是所有获得的数据都会存放在集合files里面
             
              	private static void longErgodic(File file, List files) {
             
              		//.listFiles()方法的使用
             
              		//把文件夹的所有文件（包括文件和文件名）都放在一个文件类的数组里面 
             
              		File[] fillArr=file.listFiles();
             
              		//如果是一个空的文件夹
             
              		 if (fillArr==null) {
             
              			 //后面的不执行，直接返回
             
              			return;
             
              		}
             
              		//如果文件夹有内容,遍历里面的所有文件（包括文件夹和文件），都添加到集合里面
             
              		 for (File file2 : fillArr) {
             
              			 //如果只是想要里面的文件或者文件夹或者某些固定格式的文件可以判断下再添加
             
              			 files.add(file2);
             
              			 //添加到集合后，在来判断是否是文件夹，再遍历里面的所有文件
             
              			 //方法的递归
             
              			 longErgodic(file2, files);
             
              		}
             
              	}
             
              }

来自CODE的代码片
snippet_file_0.txt

2.再建一个主方法调用类

 
             1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22 
           
              package com.xykj.lesson2;
             
              import java.io.File;
             
              import java.util.List;
             
              public class Test2 {
             
              	/**
             
              	 * 递归实现输入任意目录，列出文件以及文件夹
             
              	 * 
             
              	 * 设计：在FileUtils类里面实现了逻辑操作，在另一边调用就可以了
             
              	 * */
             
              	public static void main(String[] args) {
             
              		 //比如输入D盘
             
              		Listlist=FileUtils.getAllFiles("D:");
             
              		//输出所有的文件和文件夹的名字
             
              		for (File file : list) {
             
              			System.out.println(file);
             
              		}
             
              	}
             
              }

来自CODE的代码片
snippet_file_0.txt

（三）第三题

 
             1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26 
           
              package com.xykj.lesson3;
             
              import java.io.File;
             
              import java.util.List;
             
              import com.xykj.lesson2.FileUtils;
             
              public class Test3 {
             
              	/**
             
              	 * 递归实现列出当前工程下所有.java文件
             
              	 * 还是要题目2的遍历文件的工具类来获取所有的文件，再过滤.java文件就可以了
             
              	 * 当前目录的地址：输入.就可以获取
             
              	 * */
             
              	public static void main(String[] args) {
             
              		 //输入.  获取当前文件的 所有文件
             
              		Listlist=FileUtils.getAllFiles(".");
             
              		//输出.java后缀的文件的名字
             
              		for (File file : list) {
             
              			if (file.toString().endsWith(".java")) {
             
              				System.out.println(file.getName());
             
              			}
             
              		}
             
              	}
             
              }

来自CODE的代码片
snippet_file_0.txt

（四）第四题

 
             1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36 
           
              package com.xykj.lesson4;
             
              import java.io.File;
             
              import java.io.FileInputStream;
             
              public class Tset4 {
             
              	/**
             
              	 * 从磁盘读取一个文件到内存中，再打印到控制台
             
              	 * 
             
              	 * 程序设计：
             
              	 * 1、读取文件用到FileinputSteam 
             
              	 * 2、把读取的内容不断加入到StringBuffer，
             
              	 * 3、再把StringBuffer打印出来就可以
             
              	 * */
             
              	public static void main(String[] args) {
             
              		// 读取D:\notePad\aa.txt里面的内容
             
              		File file = new File("D:\\notePad\\aa.txt");
             
              		try {
             
              			// 创建读取流即输入流
             
              			FileInputStream fis = new FileInputStream(file);
             
              			int len = 0;
             
              			byte[] buf = new byte[1024];
             
              			StringBuffer sb = new StringBuffer();
             
              			// 把读取的数据添加到StringBuffer里面
             
              			while ((len = fis.read(buf)) != -1) {
             
              				sb.append(new String(buf, 0, len));
             
              			}
             
              			// 把StringBuffer里面的内容打印出来
             
              			System.out.println(sb);
             
              			fis.close();
             
              		} catch (Exception e) {
             
              			e.printStackTrace();
             
              		}
             
              	}
             
              }

来自CODE的代码片
snippet_file_0.txt

（五）第五题

 
             1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26 
           
              package com.xykj.lesson5;
             
              import java.io.File;
             
              import java.io.FileOutputStream;
             
              public class Test5 {
             
              	/**
             
              	 * 在程序中写一个"HelloJavaWorld你好世界"输出到操作系统文件Hello.txt文件中
             
              	 * 
             
              	 * 程序分析：文件写入，要用到输出流FileOutputStream
             
              	 * */
             
              	public static void main(String[] args) {
             
              		// 向文件D:/Hello.txt，写入内容
             
              		File file = new File("D:/Hello.txt");
             
              		try {
             
              			// 创建输出流
             
              			FileOutputStream fos = new FileOutputStream(file);
             
              			//把String类型的字符串转化为byte数组的数据保存在输出流中
             
              			fos.write("HelloJavaWorld你好世界".getBytes());
             
              			fos.flush();//刷新输出流
             
              			fos.close();//关闭输出流
             
              		} catch (Exception e) {
             
              			e.printStackTrace();
             
              		}
             
              	}
             
              }

来自CODE的代码片
snippet_file_0.txt

（六）第六题

 
             1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53 
           
              package com.xykj.lesson6;
             
              import java.io.File;
             
              import java.io.FileInputStream;
             
              import java.io.FileOutputStream;
             
              public class Test6 {
             
              	/**
             
              	 * 拷贝一张图片，从一个目录到另外一个目录下(PS:是拷贝是不是移动)
             
              	 * 
             
              	 * 程序设计思路：
             
              	 *  这题不能使用renameTo， 
             
              	 *  解题步骤：
             
              	 * 1、在目的地址创建一个图片文件
             
              	 * 2、读取源地址文件的字节流
             
              	 * 3、把读取到的字节流写入到目的地址的文件里面 
             
              	 * 4、刷新输出流，并关闭就可以了
             
              	 * 
             
              	 * @throws Exception
             
              	 * */
             
              	public static void main(String[] args) {
             
              		// 本题示范把D盘下的mm.jpg复制到D盘java文件夹里面
             
              		// 源文件地址
             
              		File fileFrom = new File("D:/mm.jpg");
             
              		// 目的文件地址
             
              		File fileTo = new File("D:/java/mm.jpg");
             
              		// 1、创建目的文件地址
             
              		try {
             
              			if (!fileTo.createNewFile()) {
             
              				System.out.println("创建文件失败！");
             
              			}
             
              			// 2、读取源地址文件的字节流
             
              			FileInputStream fis = new FileInputStream(fileFrom);
             
              			FileOutputStream fos = new FileOutputStream(fileTo);
             
              			int len = 0;
             
              			byte[] buf = new byte[1024];
             
              			while ((len = fis.read(buf)) != -1) {
             
              				// 3、把读取到的字节流写入到目的地址的文件里面
             
              				fos.write(buf, 0, len);
             
              			}
             
              			// 刷新下输出流
             
              			fos.flush();
             
              			// 关闭输入流和输出流
             
              			fis.close();
             
              			fos.close();
             
              			System.out.println("文件复制成功！");
             
              		} catch (Exception e) {
             
              			e.printStackTrace();
             
              		}
             
              	}
             
              }

来自CODE的代码片
snippet_file_0.txt

（七）第七题

 
             1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44 
           
              package com.xykj.lesson7;
             
              import java.io.File;
             
              import java.io.FileInputStream;
             
              public class Test7 {
             
              	/**
             
              	 * 统计一个文件calcCharNum.txt（见附件）中字母'A'和'a'出现的总次数
             
              	 * 
             
              	 * 程序分析：
             
              	 * 读取文件用FileInputStream
             
              	 * 一次只读一个字节(一个字母就是一个字节)，当字节内容和A或a相等时，相应的数量加1
             
              	 * */
             
              	public static void main(String[] args) {
             
              		try {
             
              			//添加文件路径
             
              			File file = new File("D:/java/calcCharNum.txt");
             
              			//创建文件读取流
             
              			FileInputStream fis = new FileInputStream(file);
             
              			int numA = 0;//字母A的数量
             
              			int numa = 0;//字母a的数量
             
              			int len = 0;//每次读取的字节数量
             
              			while ((len=fis.read())!= -1) {
             
              				//统计字母a的数量
             
              				if (new String((char)len+"").equals("a")) {
             
              					numa++;
             
              				}
             
              				//统计字母A的数量
             
              				if (new String((char)len+"").equals("A")) {
             
              					numA++;
             
              				}
             
              			}
             
              			//打印出文件内字母的数量
             
              			System.out.println("a的数量是："+numa);
             
              			System.out.println("A的数量是："+numA);
             
              			System.out.println("a和A出现的总次数："+(numA+numa));
             
              			fis.close();//关闭输入流
             
              		} catch (Exception e) {
             
              			e.printStackTrace();
             
              		}
             
              	}
             
              }

来自CODE的代码片
snippet_file_0.txt

（八）第八题

 
             1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60 
           
              package com.xykj.lesson8;
             
              import java.io.File;
             
              import java.io.FileInputStream;
             
              import java.util.HashMap;
             
              import java.util.Iterator;
             
              import java.util.Map.Entry;
             
              public class Test8 {
             
              	/**
             
              	 * 统计一个文件calcCharNum.txt（见附件）中各个字母出现次数：
             
              	 * A(8),B(16),C(10)...,a(12),b(10),c(3)....，括号内代表字符出现次数;
             
              	 *
             
              	 * 程序分析：
             
              	 * 1.这里没中文字符，依然可以只用字节流来读取文件
             
              	 * 2.不能保存相同的主键值，可以使用HashMap：key-value来实现
             
              	 * 3.先获得该key的value，如果存在key的话value的值加1 
             
              	 * */
             
              	public static void main(String[] args) {
             
              		// 文件路径
             
              		File file = new File("D:/java/calcCharNum.txt");
             
              		try {
             
              			// 创建读取文件的输入流
             
              			FileInputStream fis = new FileInputStream(file);
             
              			// 创建集合HashMap类存放要保存的key-value
             
              			HashMap map = new HashMap<>();
             
              			// 读取文件
             
              			int len = 0;// 每次读取的文件长度
             
              			int count = 0;
             
              			while ((len = fis.read()) != -1) {
             
              				// 每次获取到的字母
             
              				char c = (char) len;
             
              				//这里使用try catch是因为 map.get(c + "")，第一次get不到东西会出现空指针
             
              				try {
             
              					// 通过每次的key值获取它的value值，
             
              					// 但是在它的key值没有时或报空指针错误，所以要try catch处理
             
              					// 当她有key值，就可以获取到相应的value值
             
              					count = map.get(c + "");
             
              				} catch (Exception e) {// 什么都不用输出
             
              				}
             
              				// 如果有它的key值对应的value值要加1
             
              				map.put(c + "", count + 1);
             
              			}
             
              			fis.close();
             
              			// 读完后把结果打印出来
             
              			//迭代器的使用
             
              			Iterator> iterator = map.entrySet().iterator();
             
              			while (iterator.hasNext()) {
             
              				Entry entry = iterator.next();
             
              				System.out.print(entry.getKey() + "(" + entry.getValue()+ ") \t");
             
              			}
             
              		} catch (Exception e) {
             
              			e.printStackTrace();
             
              		}
             
              	}
             
              }

来自CODE的代码片
snippet_file_0.txt

其实本题也可以直接用字符流来读取的。

（九）第九题

 
             1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63 
           
              package com.xykj.lesson9;
             
              import java.io.File;
             
              import java.io.FileNotFoundException;
             
              import java.io.FileReader;
             
              import java.io.FileWriter;
             
              import java.util.HashMap;
             
              import java.util.Iterator;
             
              import java.util.Map.Entry;
             
              public class Test9 {
             
              	/**
             
              	 * 统计一个文件calcCharNum2.txt（见附件）中各个字母出现次数：
             
              	 * A(8),B(16),C(10)...,a(12),b(10),c(3)....中(5),国(6)，
             
              	 * 括号内代表字符出现次数;
             
              	 * 
             
              	 * 程序分析：
             
              	 * 1.这出现中文字符，依然只能用字符流来读取文件
             
              	 * 2.不能保存相同的主键值，可以使用HashMap：key-value来实现
             
              	 * 3.先获得该key的value，如果存在key的话value的值加1 
             
              	 * */
             
              	public static void main(String[] args) {
             
              		// 文件路径
             
              		File file = new File("D:/java/calcCharNum2.txt");
             
              		// 创建集合HashMap类存放要保存的key-value
             
              		HashMap map = new HashMap<>();
             
              		try {
             
              			// 创建字符流
             
              			FileReader fr = new FileReader(file);
             
              			// 每次读取的字符长度
             
              			int len = 0;
             
              			int count=0;//出现该字符的次数
             
              			while ((len = fr.read()) != -1) {
             
              				// 获取对应的字符
             
              				char c = (char) len;
             
              				try {
             
              					// 通过每次的key值获取它的value值，
             
              					// 但是在它的key值没有时或报空指针错误，所以要try catch处理
             
              					// 当她有key值，就可以获取到相应的value值
             
              					count = map.get(c + "");
             
              				} catch (Exception e) {// 什么都不用输出
             
              				}
             
              				// 如果有它的key值对应的value值要加1
             
              				map.put(c + "", count + 1);
             
              			}
             
              			// 读完后把结果打印出来
             
              			Iterator> iterator = map.entrySet().iterator();
             
              			//迭代器的使用
             
              			while (iterator.hasNext()) {				
             
              				Entry entry = iterator.next();
             
              				System.out.print(entry.getKey() + "(" + entry.getValue()+ ") \t");
             
              			}
             
              		} catch (Exception e) {
             
              			e.printStackTrace();
             
              		}
             
              	}
             
              }

来自CODE的代码片
snippet_file_0.txt

（十）第十题

 
             1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46 
           
              package com.xykj.lesson10;
             
              import java.io.File;
             
              import java.io.RandomAccessFile;
             
              public class Test10 {
             
              	/**
             
              	 * 使用随机文件流类RandomAccessFile将一个文本文件倒置读出。
             
              	 * 
             
              	 * 程序分析：
             
              	 *  RandomAccessFile的seek方法能把读取文件的光标移动到具体的位置
             
              	 * 但是还是有地点值得注意的是一个字母或数字是占用一个字节的， 一个汉字是占用两个字节的
             
              	 * */
             
              	public static void main(String[] args) {
             
              		// 要读取的文件的地址
             
              		File file = new File("D:/java/calcCharNum2.txt");
             
              		try {
             
              			RandomAccessFile raf = new RandomAccessFile(file, "r");
             
              			long length = raf.length();
             
              			StringBuffer sb = new StringBuffer();
             
              			while (length > 0) {
             
              				length--;
             
              				raf.seek(length);
             
              				int c = (char) raf.readByte();
             
              				// 如果asc码<=255,>=0,则判断是个英文字符,添加到字符串中.
             
              				if (c >= 0 && c <= 255) {
             
              					sb.append((char) c);
             
              				} else {
             
              					// 如果不在asc码范围内,则判断是个汉字字符
             
              					// 汉字字符是占2个字节的,所以length再退一个字节
             
              					length--;
             
              					raf.seek(length);
             
              					byte[] cc = new byte[2];
             
              					// cc被复制为文件中连续的两个字节
             
              					raf.readFully(cc);
             
              					sb.append(new String(cc));
             
              				}
             
              			}
             
              			System.out.println(sb);
             
              			raf.close();
             
              		} catch (Exception e) {
             
              			e.printStackTrace();
             
              		}
             
              	}
             
              }

来自CODE的代码片
snippet_file_0.txt

（十一）第十一题

 
             1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62 
           
              package com.xykj.lesson1;
             
              import java.io.File;
             
              import java.io.IOException;
             
              public class Test1 {
             
              	/**
             
              	 * 1. 在电脑D盘下创建一个文件为HelloWorld.txt文件，
             
              	 * 判断他是文件还是目录，再创建一个目录IOTest,
             
              	 * 之后将HelloWorld.txt移动到IOTest目录下去；
             
              	 * 之后遍历IOTest这个目录下的文件
             
              	 * 
             
              	 * 程序分析：
             
              	 * 1、文件创建使用File的createNewFile()方法
             
              	 * 2、判断是文件用isFile(),判断是目录用isDirectory
             
              	 * 3、创建目录用：mkdirs()方法
             
              	 * 4、移动文件用：renameTo
             
              	 * 5、遍历目录用：list（）方法获得存放文件的数组，foreach遍历的方法把文件打印出来
             
              	 * */
             
              	public static void main(String[] args) {
             
              		 //在电脑D盘下创建一个文件为HelloWorld.txt文件
             
              		File file=new File("D:","HelloWorld.txt");
             
              		//创建文件，返回一个布尔值
             
              		boolean isCreate;
             
              		try {
             
              			isCreate = file.createNewFile();
             
              			if (isCreate) {
             
              				System.out.println("创建文件成功！");
             
              			}else {
             
              				System.out.println("创建文件失败！文件已经存在");
             
              			}
             
              		} catch (IOException e) {
             
              			System.out.println("创建文件失败！");
             
              		}
             
              		// 判断他是文件还是目录，
             
              		if (file.isFile()) {
             
              			System.out.println("这是一个文件");
             
              		} else {
             
              			System.out.println("这是一个目录");
             
              		}
             
              		//再创建一个目录IOTest
             
              		File file2=new File("D:/IOTest");
             
              		file2.mkdirs();
             
              		//HelloWorld.txt移动到IOTest目录下去?失败？》
             
              		if (file.renameTo(file2)) {
             
              			System.out.println("文件移动成功！");
             
              		} else {
             
              			System.out.println("文件移动失败");
             
              		}
             
              		//遍历IOTest目录下的文件
             
              		String[] arr=file2.list();
             
              		for (String string : arr) {
             
              			System.out.println(string);
             
              		}
             
              	}
             
              }

来自CODE的代码片
snippet_file_0.txt

（十二）第十二题

 
              1
   2
   3
   4
   5
   6
   7
   8
   9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56
  57
  58
  59
  60
  61
  62
  63
  64
  65
  66
  67
  68
  69
  70
  71
  72
  73
  74
  75
  76
  77
  78
  79
  80
  81
  82
  83
  84
  85
  86
  87
  88
  89
  90
  91
  92
  93
  94
  95
  96
  97
  98
  99
 100
 101
 102
 103
 104
 105
 106
 107
 108
 109
 110
 111
 112
 113
 114
 115
 116
 117
 118
 119
 120
 121
 122
 123
 124
 125
 126
 127
 128
 129
 130
 131
 132
 133 
           
              package com.xykj.lesson12;
             
              import java.io.File;
             
              import java.io.FileInputStream;
             
              import java.io.FileOutputStream;
             
              import java.io.IOException;
             
              import java.util.List;
             
              import java.util.Scanner;
             
              import java.util.concurrent.ExecutorService;
             
              import java.util.concurrent.Executors;
             
              import com.xykj.lesson2.FileUtils;
             
              public class Test12 {
             
              	/*
             
              	 * 输入两个文件夹名称，将A文件夹内容全部拷贝到B文件夹，要求使用多线程来操作。
             
              	 * 
             
              	 * 程序分析：
             
              	 * 1.拷贝文件里面的东西，要分析的东西还是蛮多的，要先建文件夹再拷贝里面的东西，而且要一层层的来搞
             
              	 * 2.这里也需要文件遍历工具，直接调用第二题的工具类，不再重写
             
              	 * 3.多线程的使用，可以直接在方法里面直接新建线程
             
              	 * 4.对整个文件夹进行复制 文件夹分隔符可以用\\或/，其他的都是不对的
             
              	 * 所有其中还对输入的分割符进行了替换
             
              	 * 这题看起来比较长，分开看其实也不长
             
              	 * */
             
              	public static void main(String[] args) {
             
              		Scanner scanner=new Scanner(System.in);
             
              		System.out.println("要复制的文件夹：");
             
              		String fromDir = scanner.next();// 接收输入
             
              		System.out.println("要复制到哪里去：");
             
              		String toDir = scanner.next();// 接收输入
             
              		// 把输入的地址转化为File类型
             
              		File fromFile = new File(fromDir);
             
              		File toFile = new File(toDir);
             
              		//新建线程
             
              		new Thread(){
             
              			//里面做实际操作
             
              			public void run() {
             
              				// 判断如果要复制的是文件，直接复制就可以了
             
              				if (fromFile.isFile()) {
             
              					System.out.println("复制单个文件");
             
              					copy(fromFile, toFile);
             
              				} else {
             
              					// 要复制文件夹
             
              					// 要防止一种无法进行的复制：比如说，要把复制的文件复制到自己的子文件夹里面
             
              					// 举个例子：把D:/java/jsp文件夹复制到D:/java/jsp/js文件夹里面，
             
              					// 这会导致子文件不断增加的同时，而父文件也要不断增加，的一个死循环
             
              					// 如果反过来，就没事，相当于只是简单的覆盖而已
             
              					// 具体实现就是看：目的地地址包含复制的文件夹地址，就不允许操作
             
              					if (toDir.replace("/", "\\").toLowerCase()
             
              							.startsWith(fromDir.replace("/", "\\").toLowerCase())) {
             
              						return;
             
              					}
             
              					// 复制文件（包括文件和文件夹）操作
             
              					// 先获取所有的文件（包括文件和文件夹）
             
              					List list = FileUtils.getAllFiles(fromDir);
             
              					// 创建一个线程池，加快复制的速度
             
              					ExecutorService threadPool = Executors.newFixedThreadPool(20);
             
              					// 需要对每一个文件的路径进行处理
             
              					for (File file : list) {
             
              						// 复制文件名
             
              						String name = file.getAbsolutePath();
             
              						// 把原来的文件路径换成新的文件路径
             
              						String toName = name.replace(fromFile.getParent(), toDir + "/");
             
              						System.out.println(name + "变成了" + toName);
             
              						// 如果是文件夹，直接创建
             
              						if (file.isDirectory()) {
             
              							new File(toName).mkdirs();
             
              						} else {
             
              							// 如果是文件,在线程里面复制
             
              							threadPool.execute(new Runnable() {
             
              								@Override
             
              								public void run() {
             
              									File copyFile = new File(toName);
             
              									// 先要有父文件夹
             
              									copyFile.getParentFile().mkdirs();
             
              									// 开始复制文件
             
              									copy(file, copyFile);
             
              								}
             
              							});
             
              						}
             
              					}
             
              				}
             
              				scanner.close();
             
              			};
             
              		}.start();//开始线程
             
              	}
             
              	//复制文件的操作
             
              	public static void copy(File fromFile, File toFile) {
             
              		// 定义一个输入流
             
              		FileInputStream fis = null;
             
              		// 定义一个输出流
             
              		FileOutputStream fos = null;
             
              		try {
             
              			// 把复制地址的File，封装后赋值给输入流对象
             
              			fis = new FileInputStream(fromFile);
             
              			// 把目的地的File，封装后复制给输出流的对象
             
              			fos = new FileOutputStream(toFile);
             
              			// 创建一个容量，
             
              			byte[] buf = new byte[1024];
             
              			// 每次读取/写入的字节长度
             
              			int len = 0;
             
              			// 边读边写
             
              			while ((len = fis.read(buf)) != -1) {// 判断是否还能读到数据
             
              				// 把输入放到输出流里面
             
              				fos.write(buf, 0, len);
             
              			}
             
              		} catch (Exception e) {
             
              			e.printStackTrace();
             
              		} finally {
             
              			try {
             
              				// 关闭输入流和输出流
             
              				fis.close();
             
              				fos.close();
             
              			} catch (IOException e) {
             
              				e.printStackTrace();
             
              			}
             
              		}
             
              	}
             
              }

来自CODE的代码片
snippet_file_0.txt

（十三）第十三题

 
             1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55 
           
              package com.xykj.lesson13;
             
              import java.io.File;
             
              import java.util.Collections;
             
              import java.util.Comparator;
             
              import java.util.List;
             
              import com.xykj.lesson2.FileUtils;
             
              public class Test13 {
             
              	/**
             
              	 * 查看D盘中所有的文件和文件夹名称，并且使用名称升序降序，
             
              	 * 文件夹在前和文件夹在后，文件大小排序等。
             
              	 * 
             
              	 * 程序分析:
             
              	 * 1.查找文件和文件夹，需要例题二里遍历文件的工具类（这里直接调用，不在重写）
             
              	 * 2.排序需要用到list集合里面的Collections工具类类的sort方法
             
              	 * 3.这里有三重排序：首先是要按是否是文件夹来排序，然后按名称来排序，最后按大小来排序
             
              	 *   其实这里还是会有问题的，按照某一个排序还没事，但是三个都排序就不一定有效！
             
              	   实际应用中也是只按一种排序就可以了的
             
              	 * */
             
              	public static void main(String[] args) {
             
              		 List list =FileUtils.getAllFiles("D:");
             
              		 //按文件夹先显示的顺序：
             
              		 Collections.sort(list, new Comparator() {
             
              			@Override
             
              			public int compare(File o1, File o2) {
             
              				return (o2.isDirectory()?1:-1)-(o1.isDirectory()?1:-1);
             
              			}
             
              		});
             
              		 //按文件名称显示的顺序：
             
              		 Collections.sort(list, new Comparator() {
             
              				@Override
             
              				public int compare(File o1, File o2) {
             
              					return (o1.getName()).compareTo(o2.getName());
             
              				}
             
              			});
             
              		 //按文件名称显示的顺序：
             
              		 Collections.sort(list, new Comparator() {
             
              				@Override
             
              				public int compare(File o1, File o2) {
             
              					return (int)(o1.length()-o2.length());
             
              				}
             
              			});
             
              		 //遍历集合的文件
             
              		 for (File file : list) {
             
              		 //打印排序后的文件或文件夹
             
              		 System.out.println(file.getName());
             
              		}
             
              	}
             
              }

来自CODE的代码片
snippet_file_0.txt

以上是这些题目的详细的解题过程，当然很多题目的解决方法不是固定的，

但是对于基本的解题方式还是要了解的。对于知识点的掌握的话，

文件的基本操作，读取文件的基本方法，和写文件的基本方法都是要掌握的，

还有字节流的读取和字符流的读取方式和用处也要会区分。

你可能感兴趣的:(java)

Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
LocalDateTime 转 String igotyback java 开发语言
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计网页设计期末网页作业 html静态网页 html5期末大作业网页设计 web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java 算法华为 javascript
华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
Java 重写(Override)与重载(Overload) 叨唧唧的
Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
简单了解 JVM 记得开心一点啊 jvm
目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
Java企业面试题3 马龙强_ java
1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Java java
Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选 java kafka
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
白骑士的Java教学基础篇 2.5 控制流语句白骑士所长 Java 教学 java 开发语言
欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
python语法——三目运算符 HappyRocking python python 三目运算符
在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
ArrayList 源码解析程序猿进阶 Java基础 ArrayList List java 面试性能优化架构设计 idea
ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
Java爬虫框架（一）--架构设计狼图腾-狼之传说 java 框架 java 任务 html解析器存储电子商务
一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
Java：爬虫框架 dingcho Java java 爬虫
一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
python怎么将png转为tif_png转tif weixin_39977276
发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）跳房子的前端前端面试 javascript 开发语言 ecmascript
在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
JAVA·一个简单的登录窗口 MortalTom java 开发语言学习
文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Java java 爬虫开发语言
文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
博客网站制作教程 2401_85194651 java maven
首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
00. 这里整理了最全的爬虫框架（Java + Python）有一只柴犬爬虫系列爬虫 java python
目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2
JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式 android java 常用设计模式
博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
JavaScript `Map` 和 `WeakMap`详细解释跳房子的前端 JavaScript 原生方法 javascript 前端开发语言
在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键
切换淘宝最新npm镜像源是 hai40587 npm 前端 node.js
切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库
【Java】已解决：java.util.concurrent.CompletionException 屿小夏 java 开发语言
文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现
设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】） ok!ko 设计模式设计模式建造者模式 java
文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil
java的(PO,VO,TO,BO,DAO,POJO) Cb123456 VO TO BO POJO DAO
转: http://www.cnblogs.com/yxnchinahlj/archive/2012/02/24/2366110.html ------------------------------------------------------------------- O/R Mapping 是 Object Relational Mapping（对象关系映
spring ioc原理（看完后大家可以自己写一个spring） aijuans spring
最近，买了本Spring入门书：spring In Action 。大致浏览了下感觉还不错。就是入门了点。Manning的书还是不错的，我虽然不像哪些只看Manning书的人那样专注于Manning,但怀着崇敬的心情和激情通览了一遍。又一次接受了IOC 、DI、AOP等Spring核心概念。先就IOC和DI谈一点我的看法。IO
MyEclipse 2014中Customize Persperctive设置无效的解决方法 Kai_Ge MyEclipse2014
高高兴兴下载个MyEclipse2014，发现工具条上多了个手机开发的按钮，心生不爽就想弄掉他！结果发现Customize Persperctive失效！！有说更新下就好了，可是国内Myeclipse访问不了，何谈更新... so~这里提供了更新后的一下jar包，给大家使用！ 1、将9个jar复制到myeclipse安装目录\plugins中 2、删除和这9个jar同包名但是版本号较
SpringMvc上传 120153216 springMVC
@RequestMapping(value = WebUrlConstant.UPLOADFILE) @ResponseBody public Map<String, Object> uploadFile(HttpServletRequest request,HttpServletResponse httpresponse) { try { //
Javascript----HTML DOM 事件何必如此 JavaScript html Web
HTML DOM 事件允许Javascript在HTML文档元素中注册不同事件处理程序。事件通常与函数结合使用，函数不会在事件发生前被执行！注：DOM：指明使用的 DOM 属性级别。 1.鼠标事件属性
动态绑定和删除onclick事件 357029540 JavaScript jquery
因为对JQUERY和JS的动态绑定事件的不熟悉，今天花了好久的时间才把动态绑定和删除onclick事件搞定!现在分享下我的过程。在我的查询页面，我将我的onclick事件绑定到了tr标签上同时传入当前行(this值)参数，这样可以在点击行上的任意地方时可以选中checkbox，但是在我的某一列上也有一个onclick事件是用于下载附件的，当
HttpClient|HttpClient请求详解 7454103 apache 应用服务器网络协议网络应用 Security
HttpClient 是 Apache Jakarta Common 下的子项目，可以用来提供高效的、最新的、功能丰富的支持 HTTP 协议的客户端编程工具包，并且它支持 HTTP 协议最新的版本和建议。本文首先介绍 HTTPClient，然后根据作者实际工作经验给出了一些常见问题的解决方法。HTTP 协议可能是现在 Internet 上使用得最多、最重要的协议了，越来越多的 Java 应用程序需
递归逐层统计树形结构数据 darkranger 数据结构
将集合递归获取树形结构: /** * * 递归获取数据 * @param alist:所有分类 * @param subjname:对应统计的项目名称 * @param pk:对应项目主键 * @param reportList: 最后统计的结果集 * @param count:项目级别 */ public void getReportVO(Arr
访问WEB-INF下使用frameset标签页面出错的原因 aijuans struts2
<frameset rows="61,*,24" cols="*" framespacing="0" frameborder="no" border="0">
MAVEN常用命令 avords
Maven库： http://repo2.maven.org/maven2/ Maven依赖查询： http://mvnrepository.com/ Maven常用命令： 1. 创建Maven的普通java项目： mvn archetype:create -DgroupId=packageName
PHP如果自带一个小型的web服务器就好了 houxinyou apache 应用服务器 Web PHP 脚本
最近单位用PHP做网站，感觉PHP挺好的，不过有一些地方不太习惯，比如，环境搭建。PHP本身就是一个网站后台脚本，但用PHP做程序时还要下载apache，配置起来也不太很方便，虽然有好多配置好的apache+php+mysq的环境，但用起来总是心里不太舒服，因为我要的只是一个开发环境，如果是真实的运行环境，下个apahe也无所谓，但只是一个开发环境，总有一种杀鸡用牛刀的感觉。如果php自己的程序中
NoSQL数据库之Redis数据库管理(list类型) bijian1013 redis 数据库 NoSQL
3.list类型及操作 List是一个链表结构，主要功能是push、pop、获取一个范围的所有值等等，操作key理解为链表的名字。Redis的list类型其实就是一个每个子元素都是string类型的双向链表。我们可以通过push、pop操作从链表的头部或者尾部添加删除元素，这样list既可以作为栈，又可以作为队列。 &nbs
谁在用Hadoop？ bingyingao hadoop 数据挖掘公司应用场景
Hadoop技术的应用已经十分广泛了，而我是最近才开始对它有所了解，它在大数据领域的出色表现也让我产生了兴趣。浏览了他的官网，其中有一个页面专门介绍目前世界上有哪些公司在用Hadoop，这些公司涵盖各行各业，不乏一些大公司如alibaba,ebay,amazon,google,facebook,adobe等，主要用于日志分析、数据挖掘、机器学习、构建索引、业务报表等场景,这更加激发了学习它的热情。
【Spark七十六】Spark计算结果存到MySQL bit1129 mysql
package spark.examples.db import java.sql.{PreparedStatement, Connection, DriverManager} import com.mysql.jdbc.Driver import org.apache.spark.{SparkContext, SparkConf} object SparkMySQLInteg
Scala: JVM上的函数编程 bookjovi scala erlang haskell
说Scala是JVM上的函数编程一点也不为过，Scala把面向对象和函数型编程这两种主流编程范式结合了起来，对于熟悉各种编程范式的人而言Scala并没有带来太多革新的编程思想，scala主要的有点在于Java庞大的package优势，这样也就弥补了JVM平台上函数型编程的缺失，MS家.net上已经有了F#，JVM怎么能不跟上呢？对本人而言
jar打成exe bro_feng java jar exe
今天要把jar包打成exe，jsmooth和exe4j都用了。遇见几个问题。记录一下。两个软件都很好使，网上都有图片教程，都挺不错。首先肯定是要用自己的jre的，不然不能通用，其次别忘了把需要的lib放到classPath中。困扰我很久的一个问题是，我自己打包成功后，在一个同事的没有装jdk的电脑上运行，就是不行，报错jvm.dll为无效的windows映像，如截图最后发现
读《研磨设计模式》-代码笔记-策略模式-Strategy bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ /* 策略模式定义了一系列的算法，并将每一个算法封装起来，而且使它们还可以相互替换。策略模式让算法独立于使用它的客户而独立变化简单理解： 1、将不同的策略提炼出一个共同接口。这是容易的，因为不同的策略，只是算法不同，需要传递的参数
cmd命令值cvfM命令 chenyu19891124 cmd
cmd命令还真是强大啊。今天发现jar -cvfM aa.rar @aaalist 就这行命令可以根据aaalist取出相应的文件例如：在d：\workspace\prpall\test.java 有这样一个文件，现在想要将这个文件打成一个包。运行如下命令即可比如在d：\wor
OpenJWeb(1.8) Java Web应用快速开发平台 comsci java 框架 Web 项目管理企业应用
OpenJWeb(1.8) Java Web应用快速开发平台的作者是我们技术联盟的成员，他最近推出了新版本的快速应用开发平台 OpenJWeb(1.8)，我帮他做做宣传 OpenJWeb快速开发平台以快速开发为核心，整合先进的java 开源框架，本着自主开发+应用集成相结合的原则，旨在为政府、企事业单位、软件公司等平台用户提供一个架构透
Python 报错：IndentationError: unexpected indent daizj python tab 空格缩进
IndentationError: unexpected indent 是缩进的问题，也有可能是tab和空格混用啦 Python开发者有意让违反了缩进规则的程序不能通过编译，以此来强制程序员养成良好的编程习惯。并且在Python语言里，缩进而非花括号或者某种关键字，被用于表示语句块的开始和退出。增加缩进表示语句块的开
HttpClient 超时设置 dongwei_6688 httpclient
HttpClient中的超时设置包含两个部分： 1. 建立连接超时，是指在httpclient客户端和服务器端建立连接过程中允许的最大等待时间 2. 读取数据超时，是指在建立连接后，等待读取服务器端的响应数据时允许的最大等待时间在HttpClient 4.x中如下设置： HttpClient httpclient = new DefaultHttpC
小鱼与波浪 dcj3sjt126com
一条小鱼游出水面看蓝天，偶然间遇到了波浪。　　小鱼便与波浪在海面上游戏，随着波浪上下起伏、汹涌前进。　　小鱼在波浪里兴奋得大叫：“你每天都过着这么刺激的生活吗？简直太棒了。”　　波浪说：“岂只每天过这样的生活，几乎每一刻都这么刺激！还有更刺激的，要有潮汐变化，或者狂风暴雨，那才是兴奋得心脏都会跳出来。”　　小鱼说：“真希望我也能变成一个波浪，每天随着风雨、潮汐流动，不知道有多么好！”　　很快，小鱼
Error Code: 1175 You are using safe update mode and you tried to update a table dcj3sjt126com mysql
快速高效用：SET SQL_SAFE_UPDATES = 0；下面的就不要看了！今日用MySQL Workbench进行数据库的管理更新时，执行一个更新的语句碰到以下错误提示： Error Code: 1175 You are using safe update mode and you tried to update a table without a WHERE that
枚举类型详细介绍及方法定义 gaomysion enum javaee
转发 http://developer.51cto.com/art/201107/275031.htm 枚举其实就是一种类型，跟int, char 这种差不多，就是定义变量时限制输入的，你只能够赋enum里面规定的值。建议大家可以看看，这两篇文章，《java枚举类型入门》和《C++的中的结构体和枚举》，供大家参考。枚举类型是JDK5.0的新特征。Sun引进了一个全新的关键字enum
Merge Sorted Array hcx2013 array
Given two sorted integer arrays nums1 and nums2, merge nums2 into nums1 as one sorted array. Note:You may assume that nums1 has enough space (size that is
Expression Language 3.0新特性 jinnianshilongnian el 3.0
Expression Language 3.0表达式语言规范最终版从2013-4-29发布到现在已经非常久的时间了；目前如Tomcat 8、Jetty 9、GlasshFish 4已经支持EL 3.0。新特性包括：如字符串拼接操作符、赋值、分号操作符、对象方法调用、Lambda表达式、静态字段/方法调用、构造器调用、Java8集合操作。目前Glassfish 4/Jetty实现最好，对大多数新特性
超越算法来看待个性化推荐 liyonghui160com 超越算法来看待个性化推荐
一提到个性化推荐，大家一般会想到协同过滤、文本相似等推荐算法，或是更高阶的模型推荐算法，百度的张栋说过，推荐40%取决于UI、30%取决于数据、20%取决于背景知识，虽然本人不是很认同这种比例，但推荐系统中，推荐算法起的作用起的作用是非常有限的。就像任何
写给Javascript初学者的小小建议 pda158 JavaScript
　　一般初学JavaScript的时候最头痛的就是浏览器兼容问题。在Firefox下面好好的代码放到IE就不能显示了，又或者是在IE能正常显示的代码在firefox又报错了。　　如果你正初学JavaScript并有着一样的处境的话建议你：初学JavaScript的时候无视DOM和BOM的兼容性，将更多的时间花在了解语言本身（ECMAScript）。只在特定浏览器编写代码（Chrome/Fi
Java 枚举 ShihLei java enum 枚举
注：文章内容大量借鉴使用网上的资料，可惜没有记录参考地址，只能再传对作者说声抱歉并表示感谢！一基础 1）语法枚举类型只能有私有构造器（这样做可以保证客户代码没有办法新建一个enum的实例）枚举实例必须最先定义 2）特性 &nb
Java SE 6 HotSpot虚拟机的垃圾回收机制 uuhorse java HotSpot GC 垃圾回收 VM
官方资料，关于Java SE 6 HotSpot虚拟机的garbage Collection，非常全，英文。 http://www.oracle.com/technetwork/java/javase/gc-tuning-6-140523.html Java SE 6 HotSpot[tm] Virtual Machine Garbage Collection Tuning &

Java IO流经典练习题

来自CODE的代码片 snippet_file_0.txt

来自CODE的代码片 snippet_file_0.txt

来自CODE的代码片 snippet_file_0.txt

来自CODE的代码片 snippet_file_0.txt

来自CODE的代码片 snippet_file_0.txt

来自CODE的代码片 snippet_file_0.txt

来自CODE的代码片 snippet_file_0.txt

来自CODE的代码片 snippet_file_0.txt

来自CODE的代码片 snippet_file_0.txt

来自CODE的代码片 snippet_file_0.txt

来自CODE的代码片 snippet_file_0.txt

来自CODE的代码片 snippet_file_0.txt

来自CODE的代码片 snippet_file_0.txt

来自CODE的代码片 snippet_file_0.txt

你可能感兴趣的:(java)

来自CODE的代码片
snippet_file_0.txt

来自CODE的代码片
snippet_file_0.txt

来自CODE的代码片
snippet_file_0.txt

来自CODE的代码片
snippet_file_0.txt

来自CODE的代码片
snippet_file_0.txt

来自CODE的代码片
snippet_file_0.txt

来自CODE的代码片
snippet_file_0.txt

来自CODE的代码片
snippet_file_0.txt

来自CODE的代码片
snippet_file_0.txt

来自CODE的代码片
snippet_file_0.txt

来自CODE的代码片
snippet_file_0.txt

来自CODE的代码片
snippet_file_0.txt

来自CODE的代码片
snippet_file_0.txt

来自CODE的代码片
snippet_file_0.txt