• 04、※NIO的理解、NIO的概念、缓冲区的读取数据、mark标志位置、reset回设的操作和通道文本数据获取与文本写出

    ※NIO的理解

    NIO的概念

    –传统的IO流【本质上都是基于字节流】会进行【阻塞】操作、【一个字节一个字节操作】
    NIO【提供非阻塞的操作】【将数据以区域的形式映射到内存】【性能较高】【复杂、较难理解】

    –NIO提供了一个区域块的数据映射、异步的IO流操作【selector】
    –通道是用于获取流中数据
    –缓冲区是用于保存通道中的数据
    –NIO是将数据映射到内存，所以NIO的传输效率传统的IO流要好

    ※–Buffer 缓冲区

    在这里插入图片描述

    /* 缓冲区中的四个核心属性：

    • capacity：容量，表示缓冲区中最大存储数据的容量。一旦声明不能改变。
    • limit：界限，表示缓冲区中可以操作数据的大小。(limit后数据不能进行读写)
    • position：位置，表示缓冲区中正在操作数据的位置。
    • mark:标记，表示记录当前position位置。可以通过reset()恢复到mark的位置。
      /
      –API:
      allocate（）；
      put();
      flip();
      get()；
      clear();
      /
      • 根据数据类型的不同(boolean 除外)，有以下 Buffer 常用子类：
      • ByteBuffer
      • CharBuffer
      • ShortBuffer
      • IntBuffer
      • LongBuffer
      • FloatBuffer
      • DoubleBuffer
      • 上述缓冲区的管理方式几乎一致，通过allocate()获取缓冲区
        */
        在这里插入图片描述
    /**
 * @author Lantzrung
 * @date 2022年8月3日
 * @Description
 */
package com.daily01;

import java.nio.ByteBuffer;


public class BufferDemo {

    // 缓冲区用于存放数据
    // NIO中缓冲区的的使用
    public static void main(String[] args) {

	// 字节缓冲区 allocate实例化方法(容量) 本质也是数组(ByteBuffer 源码中有:final byte[] hb; )
	// ByteBuffer buffer = new ByteBuffer();// 因为ByteBuffer是抽象类不能实例化对象public
	// abstract class ByteBuffer

	// 因此ByteBuffer里面提供了一个方法进行使用 capacity是容量的意思
	ByteBuffer buffer = ByteBuffer.allocate(100);// 设定容量长度为100
	// 缓冲区的属性
	System.out.println("position=" + buffer.position());// position=0
	System.out.println("limit=" + buffer.limit()); // limit=100
	System.out.println("capacity=" + buffer.capacity());// capacity=100

	// 存放数据
	buffer.put((byte) 97);
	buffer.put((byte) 98);
	buffer.put((byte) 99);

	// 缓冲区的属性
	System.out.println("--------------存放数据后-------------");
	System.out.println("position=" + buffer.position());// position=3
	System.out.println("limit=" + buffer.limit()); // limit=100
	System.out.println("capacity=" + buffer.capacity());// capacity=100

//	OPEN1
//	// 从缓冲区中读取数据
//	// 为啥读取的数据get为0? 因为position从3开始进行获取 所以要进行把position设置为0 limit设置为3
//	System.out.println(buffer.get());// 0
//	System.out.println(buffer.get());// 0
//	System.out.println(buffer.get());// 0
//	System.out.println("position=" + buffer.position());// position=3
//	System.out.println("limit=" + buffer.limit()); // limit=100
//	System.out.println("capacity=" + buffer.capacity());// capacity=100

	System.out.println("----------------设置后---------------");
//	OPEN2
	// 从缓冲区中读取数据
	// 为啥读取的数据get为0? 因为position从3开始进行获取 所以要进行把position设置为0 limit设置为3
	buffer.position(0);// 把position设置为0
	buffer.limit(3);// 把buffer设置为3
	System.out.println(buffer.get());// 97
	System.out.println(buffer.get());// 98
	System.out.println(buffer.get());// 99
	System.out.println("position=" + buffer.position());// position=3
	System.out.println("limit=" + buffer.limit()); // limit=100
	System.out.println("capacity=" + buffer.capacity());// capacity=100

	
	System.out.println("----------------翻转设置后--------------------");
//	OPEN3
	// 要是不知道缓冲区存放了多少个数组该怎么办？
	// 翻转的作用:limit设置为position; position设置为0
	buffer.flip();
	System.out.println(buffer.get());// 97
	System.out.println(buffer.get());// 98
	System.out.println(buffer.get());// 99
	System.out.println("position=" + buffer.position());// position=3
	System.out.println("limit=" + buffer.limit()); // limit=100
	System.out.println("capacity=" + buffer.capacity());// capacity=100

	
	// 重新使用,进行清空
	buffer.clear();
	System.out.println("--------------------清空数据后---------------");
	System.out.println("position=" + buffer.position());// position=0
	System.out.println("limit=" + buffer.limit()); // limit=100
	System.out.println("capacity=" + buffer.capacity());// capacity=100
	
    }

}


    • 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
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86

    读取数据

    /**
 * @author Lantzrung
 * @date 2022年8月3日
 * @Description
 */
