JAVASE笔记20210106

1、Map接口：（非线性集合）

(1)Map和Collection没有关系
(2)Map集合以key和value方法进行存储（键值对）Key：唯一
(3)Map主要使用的分类:HashMap、TreeMap
(4)Map常用的方法
①V put(K key, V value)
②Set keySet()
③返回值(value) get(Object key)
④Collection values()
⑤Set<Map.Entry<K,V>> entrySet()
⑥返回值(value)remove(Object key)
⑦int size()
⑧等
(5)Map遍历：
①先获取所有的键-》获取值-》键值对对象
②将map中键与值当做对象进行遍历
(6)Map的key可以存 null 空吗？Value可以存 null 空吗？
①可以
(7)如何判断map的key是否唯一？
①基本数据类型 与 String 不用管
②自定义引用数据类型，需要重写 equals与hashCode方法
(8)案例：

import java.util.Map;
import java.util.Map.Entry;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
public class Demo{
	public static void main(String[] args){
		Map<String,String> map = new HashMap<>();
		//-数据存储
		map.put("k1","v1");
		map.put("k2","v2");
		map.put("k3","v3");
		map.put(null,null);
		map.put(null,"111");
		//-map:遍历（1）
		Set<String> keys = map.keySet();
		Iterator<String> iterator = keys.iterator();
		while(iterator.hasNext()){
			String key = iterator.next();
			// 禁止使用map 删除，会打乱迭代器的遍历
			//map.remove(key);
			String value = map.get(key);
			System.out.println(key+":"+value);
		}	
		//-map:遍历（2）entrySet()
		Set<Entry<String,String>> entrySet = map.entrySet();
		Iterator<Entry<String,String>> iterator1 = entrySet.iterator();
		while(iterator1.hasNext()){
			Entry<String,String> entry = iterator1.next();
			System.out.println(entry);
		}
	}
}

2、Collections

(1)Collection :集合的接口
(2)Collections：集合工具类，方便集合的使用

3、IO流

(1)IO：
      ①I => input
      ②O =》Output
(2)IO流的分类：
      ①按方向（参考物：内存）
            1)输入流
            2)输出流
      ②按数据类型
            1)字节流
            2)字符流
      ③其他流：
            1)包装流
                  a.BufferedInputStream
                  b.BufferedReader
                  c.等
            2)转换流
                  a.InputStreamReader
                  b.OuputStreamWriter
                  c.等
(3)IO流=》java.io 包下
(4)Java.io包下需要掌握的流
      ①文件相关
            1)FileInputStream
            2)FileOutputStream
            3)FileReader
            4)FileWriter
      ②转换流（字节=》字符）
            1)InputStreamReader
            2)OutputStreamWriter
      ③缓存流
            1)BufferedInputStream
            2)BufferedOutputStream
            3)BufferedReader
            4)BufferedWriter
            5)ByteArrayInputStream
            6)ByteArrayOutputStream
      ④标准输出流：
            1)PrintWriter
            2)PrintStream
      ⑤对象流
            1)ObjectInputStream
            2)ObjectOutputStream
      ⑥等
(5)FileInputStream、FileOutputStream
      ①如何创建对象
      ②如何使用流的方法
(6)案例
InputStream:

import java.io.InputStream;
import java.io.FileInputStream;
public class Demo{
	public static void main(String[] args){
		InputStream is = null;
		try{
			//创建 FileInputStream对象
			is = new FileInputStream("E:\\java\\a.txt");//文件路径
			//-开始 读字节(一个一个字节读取)
			/*
			int len = -1;
			//read()如果到达文件末尾，返回int 类型-1；
			while((len=is.read())!=-1){
				System.out.println((char)len);
			}
			*/
			//-读取字节，可以一组一组
			int len = -1;
			byte[] bytes = new byte[4];
			while((len=is.read(bytes))!=-1){
				System.out.println(new String(bytes,0,len));//覆盖
			}
			
		}catch(Exception ex){
			System.out.println(ex.getMessage());
		}finally{
			if(is!=null){
				try{
					is.close();
				}catch(Exception ex){
					System.out.println(ex.getMessage());
				}
				
			}
		}
	}
}

OutputStream:

import java.io.OutputStream;
import java.io.FileOutputStream;
public class Demo{
	public static void main(String[] args){
		//-设定输出的内容
		String info = "中国加油！";
		//-转换字节数组
		byte[] bytes = info.getBytes();
		//:对象的创建：
		OutputStream os = null;
		try{
			os = new FileOutputStream("E:\\java\\b.txt");
			//-将内容输出出去
			os.write(bytes);
		}catch(Exception ex){
			ex.printStackTrace();
		}finally{
			if(os!=null){
				try{
					os.close();
				}catch(Exception ex){
					ex.printStackTrace();
				}
			}
		}
	}
}

