Java_API on JokemeBlog

Java 注解的简单学习

Sat, 15 Feb 2020 21:33:56 +0000

Java 注解（Annotation）

Java 注解其实并不难，从名字上你都知道注解是帮助 Java 代码执行的，它的形式跟接口很类似，不过前面多了一个 @ 符号

Java 元注解

@Retention

Retention 保留期，决定注解的生命时常，取值如下

SOURCE	只在源码阶段保留
CLASS	只被保留到编译进行的时候
RUNTIME	注解可以保留到程序运行的时候

eg：该注解被保留到运行时

1
2
3

@Retention(RetentionPolicy.RUNTIME)
public @interface Annotation {
}

- @Documented

它的作用是能够将注解中的元素包含到 Javadoc 中去

- @Target

Target 指定了注解运用的地方

ANNOTATION_TYPE	给一个注解进行注解
CONSTRUCTOR	给构造方法进行注解
FIELD	给属性进行注解
LOCAL_VARIABLE	给局部变量进行注解
METHOD	给方法进行注解
PACKAGE	给包进行注解
PARAMETER	给方法内的参数进行注解
TYPE	给一个类型进行注解，比如类、接口

- @Inherited

一个类被 @Inherited 注解过的注解进行注解的话，如果它的子类没有被任何注解应用的话，那么这个子类就继承了该类的注解。

- @Repeatable

是可重复的意思

Java 内置注解

@Deprecated 这个元素是用来标记过时的元素
@Override 子类要复写父类中的方法
@SuppressWarnings 忽略编辑器的警告 ⚠
@SafeVarargs 参数安全类型注解。它的目的是提醒开发者不要用参数做一些不安全的操作，它的存在会阻止编译器产生 unchecked 这样的警告。
@FunctionalInterface 函数式接口注解，函数式接口可以很容易转换为 Lambda 表达式

注解与反射。

注解通过反射获取。首先可以通过 Class 对象的 isAnnotationPresent() 方法判断它是否应用了某个注解

`1`	`public boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) {}`

然后通过 getAnnotation() 方法来获取 Annotation 对象。

`1`	`public <A extends Annotation> A getAnnotation(Class<A> annotationClass) {}`

或者是 getAnnotations() 方法。

`1`	`public Annotation[] getAnnotations() {}`

前一种方法返回指定类型的注解，后一种方法返回注解到这个元素上的所有注解。

如果获取到的 Annotation 如果不为 null，则就可以调用它们的属性方法了

注解应用实例

JUnit

public class JUnitTest {
    @Test
    public void solo(){
        System.out.println("Awesome Junit");
    }
}

Java collections框架的工具类

Sat, 28 Dec 2019 21:33:56 +0000

Collection 框架的工具类

Collections

sort 按照自然顺序排序

package sourceCode;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Collections_utils {
	public static void main(String[] args) {
		List<String> se = new ArrayList<String>();
		se.add("fdw");
		se.add("jokeme");
		se.add("dfipo");
		se.add("daase");
		Collections.sort(se);
		System.out.println(se);
			}
}
~~~~~~~~~~~~~~~~~~~~
[daase, dfipo, fdw, jokeme]

用法很简单： Collections.sort(List)

reverse 倒序排列自然排序的 List

Collections.reverse(se);
System.out.println(se);
~~~~~~~~~~~~~~~
[jokeme, fdw, dfipo, daase]

用法也很简单： Collections.reverse(List)

如果单独使用时，其效果和 reverseOrder() 作用一样

自定义排序方法

`1`	`Collections.reverseOrder(Comparator<T> cmp())`

自定义排序方法时就需要使用 reverseOrder() 并且需要自定义一个比较方法 ? 传进去

Collections.sort(se, Collections.reverseOrder(new compareByLength()));
System.out.println(se);
~~~~~~~~~~~~~~~
[fdw, daase, dfipo, jokeme]
~~~~~~~~~~~~~~~
package sourceCode;

import java.util.Comparator;

public class compareByLength implements Comparator<String> {
	@Override
	public int compare(String str1,String str2) {
		int temp = str2.length() - str1.length();
		return temp==0?str2.compareTo(str1):temp;
	}
}

**上面我们可以看出 reverseOrder() 就是万金油，不传参就是倒序排列自然排序的 List , 而传参就可以自定义我们需要的比较方法 < 注意 reverseOrder 要联合 sort 使用，只有 reverse 可以单独使用 > **

将非同步集合转为同步集合

Java IO简单操作文件

Sat, 28 Dec 2019 21:33:56 +0000

Java-IO

Java Input-Output 主要是用于文件的存储和读取，相关操作一般都会放在 Java.io 包中

File 类

file 类的方法是我们操作文件必不可少的，是必须要学习的类

使用示例：

package Java_IO;

import java.io.File;
import java.io.IOException;

public class fileClass {
	public static void main(String[] args) throws IOException {
		
		File se = new File("D:\\Frelon.txt");
		File we = new File("D:\\","sda.py");
		System.out.println(se+"~~~~"+we);
		
		File dir = new File("D:\\KW"+File.separator);
		File sdCard = new File (dir,"a.java");
		if(sdCard.createNewFile()) {
			System.out.println("Create File Successfully ! "+sdCard);
		}else {
			System.out.println("Filed!");
		}
	}
}

File类常见方法

获取文件路径

package Java_IO;

import java.io.File;

public class filePath {
	public static void main(String[] args) {
		File file = new File("a.sh");
		String str = file.getAbsolutePath();
		String str1 = file.getPath();
		System.out.println(str+"~~~~~"+str1);
	}
}
~~~~~~~~~~~~~~~~~~
D:\github\Hadoop_build\JavaLearn\a.sh~~~~~a.sh

getPath()只是获取相对路径 < 程序在哪运行，路径就是那里 >

getAbsolutePath()表示获取绝对路径

获取文件修改时间

package Java_IO;

import java.io.File;
import java.text.DateFormat;
import java.util.Date;

public class filePath {
	public static void main(String[] args) {
		File file = new File(".classpath");
		Long lon = file.lastModified();
		Date date = new Date(lon);
		String mod_time = DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG).format(date);
		System.out.println(lon+" >>>>> "+mod_time);
	}
}

