高级API

高级API总知识点

1.File

在java程序里面文件和文件夹都用 File表示；

1.1 一些常用的方法

判断 file 是不是文件夹：isDirectory()
判断 file 是不是文件：isFile()
判断File对象是否存在：exists()
创建文件：createNewFile()
创建文件夹：mkdir();
获取文件的完整/全路径：getPath();
获取文件的父路径（不包含文件名）：getParent();
获取文件的大小/长度/尺寸：length()
获取文件名字：getName()
获取文件最后修改时间：lastModified()
删除文件：delete();
删除文件夹（必须保证是空文件夹）：delete();
获取文件夹里面的文件名字：list();
获取文件夹里面存放的所有文件对象：listFiles();
获取系统盘符：listRoots();
递归：核心在方法颞部自己调用自己。

2. io流

2.1流的分类

在java中的流按数据流动方向不同可以分为输入流和输出流两（IO流）；

按处理数据类型的不同可分为字符流和字节流；

按照功能不同可分为节点流和处理流。

2.2 字节流

//读取流
	try {
	FileInputStream fis = new FileInputStream(file);
	while((fis.read()) != -1) {
		(char)fis.read();
	}
		byte[] o = new byte [(int)file.length()];
		fis.read(o);
		String str = new String(o);
		System.out.println(str);
	} catch (Exception e) {
		e.printStackTrace();
	}

字节输入流：FileOutputStream；

//输入流
try {
        File file = new File("D:"+File.separator+"字节流"+File.separator+"wow.txt");
		FileOutputStream fos = new FileOutputStream(file);
		String str = "1234567890阿百川";
		fos.write(str.getBytes());
		System.out.println("ok");
	} catch (Exception e) {
	e.printStackTrace();
	}

2.3字节流包装类：

字节读取流包装类：BufferedInputStream；

//定义字节读取流
FileInputStream	fis = new FileInputStream(file);
//定义字节包装流
BufferedInputStream bis = new BufferedInputStream(fis);

字节写入流包装类：BufferedOutputStream；

//定义字节写入流
FileOutputStream fos = new FileOutputStream(file);
//定义包装字节写入流
BufferedOutputStream bos = new BufferedOutputStream(fos);

2.4字符流

字符读取流：FileReader；

try {
		//字符读取流
	FileReader fr = new FileReader(file);
	BufferedReader br = new BufferedReader(fr);
	String oldstr ="";
		while (true) {
			String str = br.readLine();
		if (str==null) {
				oldstr += str+"\n";
				br.lines();
			} 
		}
		br.close();
		} catch (Exception e) {
	     e.printStackTrace();
	}

字符输入流：FileWriter；

try {
	//字符写入流
	FileWriter fw = new FileWriter(file);
	BufferedWriter bw = new BufferedWriter(fw);
	Scanner m = new Scanner(System.in);
    while (true ) {
		System.out.println("请输入内容：");
		String newStr = m.next();
		if ("esc".equals(newStr)) {
			System.out.println("录入停止！");
			break;	
			} 
			oldstr+=newStr+"\n";
            }
		bw.write(oldstr);
		bw.flush();
	    bw.close();
	} catch (Exception e) {
		e.printStackTrace();
	}

2.5字符流包装类

字符读取流包装类：BufferedReader；

	BufferedReader br = new BufferedReader(fr);

字符写入流包装类：BufferedWriter；

	BufferedWriter bw = new BufferedWriter(fw);

2.6序列化和反序列化：

2.6.1序列化：

1.Java序列化就是指把Java对象转换为字节序列的过程（把java对象以文件的形式保存到电脑本地或者写入到数据库）。
2.对象写ObjectOutputStream：对象输出流用可以将对象数据写入到文件。
3.方法：writeObject(对象)
4.被序列化的类必须实现序列化接口：Serializable

	//序列化
	try {
		Student s = new Student("坨坨", "女", 19);
		File file = new File("D:\\111.bak");
		FileOutputStream fos = new FileOutputStream(file);
		BufferedOutputStream bos =  new BufferedOutputStream(fos);
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		oos.writeObject(s);
		oos.flush();
		oos.close();
		System.out.println("序列化完成！");
	} catch (Exception e) {
		e.printStackTrace();
	}

2.6.2反序列化：

1.Java反序列化就是指把字节序列恢复为Java对象的过程（把序列化的本地文件恢复为java对象）。

2.被序列化的类必须实现序列化接口：Serializable

public class Student implements Serializable{
private static final long serialVersionUID = 1L;
    }