package com.daily01;

import java.nio.ByteBuffer;

public class BufferDemo03 {
    public static void main(String[] args) {

	//
	ByteBuffer buffer = ByteBuffer.allocate(100);
	buffer.put("dadafaewffioaiohfdaeewq".getBytes());
	System.out.println("-------------------存放后翻转----------------");
	//
	buffer.flip();
	System.out.println("position=" + buffer.position());
	System.out.println("limit=" + buffer.limit());
	System.out.println("capacity=" + buffer.capacity());
	// 读取
	byte[] bu = new byte[20];
	buffer.get(bu);
	System.out.println(new String(bu));// dadafaewffioaiohfdae
	// 超过limit会出现异常Exception in thread "main" java.nio.BufferUnderflowException
	buffer.get(bu);
	System.out.println(new String(bu));// dadafaewffioaiohfdae
    }

}


    • 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

    mark标志位置的概念和reset回设的操作

    /**
 * @author Lantzrung
 * @date 2022年8月3日
 * @Description
 */
package com.daily01;

import java.nio.ByteBuffer;

public class BufferDemo03 {
    public static void main(String[] args) {

	//
	ByteBuffer buffer = ByteBuffer.allocate(100);
	buffer.put("dadafaewffioaiohfdaeewq".getBytes());
	System.out.println("-------------------存放后翻转----------------");
	//
	buffer.flip();
	System.out.println("position=" + buffer.position());// position=0
	System.out.println("limit=" + buffer.limit());// limit=23
	System.out.println("capacity=" + buffer.capacity());// capacity=100
	// 标记位置 当前position的位置 ，可以通过resert方法进行把position设置为mark位置
	buffer.mark();
	System.out.println("-------------------标记位置后--------------------");
	// 读取
	byte[] bu = new byte[20];
	buffer.get(bu);
	System.out.println(new String(bu));// dadafaewffioaiohfdae

	System.out.println("---------------回设后-------------------");
	// 回设操作reset();
	buffer.reset();
	System.out.println("position=" + buffer.position());// position=0
	System.out.println("limit=" + buffer.limit());// limit=23
	System.out.println("capacity=" + buffer.capacity());// capacity=100
	buffer.get(bu);
	System.out.println(new String(bu));// dadafaewffioaiohfdae
    }

}


    • 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
    • 40
    • 41

    ※–Channel【读写方法】 通道.

    Channel接口的主要实现类：
    FileChannel 本地文件传输通道【阻塞】
    SocketChannel/ServerSocketChannel TCP协议数据传输通道【非阻塞】
    DatagramChannel UDP协议传输通道
    本地IO：FileInputStream、FileOutputStream、RandomAccessFile

    –通道，通过流的getChannel方法来获取通道的对象
    –API:
    //将通道中的数据映射到buff中，其中第一个参数为操作模式，第二个参数为操作的开始位置，第三个参数为映射的个数
    map(FileChannel.MapMode.READ_ONLY, 0, file.length());

    案例：
    读出某个文件的数据
    将buff中的数据通过通道写出文件中
    实现文件的拷贝

    NIO通道和缓冲区实现文件数据获取

    /**
 * @author Lantzrung
 * @date 2022年8月4日
 * @Description
 */