`1`	`1575876750643 >>>>> 2019年12月9日下午03时32分30秒`

该方法并不困难，稍稍有难度的是如何把获取到的 Long 类型的数字转化为具体的时间

Date date = new Date(1575876750643l);
DateFormat time = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG);
String str = time.format(date);
System.out.println(str);

常见操作

boolean boof = file.createNewFile();     
boolean boo  = file.canExecute();        
boolean booa = file.canRead();           
boolean bood = file.canWrite();          
boolean booh = file.exists();            
boolean booj = file.isAbsolute();        
boolean book = file.isDirectory();       
boolean bool = file.isFile();            
boolean booz = file.isHidden();

认识即可，没有难度

获取文件夹内容

当操作文件夹时，肯定要知道这个文件夹里面有什么东西，我们才好操作，常用的方法有两种 list() , listFile() 但是建议用后者，因为list() 有的它也有，他有的方法**list()**没有

package Java_IO;

import java.io.File;

public class visitFile {
	public static void main(String[] args) {
		File alean = new File("c:\\");
		if (alean.exists()) {
			String[] dd = alean.list();
			for (String ss : dd) {
				System.out.println(ss);
			}
System.out.println("~~~~~~~~~~~~~~~~~~~~~~");
			File[] fo = alean.listFiles();
			for (File fs : fo) {
				if(fs.getName().contains("Logs")) {
					System.out.println(fs+" ~~~ "+fs.getName());
				}
			}
System.out.println("~~~~~~~~~~~~~~~~~~~~~~");
			Long sis = alean.getFreeSpace();
			System.out.println(alean + " " + sis / Math.pow(1024, 3) + "Gb" + " free!");
		} else {
			System.out.println("No this file");
		}
	}
}

文件过滤器

File[] str1  =  dir.listFiles(new fileFilterByName());
for (File strr : str1) {
	System.out.println(strr);
}
~~~~
package Java_IO;

import java.io.File;
import java.io.FileFilter;

public class fileFilterByName implements FileFilter {
	@Override
	public boolean accept(File arg0) {
		return arg0.isDirectory();
	}
}

它可以过滤出该 ?内的 ?,还可以过滤出 ?内的 ?,只需要把 fileFilterByName の accept() 方法改一下即可

public boolean accept(File arg0) {
	return arg0.isDirectory();
//	return arg0.isFile();
//  return arg0.isFile();
//  return arg0.getName().endSWith(".java")
}

文件名过滤器

package Java_IO;

import java.io.File;
import java.io.FilenameFilter;

public class filterByName implements FilenameFilter {
	private String se="";
	
	public filterByName(String se) {
		super();
		this.se = se;
	}
	public filterByName() {
		super();
	}
	
	@Override
	public boolean accept(File arg0, String arg1) {
		
		return arg1.endsWith(se);
	}

}
~~~~~~~~~~~~~~~~~~~~~~
package Java_IO;

import java.io.File;

public class FileFilter {
	public static void main(String[] args) {
		File file = new File("D:\\hadoop-2.8.5");
		String[] str = file.list(new filterByName(".txt"));
		for (String name : str) {
			System.out.println(name);
		}
	}
}

这种过滤器不常用，因为需要一个过滤器实现FileNameFilter, 实际 coding 我们可以使用FileFilter 替代，它不仅仅可以过滤文件夹 ?还可以过滤文件 ?

递归获取 ?内的内容

package Java_IO;

import java.io.File;
import java.io.IOException;
import java.nio.file.NoSuchFileException;

public class getAllFiles {

	public static void main(String[] args) throws IOException {
		File dir = new File("D:\\github");
		getAllFile(dir);
	}

	public static void getAllFile(File se) throws IOException {
		File[] dir1 = se.listFiles();
		if(!se.exists()) {
			throw new NoSuchFileException("No such Path");
		}
		for (File der : dir1) {
			if (der.isDirectory()) {
				getAllFile(der);
			} else {
				System.out.println("Visited " + der);
			}
		}
	}
}

什么是递归？

其实递归就是在方法内部调用该方法，该方法不断地进栈，在使用递归时，一定要有判断条件，否则一直递归下去会导致内存溢出

public void met(){
	void show();
}

public void show(){
	void met();
}

这就是一种递归，但是它是错误 ❌的递归，两个方法相互调用会导致栈内存溢出，

1
2
3

public void show(){
	void show();
}

这也是一种错误 ❌的递归，方法内部无线调用自己 ✌会导致栈内存溢出

1.3.1 使用递归删除 ?

package Java_IO;

import java.io.File;
import java.nio.file.NoSuchFileException;

public class deleteFiles {
	public static void main(String[] args) throws NoSuchFileException {
		File dir = new File("D:\\KWS");
		removeFiles(dir);
	}
	public static void removeFiles(File se) throws NoSuchFileException {
		File [] wow = se.listFiles();
		for(File wo : wow) {
			if(!wo.exists()) {
				throw new NoSuchFileException(null);
			}
			if(wo.isDirectory()) {
				removeFiles(wo);
			}else {
				Boolean esc = wo.delete();
				System.out.println("delete the file "+wo+" "+esc);
			}
		}
		Boolean esc = se.delete();
		System.out.println("delete the file "+se+" "+esc);
	}
}

递归删除很简单，只是需要注意，这个删除是不经过回收站的，会被直接删除，不可找回

还有就是需要判断该 ?有没有权限访问，要不然会报 java.lang.NullPointerException 异常，甚至还需要我们自己来抛一些 IO 异常

前三 part 测试

需求：

1
2

获取某个?内所有文件的集合
获取该?内某个?内的.txt文件,并存储到集合中打印?出来

package Java_IO;

import java.io.File;
import java.io.FilenameFilter;
import java.util.ArrayList;
import java.util.List;

public class IO_Test1 {
	public static void main(String[] args) {
		File dir = new File("c:\\tempfile");

		List<String> list = new ArrayList<String>();

		fileFilterByName filter = new fileFilterByName(".txt");

		getFile(dir, filter, list);

		for (String ser : list) {
			System.out.println(ser);
		}
	}

