JavaSE 进阶 (10) IO

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public static void main(String[] args){
	//创建字符输出流的对象
	//FileWriter fw = new FileWriter(new File("charstream\\a.txt"));
	FileWriter fw = new FileWriter("charstream\\a.txt");

	//写出数据
	fw.write(97);	//a
	fw.write(98);	//b
	fw.write(99);	//c
	
	//释放资源
	fw.close();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

public static void main(String[] args){
	//创建字符输出流的对象
	//FileWriter fw = new FileWriter(new File("charstream\\a.txt"));
	FileWriter fw = new FileWriter("charstream\\a.txt");

	//写出数据
	char[] chars = {97, 98, 99, 100, 101};
	fw.write(chars);
	
	//释放资源
	fw.close();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

public static void main(String[] args){
	//创建字符输出流的对象
	//FileWriter fw = new FileWriter(new File("charstream\\a.txt"));
	FileWriter fw = new FileWriter("charstream\\a.txt");

	//写出数据
	char[] chars = {97, 98, 99, 100, 101};
	fw.write(chars, 0, 3);  //abc
	
	//释放资源
	fw.close();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

public static void main(String[] args){
	//创建字符输出流的对象
	//FileWriter fw = new FileWriter(new File("charstream\\a.txt"));
	FileWriter fw = new FileWriter("charstream\\a.txt");

	//写出数据
	String line = "程序员abc";
	fw.write(line);
	
	//释放资源
	fw.close();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

public static void main(String[] args){
	//创建字符输出流的对象
	//FileWriter fw = new FileWriter(new File("charstream\\a.txt"));
	FileWriter fw = new FileWriter("charstream\\a.txt");

	//写出数据
	String line = "程序员abc";
	fw.write(line, 0, 2);	//程序
	
	//释放资源
	fw.close();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public static void main(String[] args) throws IOException{
	//flush()刷新流。刷新完毕之后，还可以继续写数据
	//c1ose()关闭流。释放资源。一旦关闭，就不能写数据
	
	FileWriter fw = new Filewriter("charstream\\a.txt");
	
	fw.write("程序员"); //我们发现a.txt中什么都没有，现在还没有写到文件中
	fw.flush();  //刷新后发现a.txt中有了，flush有一个特点，刷新完后，还可以继续写数据，流并没有关闭
	fw.write("666");
	fw.flush();
	
	//fw.close();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

public static void main(String[] args) throws IOException{
	//创建字符输入流的对象
	//FileReader fr = new FileReader(new File("charstream\\a.txt"));
	FileReader fr = new FileReader("charstream\\a.txt");
	
	//读取数据
	int ch;
	while((ch = fr.read()) != -1){
		System.out.println((char)ch);
	}

	//释放资源
	fr.close();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

public static void main(string[] args) throws IOException{
	//一次读取多个字符。
	
	//创建对象
	FileReader fr = new FileReader("charstream\\a.txt");
	
	//创建一个数组
	char[] chars = new char[1024];
	int len;

	//read方法还是读取，但是是一次读取多个字符
	//他把读到的字符都存入到chars数组。
	//返回值：表示本次读到了多少个字符。
	while((len = fr.read(chars)) != -1){
		System.out.println(new string(chars, 0, len));
	}
	
	fr.close();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public static void main(String[] args) throws IOException{
	//将键盘录入的用户名和密码保存到本地实现永久化存储
	//要求：用户名独占一行，密码独占一行
	
	//分析：
	//1.实现键盘录入，把用户名和密码录入进来
	Scanner sc = new Scanner(System.in);
	System.out.println("请录入用户名");
	String username = sc.next();
	System.out.println("请录入密码");
	String password = sc.next();
	
	//2.分别把用户名和密码写到本地文件。
	FileWriter fw = new FileWriter("charstream\\a.txt");
	//将用户名和密码写到文件中
	fw.write(username);
	//表示写出一个回车换行符 windows: \r\n   Macos: \r    Linux: \n
	fw.write(str:"\r\n");
	fw.write(password);
	//刷新流
	fw.flush();
	//释放资源
	fw.close();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public static void main(String[] args) throws IOException{
	//字符缓冲输入流
	BufferedReader br = new BufferedReader(new FileReader("charstream\\a.txt"));
	
	//读取数据
	char[] chars = new char[1024];
	int len;
	while((len = br.read(chars)) != -1){
		System.out.println(new string(chars, 0, len));
	}

	br.close();
}

 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

public static void main(String[] args) throws IOException{
	//字符缓冲输出流
	BufferedWriter bw = new Bufferedwriter(new Filewriter("charstream\\a.txt"));

	//写出数据
	bw.write(97);  //a
	bw.write("\r\n");
	
	char[] chars = {97, 98, 99, 100, 101};
	bw.write(chars);  //abcde
	bw.write("\r\n");
	
	bw.write(chars, 0, 3);  //abc
	bw.write("\r\n");
	
	bw.write("程序员");  //程序员
	bw.write("\r\n");
	
	String line = "abcdefg";
	bw.write(line, 0, 5);  //abcde
	bw.write("\r\n");
	
	bw.flush();
	
	bw.close();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

public static void main(String[] args) throws IOException{
	//创建对象
	BufferedWriter bw = new BufferedWriter(new Filewriter("charstream\\a.txt"));
	
	//写出数据
	bw.write("程序员666");
	//跨平台的回车换行
	bw.newLine();
	bw.write("abcdef");
	//跨平台的回车换行
	bw.newLine();
	bw.write("-------------");

	//刷新流
	bw.flush();
	//释放资源
	bw.close();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public static void main(String[] args) throws IOException{
	//创建对象
	BufferedReader br = new BufferedReader(new FileReader("charstream\\a.txt"));
	
	//读取数据
	String line1 = br.readLine();
	String line2 = br.readLine();
	String line3 = br.readLine();

	//在之前，如果读不到数据，返回-1
	//但是readLine如果读不到数据返回null
	String line4 = br.readLine();
	String line5 = br.readLine();

	System.out.println(line1);  //程序员666
	System.out.println(line2);  //abcdef
	System.out.println(line3);  //-------------
	System.out.println(line4);  //null
	System.out.println(line5);  //null

	//释放资源
	br.close();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

public static void main(String[] args)throws IOException {
	//字符缓冲流的特有功能
	//字符缓冲输入流BufferedReader: readLine读一整行
	
	//创建对象
	BufferedReader br = new BufferedReader(new FileReader("charstream\\a.txt"));

	//使用循环来进行改进
	String line;
	while((line = br.readLine()) != null){
		System.out.println(line);
	}

	//释放资源
	br.close();
}

 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

public static void main(String[] args)throws IOException {
	//1.要把文件中的数据读取进来。
	BufferedReader br = new BufferedReader(new FileReader("charstream\\sort.txt"));
	//输出流一定不能写在这里，因为会清空文件中的内容
	//Bufferedwriter bw = new Bufferedwriter(new Filewriter("charstream\\sort.txt"));
	
	String line = br.readLine();
	System.out.println("读取到的数据为" + line);
	br.close();
	
	//2.按照空格进行切分
	String[] split = line.split(" "); //9 1 2 5 3 10 4 6 7 8
	//3.把字符串类型的数组变成int类型
	int[] arr = new int[split.length];
	//遍历split数组，可以进行类型转换。
	for(int i = 0; i < split.length; i++){
		String smallstr = split[i];
		//类型转换
		int number = Integer.parseInt(smallstr);
		//把转换后的结果存入到arr中
		arr[i]=number;
	}

	//2.排序
	Arrays.sort(arr);
	System.out.println(Arrays.tostring(arr));

	//3.把排序之后结果写回到本地1234..·
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

public static void main(String[] args){
	//1 创建字符输入转换流对象
	//public InputStreamReader(InputStream is, String charset) 把原始的字节输入流，按照指定字符集编码转成字符输入流（重点）
	InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"), "utf-8");

	//2 读数据
	char[] chs = new char[1024];
	int len;
	while ((len = isr.read(chs)) !=- 1){
		System.out.print(new String(chs, 0, len));
	}

	//3 释放资源
	isr.close();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

public static void main(String[] args){
	//1 创建字符输出转换流对象，转换流的本质就是字符流
	//public OutputStreamWriter(OutputStream os, String charset)可以把原始的字节输出流，按照指定编码转换成字符输出流（重点）
	OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("a.txt"), "GBK");
	
	//2 写数据
	osw.write("hello转换流");
	osw.flush();
	
	//3 释放资源
	osw.close()
}

1
2
3
4
5
6

FileReader fr = new FileReader("MyTest\\test.txt", Charset.forName("GBK"));
int ch;
while((ch = isr.read()) != -1){
	System.out.println((char)ch);
}
fr.close();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

public static void main(String[] args){
	//1 创建字符输出转换流对象，转换流的本质就是字符流
	//public OutputStreamWriter(OutputStream os, String charset)可以把原始的字节输出流，按照指定编码转换成字符输出流（重点）
	//OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("a.txt"), "GBK");
	FileWriter osw = new FileWriter("a.txt");
	
	//2 写数据
	byte[] bytes = "hello 转换流".getBytes("GBK"); //编码
	//这里会出问题，因为String默认是UTF-8编码。String s = new String(bytes，"UTF-8");在这里解码了，会产生乱码，只能用字节流
	String s = new String(bytes);
	osw.write(s);
	osw.flush();
	
	//3 释放资源
	osw.close()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public static void main(String[] args){
	FileOutputStream osw = new FileOutputStream("a.txt");
	
	//2 写数据
	osw.write("hello 转换流".getBytes("GBK"));  //指定GBK编码，将GBK编码的数据写到文件中
	osw.flush();
	
	//3 释放资源
	osw.close()
}

1
2
3
4
5
6
7
8
9

public static void main(String[] args) throws IOException{
	User user = new User("zhangsan", "qwer");
	//需求：把这个用户信息保存到本地文件去
	Bufferedwriter bw = new Bufferedwriter(new FileWriter("a.txt"));
	bw.write(user.getusername());
	bw.newLine();
	bw.write(user.getpassword());
	bw.close();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

public class User implements Serializable{
	private string username;
	private string password;
	
	public User(){
	}
	
	public User(String username, String password){
		this.username = username;
		this.password = password;
	}
	
	//set/get...
}

public static void main(String[] args) throws IOException {
	User user = new User("zhangsan", "qwer");
	
	ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("a.txt"));
	oos.writeObject(user);
	oos.close();
}

1
2
3
4
5
6

public static void main(String[] args )throws IOException, ClassNotFoundException {
	ObjectInputStream ois = new ObjectInputStream(new FileInputstream("a.txt"));
	User o = (User)ois.readObject();
	System.out.println(o);
	ois.close();
}

1

private static final long serialVersionUID = 100L;

1

private static final long serialVersionUID = 42L;

1

private transient string password;

1

private static final long serialVersionUID = 1L;

 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

public class Student implements Serializable {
	private static final long serialversionUID = 1L;
	private string name;
	private int age;
	//...
}

public static void main(String[] args) throws IOException {
	Student s1 = new Student("杜子腾"，16);
	Student s2 = new student("张三"，23);
	Student s3 = new Student("李四"，24);
	
	ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("a.txt"));
	oos.writeObject(s1);
	oos.writeObject(s2);
	oos.writeObject(s3);
	
	oos.close();
	
	ObjectInputStream ois = new ObjectInputStream(new FileInputStream("a.txt"));
	Object obj;
	/**
	读到末尾既不是-1也不是null
	while((obj = ois.readObject()) != null){

		System.out.println(obj);
	}
	*/
	while(true){
		try{
			Object o = ois.readObject();
		}catch (EOFException e){
			break;  //EOFException代表文件读到末尾，用break进行终止
		}
	}
	ois.close()；
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public static void main(String[] args) throws IOException {
	Student s1 = new Student("杜子腾"，16);
	Student s2 = new student("张三"，23);
	Student s3 = new Student("李四"，24);
	
	ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("a.txt"));
	ArrayList<Student> list = new ArrayList<>();  //ArayList也实现了Serializable接口，也有serialVersionUID
	list.add(s1);
	list.add(s2);
	list.add(s3);
	
	//我们往本地文件中写的就是一个集合
	oos.writeObject(list);
	
	oos.close();
	
	ObjectInputStream ois = new ObjectInputStream(new FileInputStream("a.txt"));
	ArrayList<student> list2 = (ArrayList<student>) ois.readObject();
	for (Student student : list2){
		System.out.println(student);
	}
	ois.close();
	
}

 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

public class PropertiesDemo1 {
	public static void main(String[] args){
		Properties prop = new Properties();
		
		//增
		prop.put("小龙女"，"尹志平");
		prop.put("郭襄"，"杨过");
		prop.put("黄蓉"，"欧阳克");
		
		//删
		//根据键删除对应的键值对
		prop.remove("郭襄");

		//改
		//如果键不存在，那么就添加，如果键存在，那么就覆盖
		prop.put("小龙女"，"杨过");

		//查
		object value = prop.get("黄蓉");
		
		//遍历
		//方式一
		Set<object> keys = prop.keyset();
		for (object key : keys) {
			Object value = prop.get(key);
			System.out.println(key + "=" value);
		}
		
		//方式二
		//装的是所有的键值对对象，
		Set<Map.Entry<Object,Object>> entries = prop.entryset();
		for (Map.Entry<Object,Object> entry : entries){
			Object key = entry.getkey();
			Object value = entry.getvalue();
			System.out.println(key + "=" + value);
		}
	}
		
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public class PropertiesDemo1 {
	public static void main(String[] args){
		//Object setProperty (string key,string value)---put
		//设置集合的键和值，都是String类型，底层调用Hashtable方法put
		Properties prop = new Properties();
		prop.setProperty("江苏"，"南京");
		prop,setProperty("安徽"，"南京");
		prop.setProperty("山东"，"济南");
		
		//String getProperty(string key)---get
		//使用此属性列表中指定的键搜索属性
		String value = prop.getProperty("江苏");
		System.out.println(value);
		
		//Set<String> stringPropertyNames()---keySet
		//从该属性列表中返回一个不可修改的键集，其中键及其对应的值是字符串
		Set<string> keys = prop.stringPropertyNames();
		for(String key : keys){
			String value = prop.getProperty(key);
			System.out.println(key + "=" + value);
		}
		
	}
}

1
2

public void load(Reader r); //把字符流所指向的 "配置文件" 中的键值对数据，读取到Properties集合中
public void store(Writer w, String comments); //把Properties集合中的键值对数据，写到输出流指向的文件中

1
2
3

//写properties文件时不要有空格和符号,就写 键=值 就好了
username=zhangsan
password=123

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

public static void main(String[] args){
	//void load (Reader reader)                     将本地文件中的键值对数据读取到集合中
	//void store (Writer writer, String comments)   将集合中的数据以键值对形式保存在本地
	
	//读取-load
	Properties prop = new Properties();
	FileReader fr = new FileReader("prop.properties");
	//调用完了load方法之后，文件中的键值对数据已经在集合prop中了
	prop.load(fr);
	fr.close();
	System.out.println(prop);
	
	//写-store
	Properties prop = new Properties();
	prop.put("zhangsan","123");
	prop.put("lisi","456");
	prop.put("wangwu","789");
	
	FileWriter fw = new FileWriter("prop.properties");
	prop.store(fw, null);  //第二个参数是注释
	fw.close();
}

1
2
3
4
5
6
7

\u4E3A\u4EC0\u4E48\u8981\u4FEE\u6539\u624B\u673A u53F7\u5462? 就是我们写中文注释

\u代表utf-8，4E3A代表那个字

properties文件是一个配置文件，该文件的默认编码是ISO-8859-1，是为了与国外接轨

通过file—setting----搜索encoding------file encodings-------可以让我们看懂