InputStream和OutputStream混合使用（复制文件）

import java.io.InputStream;
import java.io.FileInputStream;
import java.io.OutputStream;
import java.io.FileOutputStream;
import java.io.ByteArrayOutputStream;
public class Demo{
	public static void main(String[] args){
		//-原目标路径
		String old_path = "E:\\java\\a.jpg";
		//-新目标路径
		String new_path = "E:\\java\\b.jpg";
		
		InputStream is = null;
		OutputStream os = null;
		ByteArrayOutputStream bos = null;
		
		try{
			//-创建流
			is = new FileInputStream(old_path);
			os = new FileOutputStream(new_path);
			//-第一种方式：字节流的处理（读、写）读一个写一个
			/*
			int len = -1;
			while((len=is.read())!=-1){
				//-写
				os.write(len);
			}
			*/
			/* 第二种方式：字节流的处理（读、写）以字节数组的形式读取
			int len = -1;
			byte[] bytes = new byte[1024];
			while((len=is.read(bytes))!=-1){
				os.write(bytes,0,len);
			}
			*/
			//- 第三种方式：使用字节数组的对象，进行内容的输出
			bos = new ByteArrayOutputStream();
			int len = -1;
			byte[] bytes = new byte[1024];
			while((len=is.read(bytes))!=-1){
				bos.write(bytes,0,len);
			}
			//-将所有的字节一次性输出出去
			os.write(bos.toByteArray());
		}catch(Exception ex){
			ex.printStackTrace();
		}finally{
			if(os!=null){
				try{
					os.close();
				}catch(Exception ex){
					ex.printStackTrace();
				}
			}
			if(bos!=null){
				try{
					bos.close();
				}catch(Exception ex){
					ex.printStackTrace();
				}
			}
			if(is!=null){
				try{
					is.close();
				}catch(Exception ex){
					ex.printStackTrace();
				}
			}
		}
		
	}
}

4、FileWriter 与 FileReader

(1)文件输出流、文件出入流（字符流）
(2)案例
FileWriter:

import java.io.Writer;
import java.io.FileWriter;
public class Demo_1{
	public static void main(String[] args){
		//-内容
		String info = "China中国";
		char[] chars = info.toCharArray();
		//-创建字符输出流
		Writer writer = null;
		try{
			writer = new FileWriter("E:\\java\\b.txt",true);//“true”：追加返回值，
								//若返回true，就是从文件末尾追加内容，false就覆盖原内容重新写入；
			//-输出字符数组
			//writer.write(chars);
			//-输出字符串
			writer.append("追加到文件末尾");
			writer.write(info);
		}catch(Exception ex){
			ex.printStackTrace();
		}finally{
			if(writer!=null){
				try{
					writer.close();
				}catch(Exception ex){
					ex.printStackTrace();
				}
			}
		}
	}
}

FileReader:

import java.io.Reader;
import java.io.FileReader;
public class Demo{
	public static void main(String[] args){
		//-:FileReader 创建
		Reader reader = null;
		try{
			reader = new FileReader("E:\\java\\a.txt");
			//-第一种方式：读取（一个一个字符读取）
			/*
			int len = -1;
			while((len = reader.read())!=-1){
				System.out.println((char)len);
			}
			*/
			//-第一种方式：读取 按字符数组进行读取
			char[] chars = new char[2];
			int len = -1;
			while((len = reader.read(chars))!=-1){
				System.out.println(new String(chars,0,len));
			}
			
		}catch(Exception ex){
			ex.printStackTrace();
		}finally{
			if(reader!=null){
				try{
					reader.close();
				}catch(Exception ex){
					ex.printStackTrace();
				}
			}
		}
	}
}

(3)如果读取doc文档的内容，应该用字节流（doc文档中有可能存在图片,字符不能输出图片格式，几遍doc里面没有图片也不能用字符流）

5、缓冲流：

(1)种类
①BufferedInputStream与InputStream方法没有区别
②BufferedOutputStream与OutputStream方法没有区别
③BufferedReader比 Reader 新增了 readLine()
④BufferedWriter比 Writer 新增了 newLine()
(2)BufferedReader

import java.io.Reader;
import java.io.FileReader;
import java.io.BufferedReader;
import java.io.File;
public class Demo{
	public static void main(String[] args){
		//-BufferedReader创建
		Reader reader = null;
		BufferedReader bufR = null;
		try{
			reader = new FileReader("E:"+File.separator+"java"+File.separator+"a.txt");
			//File.separator,与系统有关的默认名称分隔符，为了方便，它被表示为一个字符串。(此处相当于“\\”)
			bufR = new BufferedReader(reader);
			//-:一行一行的读取(readLine())到达文件末尾返回null，“\n”,“\r”
			String end = null;
			while((end = bufR.readLine())!=null){
				System.out.println(end);
			}
			
		}catch(Exception ex){
			ex.printStackTrace();
		}finally{
			if(reader!=null){
				try{
					reader.close();
				}catch(Exception ex){
					ex.printStackTrace();
				}
			}
			if(bufR!=null){
				try{
					bufR.close();
				}catch(Exception ex){
					ex.printStackTrace();
				}
			}
		}
	}
}