	private static void getFile(File file, fileFilterByName filter, List<String> list) {
		File[] fileName = file.listFiles();
		for (File se : fileName) {
			if (se.isDirectory()) {
				getFile(se, filter, list);
			} else {
				if (filter.accept(se)) {
					list.add(se.getPath());
				}
			}
		}
	}
}
~~~~~~~~~~~~~~~~~~~~
package Java_IO;

import java.io.File;
import java.io.FileFilter;

public class fileFilterByName implements FileFilter {
	private String str;
    
	public fileFilterByName(String str) {
		super();
		this.str = str;
	}
    
	public fileFilterByName() {
		super();
	}
	
	
	@Override
	public boolean accept(File arg0) {
		return arg0.getName().endsWith(this.str);
	}

}

给自己点个赞 ?,我真厉害?

FileOutputStream 向 ?内写入内容

package Java_IO;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class writeIntoFile {
	private static final String Line_separator = System.getProperty("line.separator");

	public static void main(String[] args) throws IOException {
		File dir = new File("c:\\tempfile");
		if(!dir.exists()) {
			dir.mkdir();
		}
		String str ="i Love Java";
		FileOutputStream fops = null;
		try {
			fops = new FileOutputStream("c:\\tempfile\\fops.java",true);
			String ssr = Line_separator+"Hello World"+Line_separator;
			fops.write(ssr.getBytes());
			fops.write(str.getBytes());
			fops.write(ssr.getBytes());
			System.out.println("写入成功");
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if(fops!=null) {}
			fops.close();
		}
	}
}

写入内容很容易，只需要调用一下write()方法即可，但是难点就是处理各种Exception ,我们需要考虑到各种各样的异常

比如 FileNotFoundException,,,NullPointerException 等等等，因为一旦出现了这些问题我们的代码可能就占用了相关的系统资源，但是程序执行失败后，我们并没有释放该资源，如此循环往复就会导致系统的卡慢，甚至死机重启，这里我们经常使用try catch finally 方法来解决，需要执行的代码放在try 里面，在finally 里面放 close()方法，保证我们的代码在申请完资源以后，无论是否报错，都可以被释放掉，还有一点就是如果我们使用try catch finally 那我们一定不能在try里面 new 对象，因为到时候finally 关闭资源时会找不到对象 ?的

还有write() 方法是会覆盖掉文件内部的内容的，如果我们需要在当前内容上继续添加内容，那就需要在创建对象时加一个true 表示续写该文件，代码如下

`1`	`FileOutputStream fops = new FileOutputStream("c:\\tempfile\\fops.java",true);`

FileInputStream 读取 ?内容

FileInputStream 类和 FileOutputStream 类有许多的共同点，都需要传一个 File 类的对象(new 对象时要保证 Path✔无误，要不然很容易造成空指针异常) 还有就是在使用完资源以后要及时释放掉资源，还有要注意的是异常の处理，如果没有处理好异常也会导致我们无法释放掉资源，导致程序占用过多的系统资源，使系统卡慢

❌ read() 入门级读取

package Java_IO;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class readFile {
	private static final int LIMSize = 8192;

	public static void main(String[] args) throws IOException {
		File dir = new File("c:\\tempfile\\fops.java");

		FileInputStream fipts = new FileInputStream(dir);

		int byt;
		while ((byt = fipts.read()) != -1) {
			System.out.println(byt);
		}

		fipts.close();
	}
}

日常开发中，基本上用不上 PASS ❌

❌ read() 初级读取

package Java_IO;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class readFile {
	private static final int LIMSize = 8192;

	public static void main(String[] args) throws IOException {
		File dir = new File("c:\\tempfile\\fops.java");
		byte[] buf = new byte[2];

		FileInputStream fip = new FileInputStream(dir);

		int len = fip.read(buf);
		System.out.println(len + "~~~" + new String(buf));

		fip.close();
	}
}

日常开发中，基本上用不上 PASS ❌

✔ read() 进阶级读取

package Java_IO;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class readFile {
	private static final int LIMSize = 8192;

	public static void main(String[] args) throws IOException {
		File dir = new File("c:\\tempfile\\fops.java");
				FileInputStream fips = new FileInputStream(dir);
		byte[] by = new byte[LIMSize];

		int length = 0;

		while ((length = fips.read(by)) != -1) {
			System.out.println(new String(by, 0, length));
		}
		fips.close();

	}
}

日常开发中可以使用，✔建议根据需要改变缓冲区的大小，一般建议设置成 :8192

✔ read()高级读取

package Java_IO;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class readFileAdvantage {
	public static void main(String[] args) throws IOException {
		File dir = new File("c:\\tempfile\\fops.java");
		FileInputStream fips = new FileInputStream(dir);
		byte [] byt = new byte [fips.available()];
		fips.read(byt);
		System.out.println(new String(byt));
		fips.close();
	}
}

✔这种是我比较喜欢的一种方法，简洁好用，也不用考虑缓冲区大小 ?,而且一般 File 对象没有问题也就不会出错啊(相对于前面几个),这是重点 ✔,圈起来！下次会考！!!

但是！!但是！!但是！这种方法只是比较适合处理比较小的文件，如果处理好几个 G 的文件，当场挂..所以呢，还是进阶和高级一起用

FileOutputStream 和 FileInputStream 一起读写文件

低级写法

package Java_IO;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class IO_CopyFile {

	public static void main(String[] args) throws IOException {
		File dir = new File("C:\\tempfile\\fops.java");
		FileInputStream fis = new FileInputStream(dir);

		File dir1 = new File("C:\\tempfile\\fops.txt");
		FileOutputStream fos = new FileOutputStream(dir1);
		int len = 0;
		while ((len = fis.read()) != -1) {
			fos.write(len);
		}
		fis.close();
		fos.close();
	}
}

不推荐这种写法，因为效率比较低，读取一个写入一个，太浪费时间

高级写法

package Java_IO;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

import APICourceCode.dateAPI;