3.(反序列化)对象读取流：ObjectInputStream：对象输入流是用来恢复之前序列化存储的对象

4.方法：readObject()；

//反序列化
	try {
		File file = new File("D:\\111.bak");
		FileInputStream fis = new FileInputStream(file);
		BufferedInputStream bis = new BufferedInputStream(fis);
		ObjectInputStream ois = new ObjectInputStream(bis);	
		ois.readObject();
		ois.close();
		System.out.println("反序列化");
		} catch (Exception e) {
		e.printStackTrace();
	}

3.URL：

统一资源定位符
获取远程/网络上资源：
InputStream is = url.openStream();// 得到网络字节读取流
InputStream：抽象类。

4.多线程：

4.1实现线程的三种方式：

继承 Thread类，并重写run()方法;

实现 Runnable接口，并重写run()方法; 实现

Callable接口，并重写call()方法;

4.2线程的五大状态：

新建、就绪、运行、阻塞、死亡；

4.3设置线程的优先级：

级别：1-10(默认级别是5)； 方法：setPriority(6);

4.3设置线程的优先级：

1.sleep()：设置线程休眠时间，单位毫秒；

2.yield()：(线程放弃当前的CPU时间片)方法是停止当前线程，让同等优先权的线程运行，如 果没有同等优先权的线程，那么Yield()方法将不会起作用。该方法与sleep()类似，只是不能由用户指定暂停多长时间，该方法执行后线程直接进入就绪状态。

3.join()：执行后线程进入阻塞状态，例如在线程B中调用线程A的join（），那线程B会进入到阻塞队列，直到join结束或中断线程B才开始进入阻塞队列。

4.wait()：让线程处于等待状态，并且释放掉抢到的锁旗标，其他线程可以继续抢锁旗标。wait()必须在同步的代码块中执行。

5.notify()：随机唤醒一个处于wait()状态的线程。

6.notifyAll()：唤醒所有处于wait()状态的线程。

7.interrupt()：中断线程的阻塞状态。

8.suspend()：挂起线程，但是容器造成死锁，已废弃该方法。

9.resume()：线程恢复执行。

4.4为了保证线程对资源安全访问(避免资源访问冲突)，可以设置线程同步：

可以设置线程同步： 设置关键字：synchronized

5.套接字：

服务器套接字：ServerSocket；

ServerSocket ss = new ServerSocket(指定端口号);
Socket socket = ss.accept();// 获取连接该服务器的客户端的套接字

客户端套接字：Socket

 Socket socket = new Socket("ip地址", 端口号);

6.UDP：无连接数据包传输协议。

6.1发送方

	public static void main(String[] args) {
		try {
//			发送信息的人
			DatagramSocket ds = new DatagramSocket();
//			定义字节数组
			byte[] bs = new byte[10];
//			定义数据包
			DatagramPacket dp = null;
//			定义要发送的文件对象
			File file = new File("C:\Users\Administrator\Pictures\Saved Pictures\2.jpg");
//			定义字节读取流
			FileInputStream fis = new FileInputStream(file);
			BufferedInputStream bis = new BufferedInputStream(fis);
//			开始读取
			while ((bis.read(bs)) != -1) {
//				开始创建数据包
				dp = new DatagramPacket(bs, bs.length,
						InetAddress.getByName("127.0.0.1"),3838);
//				开始发送
				ds.send(dp);
			}
			System.out.println("发送完成");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
 
}

6.2接收方

public class Jsf1 {
 
	public static void main(String[] args) {
		System.out.println("等待接收");
		try {
//			发送信息的人
			DatagramSocket ds = new DatagramSocket(3838);
//			定义数据包
			DatagramPacket dp = null;
//			定义接受的字节数组
			byte[] bs = new byte[20];
//			定义保存的文件路劲
			File file = new File("D:\\666.jpg");
//			定义字节写入流
			FileOutputStream fos = new FileOutputStream(file);
			BufferedOutputStream bos = new BufferedOutputStream(fos);
//			开始接受
			while (true) {
//				创建接受的数据包
				dp = new DatagramPacket(bs, bs.length);
//				开始接受
				ds.receive(dp);
//				把每次接受的字杰数组转换成字符串
				String str = new String(bs);
				if (str.contains("拜拜")) {
					break;
				}
//				保存到本地
				bos.write(bs);
				bos.flush();
			}
				ds.close();
				bos.close();
				System.out.println("接收完成");
		} catch (Exception e) {
			e.printStackTrace();
		}		
	}
}