BufferedWriter

import java.io.Writer;
import java.io.FileWriter;
import java.io.BufferedWriter;
public class Demo_1{
	public static void main(String[] args){
		
		//-字符缓冲流
		BufferedWriter bw = null;
		Writer writer = null;
		
		try{
			writer = new FileWriter("E:\\java\\b.txt");
			bw = new BufferedWriter(writer);
			
			bw.write("测试111");
			bw.newLine();
			bw.write("测试222");
			bw.newLine();
			bw.write("测试333");
			bw.newLine();
			//刷新该流的缓冲，把缓存在内存中的数据写入到File中
			bw.flush();
			
		}catch(Exception ex){
			ex.printStackTrace();
		}finally{
			if(writer!=null){
				try{
					writer.close();
				}catch(Exception ex){
					ex.printStackTrace();
				}
			}
			if(bw!=null){
				try{
					bw.close();
				}catch(Exception ex){
					ex.printStackTrace();
				}
			}
		}
	}
}

6、转换流（字节流=》字符流）

(1)主要分为：InputStreamReader、OutputStreamWriter

import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.io.File;
public class Demo{
	public static void main(String[] args){
		
		InputStreamReader isr = null;
		InputStream is = null;
		BufferedReader br = null;
		
		try{
			File file = new File("E:\\java\\a.txt");
			is = new FileInputStream(file);
			isr = new InputStreamReader(is);
			br = new BufferedReader(isr);
			
			String info = null;
			while((info=br.readLine())!=null){
				System.out.println(info);
			}
			
		}catch(Exception ex){
			ex.printStackTrace();
		}finally{
			if(br!=null){
				try{
					br.close();
				}catch(Exception ex){
					ex.printStackTrace();
				}
			}
			if(isr!=null){
				try{
					isr.close();
				}catch(Exception ex){
					ex.printStackTrace();
				}
			}
			if(is!=null){
				try{
					is.close();
				}catch(Exception ex){
					ex.printStackTrace();
				}
			}
		}
	}
}

7、File

(1)File 代表具体的文件或目录，例如：E:\java\ E:\java\a.txt
(2)如何使用File？
①构造方法
②常用方法
      1)delete()： 删除此抽象路径名表示的文件或目录。
      2)createNewFile()：当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。
      3)exists()：测试此抽象路径名表示的文件或目录是否存在。
      4)getAbsolutePath()：返回此抽象路径名的绝对路径名形式。
      5)getName() ：返回由此抽象路径名表示的文件或目录的名称。
      6)getParent()：返回此抽象路径名父目录的路径名字符串；如果此路径名没有指定父目录，则返回 null。
      7)getParentFile() ：返回此抽象路径名父目录的抽象路径名；如果此路径名没有指定父目录，则返回 null。
      8)isDirectory() ：测试此抽象路径名表示的文件是否是一个目录。
      9)isFile()：测试此抽象路径名表示的文件是否是一个标准文件。
      10)list()：返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。
      11)listFiles()：返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。
      12)mkdir()：创建此抽象路径名指定的目录。
      13)mkdirs()：创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。
      14）等（参考api）
(3)File：案例

import java.io.File;
public class Demo{
	public static void main(String[] args){
		
		File file = new File("E:\\java\\a.txt");
		//-:判断 是文件 还是 目录
		boolean flag = file.isFile();
		boolean flag_1 = file.isDirectory();
		//-获取文件名称
		String fileName = file.getName();
		System.out.println(flag+":"+flag_1+":"+fileName);
		
		File file_1 = file.getParentFile();
		String[] names = file_1.list();
		File[] files = file_1.listFiles();
		for(String name:names){
			System.out.print(name+"\t");
		}
		
		try{
			file = new File("E:\\java\\a1.txt");
			flag = file.createNewFile();
			System.out.println(flag);
		}catch(Exception ex){
			ex.printStackTrace();
		}
		
	}
}

8、线程：（多线程）

(1)线程与进程 如何区分:一个进程里有多个线程。
(2)线程创建形式有几种？
      ①extends Thread
      ②implements Runnable
(3)如何启动线程
      ①Thread类如何启动？
            1)Start() 方法
      ②Runnable接口如何启动？
            1)通过Thread类的start方法进行启动
(4)线程的声明周期
      ①新建状态
      ②就绪状态
      ③运行状态
      ④阻塞状态
      ⑤消亡状态
(5)状态之间的转换