public class copyFileByBuf {
	public static void main(String[] args) throws IOException {
		dateAPI date = new dateAPI();
		date.getDate();
		File dir = new File("d:\\tempfile\\idea.exe");
		FileOutputStream fos = null;
		FileInputStream fis = null;
		try {
			fis = new FileInputStream(dir);
			fos = new FileOutputStream("d:\\tempfile\\idea.wilu");

			byte[] buf = new byte[10240];

			int len = 0;
			while ((len = fis.read(buf)) != -1) {
				fos.write(buf, 0, len);
			}
		} catch (IOException e) {
			throw new IOException();
		} finally {
			fis.close();
			fos.close();
			date.getDate();
			System.out.println("Copy Over");
		}

	}
}

我无聊就试了试，这个byte 数组の长度对IO の性能影响有多大，就把长度从 10,102,1024,2048,4096,8192,10240 都试了个遍，得出以下答案：

时间\byte 长度	10	102	1024	2048	4096	8192	10240	20480
Start	19:38:27	19:53:42	19:54:52	19:55:50	19:56:25	19:57:05	19:57:40	19:58:16
Stop	19:44:33	19:54:19	19:54:57	19:55:54	19:56:28	19:57:08	19:57:42	19:58:18
time	366s	37s	5s	4s	3s	3s	2s	2s

测试所使用的文件大小为： 584935KB 大约是 571MB

可以看出 byte 数组的长度也是越大越好的，只要你内存足够大，磁盘性能足够强，理论上是可以做到一秒内复制任何文件的，可是！! 科技日益发达的今天电脑内存和磁盘还依然是一个瓶颈，有待我们突破啊，So 为了适应各种大小的文件，还是选择大小为8192 或者10240 也是可以的

Buffer 缓冲区

buffer 原理就是调用一片内存，作为缓冲区，然后再为 FileInput/OutputStream 使用，原理和上面的相似

使用示例

package Java_IO;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class buffer {
	public static void main(String[] args) throws IOException {
				copyfile();
	}
	public static void copyfile() throws IOException {
		File dir  = new File("d:\\LinuxSoftware_VariedOS\\Python-3.8.0.tgz");
		
		FileInputStream pis = new FileInputStream(dir);
		FileOutputStream pos = new FileOutputStream("d:\\tempfile\\Python.wilu");
		
		BufferedInputStream bufpis = new BufferedInputStream(pis);
		BufferedOutputStream bufpos = new BufferedOutputStream(pos);
		
		byte [] buf = new byte[8192];
		int len = 0;
		while((len=bufpis.read(buf))!=-1) {
			bufpos.write(buf,0,len);
		}
		bufpis.close();
		bufpos.close();
		System.out.println("Copy over");
	}  
}

字符读写

使用 I/O-Stream-Reader/Writer

由于中文一个字符占两字节，所以我们不能像读写英文那样，直接操作数据了，

package Java_IO;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

public class StreamReader {
	public static void main(String[] args) throws IOException {
		FileInputStream fis = new FileInputStream("D:\\tempfile\\fpos.java");
		FileOutputStream fos = new FileOutputStream("D:\\tempfile\\pofs.c",true);
		
		InputStreamReader isr = new InputStreamReader(fis);
		OutputStreamWriter osw = new OutputStreamWriter(fos,"utf-8");
		
		int in ;
		while((in = isr.read()) != -1) {
			osw.write(in);
		}
		
		isr.close();
		osw.close();
		System.out.println("Copy over");
	}
}

中文处理时比较的麻烦，因为各种电脑支持的编码可能不一样，就导致乱码问题，这时候我们在new 对象的时候就需要指定我们所需要的编码方式，今天就因为编码就倒腾了半天的时间 ⏰

所以为了保险起见，在创建 FileOutputStream 的时候还是加上 UTF-8 好一点

FileReader/FileWriter 类

FileReader/FileWriter 其实就是简化了FileOutputStream ＆ FileOutputStream の使用过程，但是缺点( •̀ ω •́ )y 非常明显，就是不支持设置编码方式，默认的是 ISO-8859-1 or US-ASCII ,非常容易导致乱码 ~%?…,# *’☆&℃ $︿★?

处理乱码也不难，就是不用这个类 ?

way 1

`1`	`BufferedWriter writer = new BufferedWriter (new OutputStreamWriter (new FileOutputStream (filePath,true),"UTF-8"));`

虽然这也是一种解决办法吧，但是如果一点要用的话那就只能用下面这种方法了

way 2

`1`	`Writer writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream ("String"), "UTF-8"));`

让FileWriter 继承 Write の编码方式，不过也不好用

FileReader / FileWrite 初级写法

package Java_IO;

import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class fileWriter {
	public static void main(String[] args) throws IOException {
		FileOutputStream fos = new FileOutputStream("D:\\tempfile\\pofs.c");
		OutputStreamWriter osw = new OutputStreamWriter(fos,"UTF-8");
		
		FileReader fr = new FileReader("D:\\tempfile\\fpos.java");
		FileWriter fw = new FileWriter("D:\\tempfile\\pofs.c");
		
		int in;
		while((in=fr.read())!=-1) {
			fw.write((char)in);
		}
		fr.close();
		System.out.println(fw.getEncoding());
		fw.close();
		osw.close();
		System.out.println("Copy over");
	}
}

FileReader / FileWrite 高级写法

package Java_IO;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class IO_SimplifyChinese {
	public static void main(String[] args) throws IOException {
		copyChineseChar();
	}
	public static void copyChineseChar() throws IOException {
		FileReader fr = new FileReader("D:\\LinuxSoftware_VariedOS\\jdk-8u231-linux-x64.tar.gz");
		FileWriter fw = new FileWriter("D:\\tempfile\\jdk8.wuli");
		
		char [] chara = new char[2048];
		int len ;
		while ((len=fr.read(chara))!= -1) {
			fw.write(chara,0,len);
		}
		fr.close();
		fw.close();
		System.out.println("copy over");
	}
}

BufferedReader / BufferedWriter

主要是利用缓冲区来提高读写效率，也没有啥难处，会用就可以了

