高级Api-复习

一.File

1.File:在java中，不管是文件还是文件夹都是用File来表示。

1.1: 如何定义File文件

案例：

File file = new File("E:\\测试\\lg");// 调用有参的构造方法

1.2: 判断File文件是否是文件 isFile

案例：

 boolean f = file.isFile();
		 if(f) {
		 System.out.println("是文件");
		 }
		 else {
		 System.out.println("不是文件");
		 }

1.3: 判断是否是文件夹 isDirectory()

案例：

System.out.println(file.isDirectory());

1.4 : 判断对象是否存在 exists()

案例：

 System.out.println(file.exists());

1.5 :判断file对象是否存在？如果不存在则创建 createNewFile();

案例：

if(!file.exists()) {//如果file对象不存在
				boolean f = file.createNewFile();
				if(f) {
					System.out.println("创建成功！");
				}else {
					System.out.println("创建失败!");
				}
			}else {// 存在
				System.out.println("该文件存在，不需要创建！");

1.6 :创建文件夹 mkdir()

案例：

if(!file.exists()) {// 不存在
			boolean f = file.mkdir();
			if(f) {
				System.out.println("文件夹创建成功！");
			}else {
				System.out.println("文件夹创建失败！");
			}
		}else {
			System.out.println("该文件夹存在!");
		}

1.6 : 获得文件的路径 getPath

案例：

String str = file.getPath(); 获取路径用String接收
System.out.println(str);  

1.7: 获得文件名 getName

案例：

file.getName()

1.8: 获得文件的上一次父目录的名字(父路径) getParent

案例：

file.getParent()

1.9获得文件长度，以字节为单位 length

案例：

file.length()

2.0:获得文件的最后修改时间 lastModified

案例:

long la = file.lastModified();  返回类型为long
 Date d = new Date(la);   转为date 
 System.out.println(d.toLocaleString());

2.1:删除指定路径的文件/文件夹 delete

案例:

	if(file.isFile()) { 如果是文件
			boolean f = file.delete();
			if(f) {
				System.out.println("文件【"+file.getName()+"】删除成功！");
			}else {
				System.out.println("文件【"+file.getName()+"】删除失败！");
			}
		}else {删除文件夹（只能删除空文件夹）
			boolean f = file.delete();
			if(f) {
				System.out.println("文件夹【"+file.getName()+"】删除成功！");
			}else {
				System.out.println("文件夹【"+file.getName()+"】删除失败！");
			}
		}

2.1:获得文件夹下面所有文件的名字 list

案例:

String[] list = file.list();
		for (String str : list) {
			System.out.println(str);打印出来
		}

2.1:获得文件夹下面的所有文件对象 listFiles

案例:

File[] files = file.listFiles();
		for (File fa : files) {
			System.out.println("名字："+fa.getName()+"__完整路径："
						+file.getPath()+"__大小："+fa.length());

二.字节流

1.1：读取流 ：FileInputStream

案例：

1.定义要读取的文件对象
   File file = new File("E:\\测试字节流\\sa.txt");
2.定义字节读取流对象
   FileInputStream fis = new FileInputStream(file);
3.开始读取
  定义字节数组:数组长度就是所要读取的文件的长度
   byte[] bs = new byte[(int)file.length()];
   fis.read(bs);// 一次性读取 file文件里面所有的内容
  把读取之后的bs转换成字符串
  String str = new String(bs);
 4.关流
  fis.close();

1.2：包装字节读取流

案例：

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

2.1：写入流 ：FileOutputStream

案例：

   1.定义要写入的文件对象
     File file = new File("E:\\测试字节流\\sa.txt");
   2.由用户输入
     Scanner mys = new Scanner(System.in);
   3.文件字节写流
	  FileOutputStream fos = new FileOutputStream(file);
   4.一直输入，直到exit才结束
	while(true) {
		System.out.println("请输入你要保存的内容：");
		String str = mys.next();
		 if("exit".equalsIgnoreCase(str)) {//不区分大小写进行比较
				break;  结束
			}
			fos.write(str.getBytes());写入
		}
	5.关流
   fos.close();

2.2：包装字节写入流

案例：

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

3.总结

字节读和写：
		  字节读：FileInputStream-->BufferedInputStream    read 读
		  字节写：FileOutputStream-->BufferedOutputStream  write 写

三.序列化和反序列化

1.序列化：把一个java对象通过字节序列变成文件的过程 (ObjectOutputStream)

序列化案例：

	List<Dog> dogs = new ArrayList<>();
		try {
			序列化
			for (int i = 1; i < 1001; i++) {
				Dog da = new Dog("旺财"+i,"公",i);
				dogs.add(da);
			}
			
			定义写入的文件对象
			File file = new File("e:\\序列化\\das.bak");
     		定义字节写入流
			FileOutputStream fos = new FileOutputStream(file);
			BufferedOutputStream bos = new BufferedOutputStream(fos);
			ObjectOutputStream oos = new ObjectOutputStream(bos);
			
			oos.writeObject(dogs);
			oos.flush();
			oos.close();
			System.out.println("序列化完成！");
		} catch (Exception e) {
			e.printStackTrace();
		}

2.反序列化：把一个文件反序列化成一个java对象的过程 (ObjectInputStream)

反序列化案例：

	定义要反序列化的文件
	File file = new File("e:\\序列化\\das.bak");
		try {
			反序列化
			FileInputStream fis = new FileInputStream(file);
			BufferedInputStream bis = new BufferedInputStream(fis);
			ObjectInputStream ois = new ObjectInputStream(bis);
			List<Dog> dogs = (List<Dog>)ois.readObject();
			dogs.forEach(System.out::println);
			ois.close();
		} catch (Exception e) {
			e.printStackTrace();
		}

三.URL

URL：统一资源定位符

通过URL从网络里面下载图片

案例：

try {
			File file = new File("E:\\测试\\baidu.html");
			URL：统一资源定位符
			URL url = new URL("https://www.baidu.com");
			通过URL从网络里面下载图片
			// 打开网络字节读取流
			InputStream is = url.openStream();
			// 包装
			BufferedInputStream bis = new BufferedInputStream(is);			
			开始保存到本地
			FileOutputStream fos = new FileOutputStream(file);
			BufferedOutputStream bos = new BufferedOutputStream(fos);
			
			int n = 0;//保存从网络里面读取的字节
			int count = 0;
			while((n = bis.read()) != -1) {// 读取
				count+=1;
				System.out.println(count);
				bos.write(n);写入/下载/保存到本地
			}
			System.out.println("下载完成！");
			bis.close();
			bos.close();
					} catch (Exception e) {
			e.printStackTrace();
		}

四：多线程

1.多线程存在的意义：

多线程可以让我们的程序部分可以产生同时运行的效果，各玩各的 提高效率是其次，主要是能让多段代码同时执行。

2.多线程的目的：

为了最大限度的利用CPU资源

3.实现线程的三种方式

第一种： 继承 Thread类,并重写run()方法；

第二种：实现Runnable接口，并重写run()方法；

第三种： 实现Callable接口，并重写run()方法；

4.线程的五大状态

新建 就绪 运行 阻塞 死亡

5.设置线程优先级

(1)每个线程都有一个优先级；

(2)高优先级线程的执行优先于低优先级线程；

(3)每个线程都可以或不可以标记为一个守护程序。

(4)当某个线程中运行的代码创建一个新 Thread 对象时，该新线程的初始优先级被设定为创建线程的优先级，并且当且仅当创建线程是守护线程时，新线程才是守护程序。

    里面参数也能放数字：从1——10，优先级从小到大
       setPriority(Thread.MAX_PRIORITY);  设置最高级别10
	   setPriority(Thread.MIN_PRIORITY);  设置最低级别1
	   setPriority(Thread.NORM_PRIORITY);  默认值为5 

6.常用函数

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

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

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

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

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

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

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

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

resume()：线程恢复执行。

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

五：套接字

1：服务器套接字 ：ServerSocket；

ServerSocket ss = new ServerSocket(指定端口号);

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

2：客户端套接字：Socket；

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

六： UDP

1.UDP:无连接数据包传输协议。

2.类型：

2.1 单播：是指只向一个固定的机器发送包

2.2 广播：是向255.255.255.255发送，所有监听某端口的机器都可以接收到

2.3 组播：是向一个用户组发送，该组里面所有用户可以接收到

3.UDP发送消息和传送文件

案例1：发送消息

发送方：

        //定义要发送的人
		DatagramSocket ds = new DatagramSocket();
		//定义要发送的文件
		String str="真能熬夜";
		//把文件打包
		DatagramPacket dp = new DatagramPacket(str.getBytes(),str.getBytes().length,InetAddress.getByName("127.0.0.1"),8848);
		//发送
		ds.send(dp);
		System.out.println("发送成功！");
		//关闭资源
		ds.close();

接收方：

      //定义接收的人
		DatagramSocket ds = new DatagramSocket(8848);
		//准备容器接收
		byte [] ba = new byte[10];
		DatagramPacket dp = new DatagramPacket(ba,ba.length);
		System.out.println("准备接收");
		
		//开始接收
		ds.receive(dp);
		//把字节转为字符串
		String str = new String(ba);
		System.out.println("\t\t接收的内容如下："+str);
		//关闭资源
		ds.close();

案例2：传送文件

发送方

//定义要传送的文件
		File file = new File("C:\\Users\\zjjt\\Pictures\\Camera Roll\\3.gif");
		FileInputStream fis = new FileInputStream(file);//文件字节读取流
		BufferedInputStream bis = new BufferedInputStream(fis);//缓冲字符流
		
		//传送的人
		DatagramSocket ds = new DatagramSocket();
		//定义要传送的包
		DatagramPacket dp;
		byte [] bs = new byte[10];
		
		while(true) {
			//边读
			int n = bis.read(bs);
//			Thread.sleep(10);//休息十毫秒
			if(n==-1) {
				break;
			}
			//边存进包
			dp = new DatagramPacket(bs,bs.length,InetAddress.getByName("127.0.0.1"),8888);
			//边发送
			ds.send(dp);
		}
		
		//在发送一个结束包
		dp = new DatagramPacket("bey".getBytes(),"bey".getBytes().length,InetAddress.getByName("127.0.0.1"),8888);
		ds.send(dp);
		//关闭资源
		ds.close();
		bis.close();
		System.out.println("发送成功！");

接收方：

//定义保存的位置
		File file = new File("E:\\sa.gif");
		//开始写
		FileOutputStream fos = new FileOutputStream(file);
		//转为缓冲
		BufferedOutputStream bos = new BufferedOutputStream(fos);
		//接收的人
		DatagramSocket ds = new DatagramSocket(8888);
		//接收的包
		DatagramPacket dp ;
		byte [] ba = new byte[10];
		System.out.println("准备接收");
		while(true) {
			//准备包裹
			dp = new DatagramPacket(ba, ba.length);
			//给接收的人
			ds.receive(dp);
			if(new String(ba).contains("bey")) {
				break;
			}
			//边写边入本地
			bos.write(ba);
			bos.flush();
		}
		//关闭
		bos.close();
		ds.close();