package com.daily01;

import java.io.FileInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class ChannelDemo {
    public static void main(String[] args) throws IOException {
	// 通过通道来传输数据，使用缓冲区来进行乘载
	// 通道 --获取通道 --通过流来获取
	FileInputStream out = new FileInputStream("D:\\test\\data.txt");
	FileChannel channel = out.getChannel();
	// 缓冲区 -- 字节缓冲区
	ByteBuffer buffer = ByteBuffer.allocate(1024);
	//
	int len = 0;
	byte[] bu = new byte[1024];
	while ((len = channel.read(buffer))!=-1) {
	    // 预约
	    buffer.flip();
	    // 从缓冲区中获取数据
	    buffer.get(bu,0,len);
	    // 转换为字符串输出
	    System.out.println(new String(bu,0,len));
	}
	// 关闭通道、流
	channel.close();
	out.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

    NIO-使用通道和缓冲区实现文本写出

    /**
 * @author Lantzrung
 * @date 2022年8月4日
 * @Description
 */
package com.daily01;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.util.Scanner;

public class ChannelDemo01 {
    public static void main(String[] args) throws IOException {
	write();
    }

    public static void write() throws IOException {
	// 通过通道来传输数据，使用缓冲区来进行乘载
	// 通道 --获取通道 --通过流来获取
	FileOutputStream out = new FileOutputStream("D:\\test\\data.txt");
	FileChannel channel = out.getChannel();
	// 缓冲区 -- 字节缓冲区
	ByteBuffer buffer = ByteBuffer.allocate(1024);
	//
	Scanner sc = new Scanner(System.in);
	// 进行读取操作 ---从通道中读取到了缓冲区
	while (true) {
	    // 输入信息
	    System.out.println("请输入信息：");
	    String line = sc.next();
	    // 退出循环
	    if (line.equals("exit")) {
		break;
	    }
	    // 从缓冲区中获取数据
	    buffer.put(line.getBytes());
	    // 翻转
	    buffer.flip();
	    // 通过通道写出数据
	    channel.write(buffer);
	    // 清空缓冲区
	    buffer.clear();
	}
	// 关闭通道、流
	sc.close();
	channel.close();
	out.close();
    }

    public static void read() throws IOException {
	// 通过通道来传输数据，使用缓冲区来进行乘载
	// 通道 --获取通道 --通过流来获取
	FileInputStream input = new FileInputStream("D:\\test\\data.txt");
	FileChannel channel = input.getChannel();
	// 缓冲区 -- 字节缓冲区
	ByteBuffer buffer = ByteBuffer.allocate(1024);
	// 运输
	int len = 0;
	byte[] bu = new byte[1024];
	// 进行读取操作 ---从通道中读取到了缓冲区
	while ((len = channel.read(buffer)) != -1) {
	    // 缓冲区翻转
	    buffer.flip();
	    // 从缓冲区中获取数据
	    buffer.get(bu, 0, len);
	    // 转换为字符串输出
	    System.out.println(new String(bu, 0, len));
	}
	// 关闭通道、流
	channel.close();
	input.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
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78

    NIO实现文本赋值操作

    /**
 * @author Lantzrung
 * @date 2022年8月4日
 * @Description
 */
package com.daily01;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class ChannelCopyDemo {

    public static void main(String[] args) throws IOException {
	// 1、构建流和通道 输入流
	FileInputStream input = new FileInputStream("D:\\test\\test.txt");
	FileChannel inChannel = input.getChannel();
	// 2、构建流和通道 输出流
	FileOutputStream out = new FileOutputStream("D:\\test\\test.txt");
	FileChannel outChannel = out.getChannel();

	// 2、缓冲区--字节缓冲区
	ByteBuffer buffer = ByteBuffer.allocate(1024);// 在当前设置缓冲区为1024
	// 单词读取的长度
	int len = 0;
	// 3、循环运输数据
	while ((len = inChannel.read(buffer)) != -1) { // 从输入的通道中读取数据到缓冲区
	    // 翻转
	    buffer.flip();
	    // 写出操作到输出通道
	    outChannel.write(buffer);
	    // 准备下一次的操作清空
	    buffer.clear();
	}
	// 4、关闭资源
	inChannel.close();
	input.close();
	outChannel.close();
	out.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
    • 40
    • 41
    • 42
    • 43
    • 44

    NIO-使用通道的map方法实现映射数据操作

    // 2、缓冲区 -- 字节缓冲区 映射到内存中进行复制
ByteBuffer buffer = inChannel.map(FileChannel.MapMode.READ_ONLY, 0, file.length());

    • 1
    • 2
    /**
 * @author Lantzrung
 * @date 2022年8月4日
 * @Description
 */
package com.daily01;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class ChannelDemo02 {
    public static void main(String[] args) throws IOException {

	read();
    }

    public static void read() throws IOException {
	// 通过通道来传输数据，使用缓冲区来进行乘载
	// 通道--获取通道--通过流来获取
	File file = new File("D:\\test\\test.txt");

	FileInputStream input = new FileInputStream(file);
	FileChannel channel = input.getChannel();
	// 缓冲区 - 字节流缓冲区 把通道中的数据映射到缓冲区中存储
	// 注意:映射数据时候。注意长度不能超过文件的长度 【关键逻辑:偏移量的算法、映射长度的算法】
	ByteBuffer buffer = channel.map(FileChannel.MapMode.READ_ONLY, 0, file.length());
	// 运输
	byte[] bu = new byte[1024];
	// 偏移量
	buffer.get(bu, 0, (int) (file.length()));
	// 输出数组
	System.out.println(new String(bu));
	// 关闭通道、流
	channel.close();
	input.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
    • 40
    • 41

    练习1:生成电影票和文件中的内容

    在这里插入图片描述

    生成了电影票：
    在这里插入图片描述
    文件中的内容：
    在这里插入图片描述

    实现方法一:

    package com.work01;

/**
 * @author Lantzrung
 * @date 2022年8月3日
 * @Description
 */
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.InputMismatchException;
import java.util.Scanner;

public class HomeWork1 {
    // 存放电影的集合
    public static ArrayList<Film> arrayList = new ArrayList<>();
    // 定义一个路径内容
    public static final String PATH = "D:\\test\\";

    public static void main(String[] args) throws IOException {
	// 开始
	tck tck = start();
	try {
	    // 生成电影票文件
	    generatetck(tck);
	} catch (RuntimeException e) {
	    System.out.println(e.getMessage());
	    // 没有生成，再次开始
	    start();
	}
    }

    // 开始
    private static tck start() {
	// 系统开始:打印电影列表+座位
	systemStarts();
	// 电影票
	tck tck = null;
	// 电影票为null，一直循环
	while (tck == null) {
	    // 输入电影票信息
	    tck = enterInformation();
	}
	return tck;
    }

    // 生成电影票文件
    private static void generatetck(tck tck) throws IOException {
	// 计算电影票价格
	String price = null;
	// 电影票价格
	for (Film f : arrayList) {
	    if (f.getName().equals(tck.getName()) && f.getTime().equals(tck.getTime())) {
		// 折扣
		final double dis = tck.getDiscount() / 10.0;
		final double v = f.getPrice() * dis;
		price = String.valueOf(v);
	    }
	}
	// 拼接文件路径+文件名
	final String[] split = tck.getTime().split(":");
	String fileName = tck.getName() + "-" + tck.getPosition() + "座-" + split[0] + "时" + split[1] + "分" + ".txt";
	final File file = new File(PATH + fileName);
	// --------------
	FileWriter writer = new FileWriter(file);
	final BufferedWriter bw = new BufferedWriter(writer);
	// --------------
	bw.write("***************************");
	bw.newLine();
	bw.write("      淘宝影院(" + tck.getType() + ")");
	bw.newLine();
	bw.write("---------------------------");
	bw.newLine();
	bw.write("  电影名:" + tck.getName());
	bw.newLine();
	bw.write("  时间:" + tck.getTime());
	bw.newLine();
	bw.write("  座位号:" + tck.getPosition());
	bw.newLine();
	bw.write("  价格:" + price);
	bw.newLine();
	bw.write("***************************");
	bw.newLine();
	System.out.println("电影票已生成!");
	// 同步刷新
	bw.flush();
	// --------------
	// 关闭流，释放资源
	bw.close();
	writer.close();
    }

    // 输入电影票信息
    private static tck enterInformation() {
	// 输入
	Scanner sc = new Scanner(System.in);
	// 电影票
	final tck tck = new tck();

	System.out.print("请输入电影名称:");
	tck.setName(sc.nextLine());

	System.out.println("请输入电影播放时间:以xx:xx的格式");
	tck.setTime(sc.nextLine());

	System.out.println("请输入你所要购买的票的类型:1.普通票  2.学生票  3.赠送票");
	int type;
	try {
	    type = sc.nextInt();
	} catch (InputMismatchException e) {
	    System.out.println("输入错误");
	    return null;
	}
	if (type == 1) {
	    tck.setType("普通票");
	} else if (type == 2) {
	    tck.setType("学生票");
	} else if (type == 3) {
	    tck.setType("赠送票");
	} else {
	    return null;
	}

	System.out.println("请输入您所需要的折扣:1-9的整数");
	try {
	    tck.setDiscount(sc.nextInt());
	} catch (InputMismatchException e) {
	    System.out.println("输入错误");
	    return null;
	}
	if (tck.getDiscount() < 0 || tck.getDiscount() > 9) {
	    System.out.println("输入错误");
	    return null;
	}

	System.out.println("请输入您所需要的座位号:以排-列的形式");
	tck.setPosition(sc.next());
	// -----------
	return tck;
    }

    // 系统开始:打印电影列表+座位
    private static void systemStarts() {
	arrayList.clear();
	final Film film1 = new Film("1.", "非常完美", "perfect", "阴萌", "范冰冰", "Romance", 60, "09:00");
	final Film film2 = new Film("2.", "非常完美", "perfect", "阴萌", "范冰冰", "Romance", 60, "13:00");
	final Film film3 = new Film("3.", "少林足球", "shaolin", "周星驰", "周星驰", "Romance", 70, "14:00");
	arrayList.add(film1);
	arrayList.add(film2);
	arrayList.add(film3);
	System.out.printf("%-2s\t%-5s\t%-5s\t%-5s\t%-5s\t%-5s\t%-5s\t%-5s\n", "序号", "电影名称", "英文名称", "导演", "演员", "电影类型",
		"价格", "时间");
	for (Film film : arrayList) {
	    System.out.printf("%-2s\t%-5s\t%-5s\t%-5s\t%-5s\t%-5s\t%-5s\t%-5s\n", film.getId(), film.getName(),
		    film.getEnglish_Name(), film.getDirector(), film.getActor(), film.getType(), film.getPrice(),
		    film.getTime());
	}
	System.out.println("下面为影院的座位结构图:");
	System.out.println("                     屏幕");
	for (int i = 1; i <= 5; i++) {
	    for (int j = 1; j <= 7; j++) {
		System.out.print("   " + i);
		System.out.print("-" + j);
	    }
	    System.out.println();
	}
    }
}

class Film {

    private String id;
    private String name;
    private String English_Name;// 英文名字
    private String director;// 导演
    private String actor; // 演员
    private String type;// 类型
    private int price;// 价格
    private String time;// 时间

    public Film() {
    }

    public Film(String id, String name, String English_Name, String director, String actor, String type, int price,
	    String time) {
	this.id = id;
	this.name = name;
	this.English_Name = English_Name;
	this.director = director;
	this.actor = actor;
	this.type = type;
	this.price = price;
	this.time = time;
    }

    @Override
    public String toString() {
	return "Film{" + "id='" + id + '\'' + ", name='" + name + '\'' + ", English_Name='" + English_Name + '\''
		+ ", director='" + director + '\'' + ", actor='" + actor + '\'' + ", type='" + type + '\'' + ", price="
		+ price + ", time='" + time + '\'' + '}';
    }

    public String getId() {
	return id;
    }

    public void setId(String id) {
	this.id = id;
    }

    public String getName() {
	return name;
    }

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

    public String getEnglish_Name() {
	return English_Name;
    }

    public void setEnglish_Name(String English_Name) {
	this.English_Name = English_Name;
    }

    public String getDirector() {
	return director;
    }

    public void setDirector(String director) {
	this.director = director;
    }

    public String getActor() {
	return actor;
    }

    public void setActor(String actor) {
	this.actor = actor;
    }

    public String getType() {
	return type;
    }

    public void setType(String type) {
	this.type = type;
    }

    public int getPrice() {
	return price;
    }

    public void setPrice(int price) {
	this.price = price;
    }

    public String getTime() {
	return time;
    }

    public void setTime(String time) {
	this.time = time;
    }
}

class tck {
    // 名称
    private String name;
    // 时间
    private String time;
    // 类型:普通票，学生票，赠送票
    private String type;
    // 折扣:1-9
    private Integer discount;
    // 位置
    private String position;

    public tck() {
    }

    public tck(String name, String time, String type, Integer discount, String position) {
	this.name = name;
	this.time = time;
	this.type = type;
	this.discount = discount;
	this.position = position;
    }

    @Override
    public String toString() {
	return "tck{" + "name='" + name + '\'' + ", time='" + time + '\'' + ", type='" + type + '\'' + ", discount="
		+ discount + ", position='" + position + '\'' + '}';
    }

    public String getName() {
	return name;
    }

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

    public String getTime() {
	return time;
    }

    public void setTime(String time) {
	this.time = time;
    }

    public String getType() {
	return type;
    }

    public void setType(String type) {
	this.type = type;
    }

    public Integer getDiscount() {
	return discount;
    }

    public void setDiscount(Integer discount) {
	this.discount = discount;
    }

    public String getPosition() {
	return position;
    }

    public void setPosition(String position) {
	this.position = position;
    }
}


    • 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
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186
    • 187
    • 188
    • 189
    • 190
    • 191
    • 192
    • 193
    • 194
    • 195
    • 196
    • 197
    • 198
    • 199
    • 200
    • 201
    • 202
    • 203
    • 204
    • 205
    • 206
    • 207
    • 208
    • 209
    • 210
    • 211
    • 212
    • 213
    • 214
    • 215
    • 216
    • 217
    • 218
    • 219
    • 220
    • 221
    • 222
    • 223
    • 224
    • 225
    • 226
    • 227
    • 228
    • 229
    • 230
    • 231
    • 232
    • 233
    • 234
    • 235
    • 236
    • 237
    • 238
    • 239
    • 240
    • 241
    • 242
    • 243
    • 244
    • 245
    • 246
    • 247
    • 248
    • 249
    • 250
    • 251
    • 252
    • 253
    • 254
    • 255
    • 256
    • 257
    • 258
    • 259
    • 260
    • 261
    • 262
    • 263
    • 264
    • 265
    • 266
    • 267
    • 268
    • 269
    • 270
    • 271
    • 272
    • 273
    • 274
    • 275
    • 276
    • 277
    • 278
    • 279
    • 280
    • 281
    • 282
    • 283
    • 284
    • 285
    • 286
    • 287
    • 288
    • 289
    • 290
    • 291
    • 292
    • 293
    • 294
    • 295
    • 296
    • 297
    • 298
    • 299
    • 300
    • 301
    • 302
    • 303
    • 304
    • 305
    • 306
    • 307
    • 308
    • 309
    • 310
    • 311
    • 312
    • 313
    • 314
    • 315
    • 316
    • 317
    • 318
    • 319
    • 320
    • 321
    • 322
    • 323
    • 324
    • 325
    • 326
    • 327
    • 328
    • 329
    • 330
    • 331
    • 332
    • 333
    • 334
    • 335
    • 336
    • 337
    • 338
    • 339

    实现方法二:

    package com.day0803.homework;

import java.io.BufferedReader;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintStream;
import java.util.Scanner;

public class HomeWork1 {

	public static void main(String[] args) throws IOException {
		// 1、电影信息的获取【文件】【缓冲字符流】
		BufferedReader reader = new BufferedReader(new FileReader("D:\\GZ2244\\0803\\ticket.txt"));
		// Scanner
		Scanner sc = new Scanner(System.in);
		// 2、循环读取
		String line = "";
		while ((line = reader.readLine()) != null) {
			// 打印输出
			System.out.println(line);
		}
		// 3、座位号
		System.out.println("下面是影院的座位结构：");
		System.out.println("\t\t\t屏幕");
		// 循环
		for (int i = 1; i <= 5; i++) {
			for (int j = 1; j <= 7; j++) {
				System.out.print(i + "-" + j + "\t");
			}
			// 换行
			System.out.println();
		}
		// 获取电影购买的信息：
		System.out.println("请输入电影名称：");
		String movie = sc.next();
		System.out.println("请输入电影的播放时间，以xx点xx分的格式 ：");
		String time = sc.next();
		System.out.println("请输入电影价格 ：");
		double price = Double.parseDouble(sc.next());
		System.out.println("请输入购票类型，1.普通票【打折】 2.学生票【6折】 3.赠送票【免费】：");
		String type = sc.next();
		type = type.equals("1") ? "普通票" : (type.equals("2") ? "学生票" : "赠送票");
		int discount = 10;// 默认没有打折
		if (type.equals("普通票")) {
			System.out.println("请输入折扣：");
			discount = Integer.parseInt(sc.next());
			// 价格
			price = price * (discount * 0.1);
		}
		if (type.equals("学生票")) {
			// 价格
			price = price * 0.6;
		}
		if (type.equals("赠送票")) {
			// 价格
			price = 0;
		}
		System.out.println("请输入选择座位号，以排-列的形式：");
		String set = sc.next();
		// 生成电影票【文件】【打印流】
		// 文件路径
		String path = "D:\\GZ2244\\0803\\" + movie + "-" + time + "-" + set + ".txt";
		System.out.println(path);
		// 打印流
		PrintStream ps = new PrintStream(new FileOutputStream(path));
		ps.println("*******************************************");
		ps.println("***********淘宝影院（" + type + "）*************");
		ps.println("*******************************************");
		ps.println("电影名：" + movie);
		ps.println("时间：" + time);
		ps.println("座位号：" + set);
		// 先把数据读取时存在在集合中，然后遍历判断名称和时间，再通过字符串的截取获取价格，最后价格乘以折扣
		ps.println("价格：" + price + "元");
		ps.println("*******************************************");
		ps.flush();
		// 关闭流
		reader.close();
		ps.close();
		sc.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
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84

    练习二: 编写一个程序，其功能是将两个文件的内容合并到一个文件中。

    data1.txt和data2.txt   --->  result.txt
--要求：nio

    • 1
    • 2

    实现一

    /**
 * @author Lantzrung
 * @date 2022年8月3日
 * @Description
 */
package com.work01;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class HomeWork2 {
    public static void main(String[] args) throws IOException {
	// 1、构建流和通道
	FileInputStream input = new FileInputStream("D:\\test\\data1.txt");
	FileChannel inChannel = input.getChannel();
	FileInputStream input1 = new FileInputStream("D:\\test\\data2.txt");
	FileChannel inChanne2 = input1.getChannel();
	//
	FileOutputStream out = new FileOutputStream("D:\\test\\result.txt", true);
	FileChannel outChannel = out.getChannel();

	// 2、缓冲区 -- 字节缓冲区
	ByteBuffer buffer = ByteBuffer.allocate(1024);
	int len = 0;// 单次读取的长度
	// 3、循环运输数据
	while ((len = inChannel.read(buffer)) != -1) {// 从输入的通道中读取数据到缓冲区
	    // 翻转
	    buffer.flip();
	    // 写出数据到输出的通道
	    outChannel.write(buffer);
	    // 准备下一次的操作，清空
	    buffer.clear();
	}
	int len1 = 0;// 单次读取的长度
	// 3、循环运输数据
	while ((len1 = inChanne2.read(buffer)) != -1) {// 从输入的通道中读取数据到缓冲区
	    // 翻转
	    buffer.flip();
	    // 写出数据到输出的通道
	    outChannel.write(buffer);
	    // 准备下一次的操作，清空
	    buffer.clear();
	}
	// 4、关闭流、通道
	inChannel.close();
	input.close();
	inChanne2.close();
	input1.close();
	outChannel.close();
	out.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
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56

    实现二

    package com.day0803.homework;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class HomeWork2 {

	public static void main(String[] args) throws IOException {
		// 1、创建Nio【通道、缓冲区】【内存映射】
		// 文件1 通道
		File file1 = new File("D:\\test\\data1.txt");
		FileInputStream input1 = new FileInputStream(file1);
		FileChannel channel1 = input1.getChannel();
		// 文件2 通道
		File file2 = new File("D:\\test\\data2.txt");
		FileInputStream input2 = new FileInputStream(file2);
		FileChannel channel2 = input2.getChannel();
		// 文件输出文件 的 通道
		FileOutputStream out = new FileOutputStream("D:\\test\\result.txt");
		FileChannel out_channel = out.getChannel();
		// 文件1读取写出
		ByteBuffer buffer = channel1.map(FileChannel.MapMode.READ_ONLY, 0, file1.length());
		out_channel.write(buffer);
		// 偏移position
		out_channel.position(file1.length());
		// 文件2 读取写出
		buffer = channel2.map(FileChannel.MapMode.READ_ONLY, 0, file2.length());
		out_channel.write(buffer);
		// 关闭流
		input1.close();
		channel1.close();
		input2.close();
		channel2.close();
		out.close();
		out_channel.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
    • 40
    • 41
    • 42
  • 相关阅读:
    毕业了，感觉自己一无是处，不知道做什么，怎么办？
    tcp的建立连接和断开连接
    Hibernate EntityManager 指南
    高可用Kuberbetes部署Prometheus + Grafana
    Python异步编程｜ASGI 与 Django（附源码）
    【Git】git commit -m 提交信息约束规范
    Java习题：第三章 面向对象
    I.MX6UL的uboot移植
    树状数组
    山西电力市场日前价格预测【2023-10-18】
  • 原文地址：https://blog.csdn.net/Lantzrung/article/details/126151271