package Java_IO;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Buffered_IO {
	public static void main(String[] args) throws IOException {
		buff();
	}
	public static void buff() throws IOException {
		FileReader fr = new FileReader("D:\\tempfile\\fos.java");
		BufferedReader br = new BufferedReader(fr);
		
		FileWriter fw = new FileWriter("D:\\tempfile\\copyed_fos.wuli");
		BufferedWriter bw = new BufferedWriter(fw);
		
		char [] chara = new char[2048];
		
		int in ;
		while((in=fr.read(chara))!= -1) {
			bw.write(chara,0,in);
		}
		br.close();
		bw.close();
		System.out.println("Copy over");
	}
}

Final 写在最后：

在经过学习后，我发现字节流和字符流都用于复制文件，但字符流的出现主要是为了解决与字符相关的问题，所以不适合复制文件(编码原因),字符流复制文件时可能会出现莫名其妙的问题导致复制后的文件破损无法使用，但字节流就不存在这种问题所以得出

`1`	`复制文件时使用字节流:复制文本文件时使用字符流`

简单的Java泛型学习

Sat, 28 Dec 2019 21:33:56 +0000

泛型

泛型特性

百度得如下解释：

泛型是程序设计语言的一种特性,允许程序员在强类型程序设计语言中编写代码时定义一些可变部分，那些部分在使用前必须作出指明。各种程序设计语言和其编译器、运行环境对泛型的支持均不一样。将类型参数化以达到代码复用提高软件开发工作效率的一种数据类型。泛型类是引用类型，是堆对象，主要是引入了类型参数这个概念。

举个栗子

List Li = new ArrayList();
Li.add("sdn");
Li.add(90);

for (Object se :Li){
	System.out.println(se);   
}

`1`	`java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String`

典型的类型转换异常，Integer不能被转换成String

正确的写法如下：

`1`	`List<String> Li = new ArrayList<String>();`

泛型的使用

泛型有三种使用方式，分别为：泛型类、泛型接口、泛型方法

泛型类

泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种容器类，如：List、Set、Map。

一个最普通的泛型类：

public class examples<Human>{ 
    private Human key;
    public examples(Human key) { 
        this.key = key;
    }
    public Human getKey(){ 
        return key;
    }
}

注意事项

泛型的类型参数只能是类类型，不能是简单类型。

不能对确切的泛型类型使用instanceOf操作，编译时会出错。

泛型接口

泛型接口与泛型类的定义及使用基本相同

1
2
3

public interface killSky<Gun> {
    public Gun next();
}

实现泛型接口的类也必须要保证该类的泛型和接口保持一致

class Fun<Gun> implements killSky<Gun>{
    @Override
    public Gun next() {
        return null ;
    }
}

泛型通配符

在写代码时可能会遇到下面的情况，通配符就会统统匹配

public static void printCollection(Collection<?> coll) {
		for (Object obj:coll){
			System.out.println(obj);
		}

泛型方法

泛型类，是在实例化类的时候指明泛型的具体类型，那么泛型方法，就是在调用方法的时候指明泛型的具体类型。

静态方法与泛型

静态方法有一种情况需要注意一下，那就是在类中的静态方法使用泛型：静态方法无法访问类上定义的泛型；如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。

即：如果静态方法要使用泛型的话，必须将静态方法也定义成泛型方法。

public class StaticGenerator<T> {
    ....
    ....
    public static <T> void show(T t){

    }
}

泛型上下边界

在使用泛型的时候，我们还可以为传入的泛型类型实参进行上下边界的限制，如：类型实参只准传入某种类型的父类或某种类型的子类。

为泛型添加上边界，即传入的类型实参必须是指定类型的子类型

public void showKeyValue1(Generic<? extends Number> obj){
    System.out.println(obj)
} 
public void showKeyValue1(Generic<? super Number> obj) {
    System.out.println(obj)
}

//在泛型方法中添加上下边界限制的时候，必须在权限声明与返回值之间的<T>上添加上下边界，即在泛型声明的时候添加
//public <T> T showKeyName(Generic<T extends Number> container)，编译器会报错："Unexpected bound"
public <T extends Number> T showKeyName(Generic<T> container){
    System.out.println("container key :" + container.getKey());
    T test = container.getKey();
    return test;
}

看到了很多文章中都会提起泛型数组，经过查看 sun 的说明文档，在 Java 中是”不能创建一个确切的泛型类型的数组”的。

也就是说下面的这个例子是不可以的：

`1`	`List<String>[] ls = new ArrayList<String>[10];`

而使用通配符创建泛型数组是可以的，如下面这个例子：

`1`	`List<?>[] ls = new ArrayList<?>[10];`

这样也是可以的：

`1`	`List<String>[] ls = new ArrayList[10];`

下面使用Sun 的一篇文档的一个例子来说明这个问题：

Java中的collections的map

Sat, 28 Dec 2019 21:17:12 +0000

Collection-Map

Map--|双列集合,一次存一对键值对,必须保证唯一性
	 --|HashMap:哈希表,不同步,允许空的Key,Value
	 --|TreeMap:二叉树,线程不同步,可以对Map集合的键?排序
	 --|Hashtable:哈希表,线程同步效率低下,不允许空的Key,Value

Map 集合共性功能

添加	V put(K,V) / putAll(Map<K,V> map)
删除	V remove(K) / void clear()
判断	Boolean containsKey / Value()
获取	V get(K) / int size()

注意：如果对同一个键多次存储会出现值被覆盖的现象

Map 集合取出键值对方法

迭代器取出法

package sourceCode;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class collMap {
	public static void main(String[] args) {
		Map<Integer,String> se = new HashMap<Integer,String>();
		se.put(1, "Now");
		se.put(5, "aset");
		se.put(6, "kEREd");
//		System.out.println(se);
		Set<Integer> keySet = se.keySet();
		for (Iterator<Integer> iter = keySet.iterator(); iter.hasNext();) {
			Integer ssr = (Integer) iter.next();
			System.out.println(se.get(ssr));
		}
	}
}

Map.Entry

		Set<Map.Entry<Integer, String>> Solo = se.entrySet();
		for (Iterator<Map.Entry<Integer, String>> itera = Solo.iterator(); itera.hasNext();) {
			Map.Entry<Integer, String> me = itera.next();
			Integer er =me.getKey();
			String  sun =me.getValue();
			System.out.println(er+"::::"+sun);			
		}

这里解释以下Map.Entry 其实，Entry就是Map接口内的一个接口

它随着Map的加载而加载

interface Map{
	public static interface Entry {
		
	}
}
class xxx implements Map.Entry{

}

Values 方法取出键值对

Collection<String> value = se.values();
for (Iterator<String> uuid = value.iterator(); uuid.hasNext();) {
	String dock =uuid.next();
	System.out.println(dock);
}

三种方法结果如下：

Now
aset
kEREd
~~~~~~~~~~~
1::::Now
5::::aset
6::::kEREd
~~~~~~~~~~~
Now
aset
kEREd

关于 Map.Entry 方法

其实Map.Entry可以直接写为Entry 方法，因为我在敲代码的时候偶然发现，不敲 Map. 程序依然可以正常运行

百度得：

1
2
3

Entry是Map中的一个静态内部类，用来表示Map中的每个键值对。除非使用了静态导入:import static java.util.Map.*
除了使用静态导入外，还可以直接导入这个类，因为它是public的。即:import java.util.Map.Entry。
导入后也可以在当前空间直接使用Entry。

Java时间类api

Sun, 22 Dec 2019 21:33:56 +0000

时间类 API

在日常学习生活中，我们经常遇到时间相关的问题，现在虽然 Date 类已经不是主流了，但任然有许多方法要学习

DateFormat

使用示例

package APICourceCode;

import java.text.DateFormat;
import java.util.Date;

public class dateAPI {
	public static void main(String[] args) {
		Date date = new Date();
		DateFormat ses = DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.FULL);
		String sesa = ses.format(date);
		System.out.println(sesa);
	}
}

其常见的Style如下

FULL:2019年12月16日 星期一 下午06时38分17秒 CST
LONG:2019年12月16日 下午06时39分20秒
MEDIUM:2019-12-16 18:39:41 (默认方式)
SHORT:19-12-16 下午6:40

如果需要自定义的格式，就需要按照下面的表格自定义，自定义以后，系统自带的Style将不生效

字母	意义
y	年
M	月份
w	年份中的周数
W	月份中的周数
d	月份中的天数
D	年份中的天数
F	月份中的星期
E	星期中的天数
a	am/pm 表示上下午
H	一天中的小时数(0-23)
h	am/pm 中的一天小时数(1-12)
m	小时中的分钟数
s	分钟中的秒数
S	毫秒数
z	PST;GMT 时区

package APICourceCode;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

public class dateAPI {
	public static void main(String[] args) {
		Date date = new Date();
		DateFormat ses = DateFormat.getDateTimeInstance();
		ses = new SimpleDateFormat("yyyy/MM/dd HH-mm-ss-SS");
		String sesa = ses.format(date);
		System.out.println(sesa);
		
	}
}

总结：

DateFormat方法其实很简单，

① 首先new一个Date类对象，就不用管了

② 调用DateFormat方法对象(不需要 new),生成自定义的Style

③ 使用字符串接收DateFormat对象的Format方法，需要传Date类的对象

DateFormat 反解析

使用示例：

package APICourceCode;

import java.text.DateFormat;
import java.text.ParseException;
import java.util.Date;

public class ReverseDateFormat {
	public static void main(String[] args) throws ParseException {
		String str = "2019-07-02";
		DateFormat se = DateFormat.getDateInstance();
		Date date =se.parse(str);
		System.out.println(date);
	}
}

Calendar

使用示例：

package APICourceCode;

import java.util.Calendar;

public class CalenderL {
	public static void main(String[] args) {
		Calendar se = Calendar.getInstance();
		
		se.add(Calendar.YEAR, 1);
		
		int year = se.get(Calendar.YEAR);
		int month = se.get(Calendar.MONTH)+1;
		int day = se.get(Calendar.DAY_OF_MONTH);
		int hours = se.get(Calendar.HOUR_OF_DAY);
		int minute = se.get(Calendar.MINUTE);
		int sec = se.get(Calendar.SECOND);
		System.out.println(year + "-" + month + "-" + day + "-" + hours + "-" + minute + "-" + sec);
	}
}
----------
2020-12-16-20-16-53

常见的Calendar参数

java.util.GregorianCalendar[
time=1576496255445,
firstDayOfWeek=1,
YEAR=2019,
MONTH=11,
WEEK_OF_YEAR=51,
WEEK_OF_MONTH=3,
DAY_OF_MONTH=16,
DAY_OF_YEAR=350,
DAY_OF_WEEK=2,
DAY_OF_WEEK_IN_MONTH=3,
HOUR=7,
HOUR_OF_DAY=19,
MINUTE=37,
SECOND=35,
MILLISECOND=445]

日期的偏移

`1`	`se.add(Calendar.MONTH, 1);`

个人认为作用不是很大

Java collection

Fri, 20 Dec 2019 21:33:56 +0000

collection集合

1
2
3

collection--|
		   |--list:有序,有索引,允许重复元素
		   |--set:不允许重复元素,元素存取无序

共性功能

a.添加

1
2

Boolean add (Obj obj);//添加单个对象
Boolean addAll (Collection c);//添加一组的collection的对象

b.删除

1
2
3

void clear();//清空collection内所有对象/元素
Boolean remove (Object o);//删除collection里面某个对象
Boolean removeAll (Collection c);//删除一组的collection

c.获取长度

`1`	`int size();`

d.判断

1
2
3

Boolean isEmpty();
Boolean contains(Object o);
Boolean containsAll(Collection c)

e.集合转数组

1
2

toArray();
toArray([]);

f.迭代器

`1`	`Iterator iterator();`

List集合

list集合的具体子类

List----
	|-- Vector:数组数据结构,长度可变,线程同步<多线程安全>,但是速度比较慢(现在已经不常用-被ArrayList替代),长度按数组长度的100%延长
	|-- ArrayList:数组结构,长度可变,线程不同步<多线程不安全>.查,速度快,增 删 改速度慢,长度按数组长度的50%延长
	|-- LinkedList:链表结构,线程不同步<多线程不安全>,增,删,改,速度快,查 速度慢

迭代器使用注意

1
2
3

Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(Unknown Source)
	at java.util.ArrayList$Itr.next(Unknown Source)

遇到这种在使用迭代器时还修改迭代器内元素的时候，JVM会报错，这时候就需要用ListIterator

犯错实记:

package sourceCode;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class listTest {
	public static void clean(ArrayList<person> jsr) {
		List<person> dot = new ArrayList<person>();

		for (ListIterator<person> lis = jsr.listIterator(); lis.hasNext();) {
			person pop = lis.next();
			if (!dot.contains(pop)) {
				dot.add(pop);
			}
		}
		jsr.clear();
		jsr.addAll(dot);
	}

	public static void main(String[] args) {
		ArrayList<person> jsr = new ArrayList<person>();
		jsr.add(new person(20, "frelon"));
		jsr.add(new person(21, "frelon"));
		jsr.add(new person(23, "frelon"));
		jsr.add(new person(21, "frelon"));
		clean(jsr);
		System.out.println(jsr);
	}

}

package sourceCode;

public class person {
	private int age;
	private String name;

	public person(int age, String name) {
		super();
		this.age = age;
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Override
	public String toString() {
		return "person [age=" + age + ", name=" + name + "]";
	}
	


	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		person other = (person) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}

	public boolean equals(person obj) {
		if (this==obj) {
			return true;
		}
			return this.name.equals(obj.name)&&this.age==obj.age;
	}
}

上面这个例子，是我用了两天时间得出Java面向接口编程的一个实例

为什么说用了两天时间呢？

因为我一直都不太明白 Java 面向对象编程的具体表现，所以在写代码的时候也比较呆板，再者就是我还没有搞明白接口里面的类有没有被子类所实现

`1`	`ArrayList<person> dot = new ArrayList<person>();`

这就是我犯错的一段代码，我总是用List的子类 ArrayList来new新对象，而我Overwrite的方法已经被ArrayList实现，使用无论我怎么调用都还是无法调用到我自己 Overwrite后的代码

`1`	`List<person> dot = new ArrayList<person>();`

这就是导致我卡了两天的细节，我用List new对象以后代码完美执行了

这就是因为没有掌握面向对象编程的思想，犯下的一个低级错误

重写 equals和hashcode

LinkedList

a.特有方法

addFirst()	removeFirst()	getFirst()
#添加到第一个	#删除第一个	#获取第一个
addlast()	removeLast()	getLast()
#添加到最后一个	#删除最后一个	#获取最后一个

JDK1.6以后推荐使用下列方法替代，这样在遇到空值时就不会报错而是返回null

offerFirst()	pollFirst()	peekFirst()
#添加到第一个	#删除第一个	#获取第一个
offerLast()	pollLast()	peekLast()
#添加到最后一个	#删除最后一个	#获取最后一个

b.实战演练

实现先进后出

package sourceCode;

import java.util.LinkedList;

public class linkedlist_test {
	public static void main(String[] args) {
		test loser = new test();
		loser.setKail("hello");
		loser.setKail("CNN");
		loser.setKail("Love China");
		while (loser.Kailisempty()) {
			System.out.println(loser.getKail());
		}
	}
}

class test {
	private LinkedList<Object> kail;

	public Object getKail() {
		return kail.pollLast();
	}

	public Boolean Kailisempty() {
		if (kail.isEmpty()) {
			return false;
		} else if (!kail.isEmpty()) {
			return true;
		}
		return false;
	}

	@Override
	public String toString() {
		return "test [kail=" + kail + "]";
	}

	public void setKail(Object obj) {
		this.kail.addLast(obj);
	}

	public test() {
		kail = new LinkedList<Object>();
	}
}

Set 集合

Set--:不允许重复元素,方法和collection相同.set集合只能用Iterator取出元素
	|--Hashset:不保证存入和取出的顺序一致,不允许重复,效率高 
			 |--LinkedHashSet:有序的HashSet表,不允许重复	
	|--Treeset:可以对元素进行排序,其排序方式需要元素具备比较功能,且实现CompareTo()方法,且不允许存储相同元素的方法是依据compareto()返回值是否为0,其数据结构为二叉树结构,

HashSet

HashSet主要就是靠hashcode()表来确定元素排列的，在使用时必须要重写hashCode()方法，而hashCode()方法内部又调用到了equals()方法来解决Hash 冲突,所以在使用时必须要Overwrite这两个方法

HashSet 使用示例

package sourceCode;

import java.util.HashSet;
import java.util.Set;

public class hashset {
	public static void main(String[] args) {
		Set doThat = new HashSet();
		
		doThat.add(new person(13,"coco"));
		doThat.add(new person(22,"peon"));
		doThat.add(new person(23,"frelon"));
		doThat.add(new person(23,"frelon"));
		
		System.out.println(doThat);
	}
}

person类同上,这里仅写出 Overwrite 部分
	@Override
	public boolean equals(Object obj) {
		if (this==obj) {
			return true;
		}	
			person se = (person) obj;
			return this.name.equals(se.name)&&this.age==se.age;
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

TreeSet

Comparable 接口的学习

Exception in thread "main" java.lang.ClassCastException: sourceCode.person cannot be cast to java.lang.Comparable
	at java.util.TreeMap.compare(Unknown Source)
	at java.util.TreeMap.put(Unknown Source)
	at java.util.TreeSet.add(Unknown Source)

这个异常对于学习 TreeSet 的我是一脸懵逼啊 ?,啥啥啥啊，就报了个异常，再看看我这代码没有错啊，编辑器也没有报错啊！

package sourceCode;

import java.util.Set;
import java.util.TreeSet;

public class treeSetLearn {
	public static void main(String[] args) {
		Set ssf = new TreeSet();
		ssf.add(new person(12, "hfh"));
		ssf.add(new person(19, "frelon"));
		ssf.add(new person(13, "jokoe"));

	}
}

遂百度，知，需要person 类 implements comparable 接口并 Overwrite 该接口的 CompareTo() 方法

package sourceCode;

public class person implements Comparable {
~~~
    略
~~~
    方法一:只能按年龄排序,忽略了姓名
	public int compareTo(Object osi) {
		person seao = (person) osi;
		if(this.age>seao.age) {
			return 1;
		}
		if(this.age<seao.age)
			return -1;
		return 0;
	}
    
~~~
    方法二:完美方案?
    public int compareTo(Object osi){
        int temp = this.age-seao.age;
        return temp==0?this.name.compareTo(osi.name):temp;
    }

按照方法二改完以后，成功按照年龄(从小到大)排序，并且同姓名，同年龄算一个人，不存进去

实现Comparator接口示例

当我们需要需要对没有比较功能的元素进行排序时or 自定义元素排序方式时，我们就不能再依赖通过实现Comparable接口的**CompareTo()**方法，而是要自定义一个新的比较器

使用自定义的比较器对TreeSet排序

package sourceCode;

import java.util.Set;
import java.util.TreeSet;

public class diySavePerson {
	public static void main(String[] args) {
		Set t1 = new TreeSet(new diyCompare());
		t1.add(new person(12,"frelon"));
		t1.add(new person(29,"lion"));
		t1.add(new person(29,"aion"));
		t1.add(new person(19,"zoco"));
		for(Object se : t1) {
			System.out.println(se);
		}
	}
}

package sourceCode;

import java.util.Comparator;

public class diyCompare implements Comparator<Object> {

	@Override
	public int compare(Object arg0, Object arg1) {

		person p1 = (person) arg0;
		person p2 = (person) arg1;

		int temp = p1.getName().compareTo(p2.getName());
		int temp2 = p1.getAge() - p2.getAge();

		return temp == 0 ? temp2 : temp;
	}

}

对根据字符长短排序

下面的方案主要是根据名字的长短来排序的，如长短相同则根据名字的hashCode决定谁在前面

package sourceCode;

import java.util.Set;
import java.util.TreeSet;

public class diySavePerson {
	public static void main(String[] args) {
		Set<String> set1 = new TreeSet<String>( new diyCompare()); 
		set1.add("jeAreF");
		set1.add("jpwdth");
		set1.add("jogeth");
		set1.add("jokeme");
		set1.add("jsrdds");
		for (Object se: set1) {
			System.out.println(se);
		}
	}
}

package sourceCode;

import java.util.Comparator;

public class diyCompare implements Comparator<Object> {

	@Override
	public int compare(Object arg0, Object arg1) {
		String str1 = (String)arg0;
		String str2 = (String)arg1;
		int temp1=str1.length()-str2.length();
		int sss = str1.hashCode();
		int ssd = str2.hashCode();
		return temp1==0?sss-ssd:temp1;
	}

}

三元运算符

语法为：条件表达式？表达式 1：表达式 2。

说明：问号前面的位置是判断的条件，判断结果为 boolean 型，为 true 时调用表达式 1，为 false 时调用表达式 2。

Java的equals和contains的一些区别

Fri, 20 Dec 2019 21:33:56 +0000

equals() && contains()

Java 中常见的比较有equals和hashcode

今天在学习的时候就遇到了一个头疼的问题(菜鸟级的我有大大疑问)

在比较两个对象内的元素时，无论是使用equals还是hashcode都始终得不到我想要的结果。遂百度，记此文

那么这两种方法到底有什么区别呢？

equals()方法是根类 Object 的默认方法，查看 Object 中 equals()的默认实现：

public boolean equals(Object obj) {
    return (this == obj);
    }
✅

可以看出没有重写过的 equals()方法和 == 是一样的，都是比较两个对象引用指向的内存地址是否一样判断两个对象是否相等。

也就是说，基本上每次都要Overwrite这个方法

hashCode是JDK根据对象的地址或者字符串或者数字计算该对象的哈希码值的方法。

hashcode 和 equals 两者必须同时重写。

注意在类中，有一些 equals 方法 OverWrite 时必须要传入 Object 类型

public boolean equals (person obj){
	return (this == obj);
	}	
❌
//这样写就是错误的,equals()方法不允许传入非 Object 类

Java_API on JokemeBlog

Java 注解的简单学习

Java 注解（Annotation）

Java 元注解

Java 内置注解

注解与反射。

注解应用实例

Java collections框架的工具类

Collection 框架的工具类

Collections

sort 按照自然顺序排序

reverse 倒序排列自然排序的 List

自定义排序方法

将非同步集合转为同步集合

Java IO简单操作文件

Java-IO

File 类

使用示例：

File类常见方法

获取文件路径

获取文件修改时间

常见操作

获取文件夹内容

文件过滤器

文件名过滤器

递归 获取 ?内的内容

1.3.1 使用递归删除 ?

前三 part 测试

FileOutputStream 向 ?内写入内容

FileInputStream 读取 ?内容

❌ read() 入门级读取

❌ read() 初级读取

✔ read() 进阶级读取

✔ read()高级读取

FileOutputStream 和 FileInputStream 一起读写文件

低级写法

高级写法

Buffer 缓冲区

使用示例

字符读写

使用 I/O-Stream-Reader/Writer

FileReader/FileWriter 类

FileReader / FileWrite 初级写法

FileReader / FileWrite 高级写法

BufferedReader / BufferedWriter

Final 写在最后：

简单的Java泛型学习

泛型

泛型特性

举个栗子

泛型的使用

泛型类

泛型接口

泛型通配符

泛型方法

静态方法与泛型

泛型上下边界

Java中的collections的map

Collection-Map

Map 集合共性功能

Map 集合取出键值对方法

迭代器取出法

Map.Entry

Values 方法取出键值对

三种方法结果如下：

关于 Map.Entry 方法

Java时间类api

时间类 API

DateFormat

使用示例

总结：

DateFormat 反解析

使用示例：

Calendar

使用示例：

常见的Calendar参数

日期的偏移

Java collection

collection集合

共性功能

递归获取 ?内的内容