老师笔记.pdf

谷粒学院项目笔记整合.pdf

ReadMe.txt

1、稀疏数组

1.1、实际需求

  • 编写的五子棋程序中，有存盘退出和续上盘的功能
  • 因为该二维数组的很多值是默认值 0 ，因此记录了很多没有意义的数据，我们将其转为稀疏数组进行存储

image.png

1.2、稀疏数组应用

1.2.1、稀疏数组处理方法

  • 稀疏数组把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模
  • 稀疏数组也是二维数组，行数由原数组的数据决定，列数一般为 3 列

  • 稀疏数组的第一行记录原数组一共有几行几列，有多少个不为零的值

    1.    第一列：原数组的行数<br />        第二列：原数组的列数<br />        第三列：原数组有多少个不为零的值

  • 之后的行记录原数组中不为零（x）的值所在的行数、列数以及 x 的值

    1.  第一列：x 在原数组中的行数<br />       第二列：x 在原数组中的列数<br />       第三列：x 的值

    1.2.2、举例说明

  • 原始二维数组较大，压缩后占用空间减少

image.png

1.3、应用实例

1.3.1、思路分析

  • 使用稀疏数组， 来保留类似前面的二维数组(棋盘、 地图等等)
  • 把稀疏数组存盘， 并且可以从新恢复原来的二维数组数

image.png

1.3.2、代码实现

  • 代码 ```java public class SparseArray {

    public static void main(String[] args) {

    1.   // 创建一个原始的二维数组 11 * 11
    2.   // 0: 表示没有棋子， 1 表示 黑子 2 表蓝子
    3.   int chessArr1[][] = new int[11][11];
    4.   chessArr1[1][2] = 1;
    5.   chessArr1[2][3] = 2;
    6.   chessArr1[4][5] = 2;
    7.   // 输出原始的二维数组
    8.   System.out.println("原始的二维数组~~");
    9.   for (int[] row : chessArr1) {
    10.       for (int data : row) {
    11.           System.out.printf("%d\t", data);
    12.       }
    13.       System.out.println();
    14.   }
    16.   // 将二维数组 转 稀疏数组的思
    17.   // 1. 先遍历二维数组 得到非0数据的个数
    18.   int sum = 0;
    19.   for (int i = 0; i < chessArr1.length; i++) {
    20.       for (int j = 0; j < chessArr1[i].length; j++) {
    21.           if (chessArr1[i][j] != 0) {
    22.               sum++;
    23.           }
    24.       }
    25.   }
    27.   // 2. 创建对应的稀疏数组
    28.   int sparseArr[][] = new int[sum + 1][3];
    29.   // 给稀疏数组赋值
    30.   sparseArr[0][0] = chessArr1.length;
    31.   sparseArr[0][1] = chessArr1[0].length;
    32.   sparseArr[0][2] = sum;
    34.   // 遍历二维数组，将非0的值存放到 sparseArr中
    35.   int count = 0; // count 用于记录是第几个非0数据
    36.   for (int i = 0; i < chessArr1.length; i++) {
    37.       for (int j = 0; j < chessArr1[i].length; j++) {
    38.           if (chessArr1[i][j] != 0) {
    39.               count++;
    40.               sparseArr[count][0] = i;
    41.               sparseArr[count][1] = j;
    42.               sparseArr[count][2] = chessArr1[i][j];
    43.           }
    44.       }
    45.   }
    47.   // 输出稀疏数组的形式
    48.   System.out.println();
    49.   System.out.println("得到稀疏数组为~~~~");
    50.   for (int i = 0; i < sparseArr.length; i++) {
    51.       System.out.printf("%d\t%d\t%d\n", sparseArr[i][0], sparseArr[i][1], sparseArr[i][2]);
    52.   }
    53.   System.out.println();
    55.   // 将稀疏数组 --》 恢复成 原始的二维数组
    56.   /*
    57.    * 1. 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组，比如上面的 chessArr2 = int [11][11] 2.
    58.    * 在读取稀疏数组后几行的数据，并赋给 原始的二维数组 即可.
    59.    */
    61.   // 1. 先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组
    63.   int chessArr2[][] = new int[sparseArr[0][0]][sparseArr[0][1]];
    65.   // 2. 在读取稀疏数组后几行的数据(从第二行开始)，并赋给 原始的二维数组 即可
    67.   for (int i = 1; i < sparseArr.length; i++) {
    68.       chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
    69.   }
    71.   // 输出恢复后的二维数组
    72.   System.out.println();
    73.   System.out.println("恢复后的二维数组");
    75.   for (int[] row : chessArr2) {
    76.       for (int data : row) {
    77.           System.out.printf("%d\t", data);
    78.       }
    79.       System.out.println();
    80.   }

    }

}

  2. - 程序运行结果
  3. ```java
  4. 原始的二维数组~~
  5. 0    0    0    0    0    0    0    0    0    0    0    
  6. 0    0    1    0    0    0    0    0    0    0    0    
  7. 0    0    0    2    0    0    0    0    0    0    0    
  8. 0    0    0    0    0    0    0    0    0    0    0    
  9. 0    0    0    0    0    2    0    0    0    0    0    
  10. 0    0    0    0    0    0    0    0    0    0    0    
  11. 0    0    0    0    0    0    0    0    0    0    0    
  12. 0    0    0    0    0    0    0    0    0    0    0    
  13. 0    0    0    0    0    0    0    0    0    0    0    
  14. 0    0    0    0    0    0    0    0    0    0    0    
  15. 0    0    0    0    0    0    0    0    0    0    0    
  17. 得到稀疏数组为~~~~
  18. 11    11    3
  19. 1    2    1
  20. 2    3    2
  21. 4    5    2
  24. 恢复后的二维数组
  25. 0    0    0    0    0    0    0    0    0    0    0    
  26. 0    0    1    0    0    0    0    0    0    0    0    
  27. 0    0    0    2    0    0    0    0    0    0    0    
  28. 0    0    0    0    0    0    0    0    0    0    0    
  29. 0    0    0    0    0    2    0    0    0    0    0    
  30. 0    0    0    0    0    0    0    0    0    0    0    
  31. 0    0    0    0    0    0    0    0    0    0    0    
  32. 0    0    0    0    0    0    0    0    0    0    0    
  33. 0    0    0    0    0    0    0    0    0    0    0    
  34. 0    0    0    0    0    0    0    0    0    0    0    
  35. 0    0    0    0    0    0    0    0    0    0    0

1.4、课后练习

  • 在前面的基础上， 将稀疏数组保存到磁盘上， 比如 map.data

  • 恢复原来的数组时， 读取 map.data 进行恢复

    2、队列

    2.1、队列使用场景

  • 银行排队的案例：

image.png

2.2、队列介绍

  • 队列是一个有序列表， 可以用数组或是链表来实现。
  • 遵循先入先出的原则， 即： 先存入队列的数据， 要先取出，后存入的要后取出
  • 示意图： (使用数组模拟队列示意图)

image.png

2.3、数组模拟队列

2.3.1、思路分析

  • maxSize ：队列容量（数组的长度）
  • arr ：模拟队列的数组
  • front ：指向队列头部元素的前一个元素，初始值为 -1
  • rear ：指向队列尾部元素，初始值为 -1

image.png

  • 基本操作

队列判空：front == rear
队列判满：rear == (maxSize - 1) ，即 rear 是否已经指向了数组的最后一个位置
队列元素个数：rear - front
队列入队：队列不满才能入队，arr[++rear] = value
队列出队：队列不空才能出队，return arr[front++]

2.3.2、代码实现

  • 队列的定义 ```java // 使用数组模拟队列-编写一个ArrayQueue类 class ArrayQueue { private int maxSize; // 表示数组的最大容量 private int front; // 队列头 private int rear; // 队列尾 private int[] arr; // 该数据用于存放数据, 模拟队列

    // 创建队列的构造器 public ArrayQueue(int arrMaxSize) {

    1.   maxSize = arrMaxSize;
    2.   arr = new int[maxSize];
    3.   front = -1; // 指向队列头部，分析出front是指向队列头的前一个位置.
    4.   rear = -1; // 指向队列尾，指向队列尾的数据(即就是队列最后一个数据)

    }

    // 判断队列是否满 public boolean isFull() {

    1.   return rear == maxSize - 1;

    }

    // 判断队列是否为空 public boolean isEmpty() {

    1.   return rear == front;

    }

    // 添加数据到队列 public void addQueue(int n) {

    1.   // 判断队列是否满
    2.   if (isFull()) {
    3.       System.out.println("队列满，不能加入数据~");
    4.       return;
    5.   }
    6.   rear++; // 让 rear 后移
    7.   arr[rear] = n;

    }

    // 获取队列的数据, 出队列 public int getQueue() {

    1.   // 判断队列是否空
    2.   if (isEmpty()) {
    3.       // 通过抛出异常
    4.       throw new RuntimeException("队列空，不能取数据");
    5.   }
    6.   front++; // front后移
    7.   return arr[front];

    }

    // 显示队列的所有数据 public void showQueue() {

    1.   // 遍历
    2.   if (isEmpty()) {
    3.       System.out.println("队列空的，没有数据~~");
    4.       return;
    5.   }
    6.   for (int i = front + 1; i <= rear; i++) {
    7.       // Java 中也能用占位符诶
    8.       System.out.printf("arr[%d]=%d\n", i, arr[i]);
    9.   }

    }

    // 显示队列的头数据， 注意不是取出数据 public int headQueue() {

    1.   // 判断
    2.   if (isEmpty()) {
    3.       throw new RuntimeException("队列空的，没有数据~~");
    4.   }
    5.   return arr[front + 1];

    } }

  2. - 测试代码
  3. ```java
  4. public class ArrayQueueDemo {
  6.     public static void main(String[] args) {
  7.         // 测试一把
  8.         // 创建一个队列
  9.         ArrayQueue queue = new ArrayQueue(3);
  10.         char key = ' '; // 接收用户输入
  11.         Scanner scanner = new Scanner(System.in);//
  12.         boolean loop = true;
  13.         // 输出一个菜单
  14.         while (loop) {
  15.             System.out.println("s(show): 显示队列");
  16.             System.out.println("e(exit): 退出程序");
  17.             System.out.println("a(add): 添加数据到队列");
  18.             System.out.println("g(get): 从队列取出数据");
  19.             System.out.println("h(head): 查看队列头的数据");
  20.             System.out.println();
  21.             key = scanner.next().charAt(0);// 接收一个字符
  22.             switch (key) {
  23.             case 's':
  24.                 queue.showQueue();
  25.                 break;
  26.             case 'a':
  27.                 System.out.println("输出一个数");
  28.                 int value = scanner.nextInt();
  29.                 queue.addQueue(value);
  30.                 break;
  31.             case 'g': // 取出数据
  32.                 try {
  33.                     int res = queue.getQueue();
  34.                     System.out.printf("取出的数据是%d\n", res);
  35.                 } catch (Exception e) {
  36.                     System.out.println(e.getMessage());
  37.                 }
  38.                 break;
  39.             case 'h': // 查看队列头的数据
  40.                 try {
  41.                     int res = queue.headQueue();
  42.                     System.out.printf("队列头的数据是%d\n", res);
  43.                 } catch (Exception e) {
  44.                     System.out.println(e.getMessage());
  45.                 }
  46.                 break;
  47.             case 'e': // 退出
  48.                 scanner.close();
  49.                 loop = false;
  50.                 break;
  51.             default:
  52.                 break;
  53.             }
  54.         }
  56.         System.out.println("程序退出~~");
  57.     }
  59. }
  • 程序运行结果 ```java s(show): 显示队列 e(exit): 退出程序 a(add): 添加数据到队列 g(get): 从队列取出数据 h(head): 查看队列头的数据

s 队列空的，没有数据~~ s(show): 显示队列 e(exit): 退出程序 a(add): 添加数据到队列 g(get): 从队列取出数据 h(head): 查看队列头的数据

a 输出一个数 1 s(show): 显示队列 e(exit): 退出程序 a(add): 添加数据到队列 g(get): 从队列取出数据 h(head): 查看队列头的数据

a 输出一个数 2 s(show): 显示队列 e(exit): 退出程序 a(add): 添加数据到队列 g(get): 从队列取出数据 h(head): 查看队列头的数据

a 输出一个数 3 s(show): 显示队列 e(exit): 退出程序 a(add): 添加数据到队列 g(get): 从队列取出数据 h(head): 查看队列头的数据

s arr[0]=1 arr[1]=2 arr[2]=3 s(show): 显示队列 e(exit): 退出程序 a(add): 添加数据到队列 g(get): 从队列取出数据 h(head): 查看队列头的数据

a 输出一个数 4 队列满，不能加入数据~ s(show): 显示队列 e(exit): 退出程序 a(add): 添加数据到队列 g(get): 从队列取出数据 h(head): 查看队列头的数据

g 取出的数据是1 s(show): 显示队列 e(exit): 退出程序 a(add): 添加数据到队列 g(get): 从队列取出数据 h(head): 查看队列头的数据

g 取出的数据是2 s(show): 显示队列 e(exit): 退出程序 a(add): 添加数据到队列 g(get): 从队列取出数据 h(head): 查看队列头的数据

g 取出的数据是3 s(show): 显示队列 e(exit): 退出程序 a(add): 添加数据到队列 g(get): 从队列取出数据 h(head): 查看队列头的数据

g 队列空，不能取数据 s(show): 显示队列 e(exit): 退出程序 a(add): 添加数据到队列 g(get): 从队列取出数据 h(head): 查看队列头的数据

  1. <a name="ugdvx"></a>
  2. ### 2.4、数组模型环形队列
  3. <a name="sWers"></a>
  4. #### 2.4.1、提出问题
  6. - 目前数组**使用一次就不能用**， 没有达到复用的效果，造成**内存空间的浪费**
  7. - 将这个数组使用算法， 改进成一个**环形**的队列（**取模： %**）
  8. <a name="b1qjr"></a>
  9. #### 2.4.2、思路分析
  11. - 对前面的队列进行优化，改造为环形队列（通过**取模**实现）
  12. - maxSize ：队列容量（数组的长度）
  13. - arr ：模拟队列的数组
  14. - front ：指向队列头部元素，初始值为 0
  15. - rear ：指向队列尾部元素的后一个元素，初始值为 0
  17. ![image.png](https://cdn.nlark.com/yuque/0/2022/png/2673847/1641522172883-0ac0cc30-bd82-4156-a843-18560a719114.png#clientId=u648f047f-ebb4-4&crop=0&crop=0&crop=1&crop=1&errorMessage=unknown%20error&from=paste&height=435&id=ub1726ad6&margin=%5Bobject%20Object%5D&name=image.png&originHeight=435&originWidth=751&originalType=binary&ratio=1&rotation=0&showTitle=false&size=53990&status=error&style=none&taskId=ub3740d2d-4ec8-420a-9f00-11ed02da7b7&title=&width=751)
  19. - 基本操作
  21. 队列判空：front == rear<br />队列判满：<br />为何要在 rear 之后，front 之前空出一个元素的空间？因为如果不空出一个元素，队列判空条件为：front == rear ，队列判满的条件也是：front == rear ，有歧义！<br />队列容量：因为空出了一个元素，所以队列容量就变成了 (maxSize - 1)<br />当空出一个元素的空间，如何判满？当还剩一个元素时，队列就已经满了，所以判断条件为 (rear + 1) % maxSize == front<br />队列元数个数：<br />计算公式：(rear + maxSize - front) % maxSize ，这样来思考：<br />当 rear 比 front 大时，即 (rear -front) > 0 ，这时还没有形成环形结构，(rear -front) 即是队列元素个数<br />当 rear 比 front 小时，即 (rear -front) < 0 ，这时已经形成了环形结构，(rear -front) 表示数组还差多少个元素存满（负数），(rear + maxSize - front) 即是队列元素个数<br />综上：(rear + maxSize - front) % maxSize<br />队列入队：<br />首先，队列不满才能入队<br />由于 rear 指向队列尾部元素的后一个元素，所以直接设置即可： arr[rear] = value<br />接下来，rear 应该向后移动一个位置：rear = (rear + 1) % maxSize<br />取模是为了防止数组越界，让指针从新回到数组第一个元素<br />队列出队：<br />首先，队列不空才能出队<br />由于 front 直接指向队列头部元素，所以直接返回该元素即可：int value = arr[front ]<br />接下来，front 应该向后移动一个位置：front = (front + 1) % maxSize<br />取模是为了防止数组越界，让指针从新回到数组第一个元素<br />[<br />](https://blog.csdn.net/oneby1314/article/details/107584566)
  22. <a name="QmcQX"></a>
  23. #### 2.4.3、代码实现
  25. - 环形队列的实现
  26. ```java
  27. class CircleArray {
  28.     private int maxSize; // 表示数组的最大容量
  29.     // front 变量的含义做一个调整： front 就指向队列的第一个元素, 也就是说 arr[front] 就是队列的第一个元素
  30.     // front 的初始值 = 0
  31.     private int front;
  32.     // rear 变量的含义做一个调整：rear 指向队列的最后一个元素的后一个位置. 因为希望空出一个空间做为约定.
  33.     // rear 的初始值 = 0
  34.     private int rear; // 队列尾
  35.     private int[] arr; // 该数据用于存放数据, 模拟队列
  37.     public CircleArray(int arrMaxSize) {
  38.         maxSize = arrMaxSize;
  39.         arr = new int[maxSize];
  40.     }
  42.     // 判断队列是否满
  43.     public boolean isFull() {
  44.         return (rear + 1) % maxSize == front;
  45.     }
  47.     // 判断队列是否为空
  48.     public boolean isEmpty() {
  49.         return rear == front;
  50.     }
  52.     // 添加数据到队列
  53.     public void addQueue(int n) {
  54.         // 判断队列是否满
  55.         if (isFull()) {
  56.             System.out.println("队列满，不能加入数据~");
  57.             return;
  58.         }
  59.         // 直接将数据加入
  60.         arr[rear] = n;
  61.         // 将 rear 后移, 这里必须考虑取模
  62.         rear = (rear + 1) % maxSize;
  63.     }
  65.     // 获取队列的数据, 出队列
  66.     public int getQueue() {
  67.         // 判断队列是否空
  68.         if (isEmpty()) {
  69.             // 通过抛出异常
  70.             throw new RuntimeException("队列空，不能取数据");
  71.         }
  72.         // 这里需要分析出 front是指向队列的第一个元素
  73.         // 1. 先把 front 对应的值保留到一个临时变量
  74.         // 2. 将 front 后移, 考虑取模
  75.         // 3. 将临时保存的变量返回
  76.         int value = arr[front];
  77.         front = (front + 1) % maxSize;
  78.         return value;
  80.     }
  82.     // 显示队列的所有数据
  83.     public void showQueue() {
  84.         // 遍历
  85.         if (isEmpty()) {
  86.             System.out.println("队列空的，没有数据~~");
  87.             return;
  88.         }
  89.         // 思路：从front开始遍历，遍历多少个元素
  90.         // 动脑筋
  91.         for (int i = front; i < front + size(); i++) {
  92.             System.out.printf("arr[%d]=%d\n", i % maxSize, arr[i % maxSize]);
  93.         }
  94.     }
  96.     // 求出当前队列有效数据的个数
  97.     public int size() {
  98.         // rear = 2
  99.         // front = 1
  100.         // maxSize = 3
  101.         return (rear + maxSize - front) % maxSize;
  102.     }
  104.     // 显示队列的头数据， 注意不是取出数据
  105.     public int headQueue() {
  106.         // 判断
  107.         if (isEmpty()) {
  108.             throw new RuntimeException("队列空的，没有数据~~");
  109.         }
  110.         return arr[front];
  111.     }
  112. }

  • 测试代码 ```java public class CircleArrayQueueDemo {

    public static void main(String[] args) {

    1.   // 测试一把
    2.   System.out.println("测试数组模拟环形队列的案例~~~");
    4.   // 创建一个环形队列
    5.   CircleArray queue = new CircleArray(4); // 说明设置4, 其队列的有效数据最大是3
    6.   char key = ' '; // 接收用户输入
    7.   Scanner scanner = new Scanner(System.in);//
    8.   boolean loop = true;
    9.   // 输出一个菜单
    10.   while (loop) {
    11.       System.out.println("s(show): 显示队列");
    12.       System.out.println("e(exit): 退出程序");
    13.       System.out.println("a(add): 添加数据到队列");
    14.       System.out.println("g(get): 从队列取出数据");
    15.       System.out.println("h(head): 查看队列头的数据");
    16.       System.out.println();
    17.       key = scanner.next().charAt(0);// 接收一个字符
    18.       switch (key) {
    19.       case 's':
    20.           queue.showQueue();
    21.           break;
    22.       case 'a':
    23.           System.out.println("输出一个数");
    24.           int value = scanner.nextInt();
    25.           queue.addQueue(value);
    26.           break;
    27.       case 'g': // 取出数据
    28.           try {
    29.               int res = queue.getQueue();
    30.               System.out.printf("取出的数据是%d\n", res);
    31.           } catch (Exception e) {
    32.               // TODO: handle exception
    33.               System.out.println(e.getMessage());
    34.           }
    35.           break;
    36.       case 'h': // 查看队列头的数据
    37.           try {
    38.               int res = queue.headQueue();
    39.               System.out.printf("队列头的数据是%d\n", res);
    40.           } catch (Exception e) {
    41.               // TODO: handle exception
    42.               System.out.println(e.getMessage());
    43.           }
    44.           break;
    45.       case 'e': // 退出
    46.           scanner.close();
    47.           loop = false;
    48.           break;
    49.       default:
    50.           break;
    51.       }
    52.   }
    53.   System.out.println("程序退出~~");

    }

}

  2. - 程序运行结果
  3. ```java
  4. 测试数组模拟环形队列的案例~~~
  5. s(show): 显示队列
  6. e(exit): 退出程序
  7. a(add): 添加数据到队列
  8. g(get): 从队列取出数据
  9. h(head): 查看队列头的数据
  11. a
  12. 输出一个数
  13. 1
  14. s(show): 显示队列
  15. e(exit): 退出程序
  16. a(add): 添加数据到队列
  17. g(get): 从队列取出数据
  18. h(head): 查看队列头的数据
  20. a
  21. 输出一个数
  22. 2
  23. s(show): 显示队列
  24. e(exit): 退出程序
  25. a(add): 添加数据到队列
  26. g(get): 从队列取出数据
  27. h(head): 查看队列头的数据
  29. a
  30. 输出一个数
  31. 3
  32. s(show): 显示队列
  33. e(exit): 退出程序
  34. a(add): 添加数据到队列
  35. g(get): 从队列取出数据
  36. h(head): 查看队列头的数据
  38. s
  39. arr[0]=1
  40. arr[1]=2
  41. arr[2]=3
  42. s(show): 显示队列
  43. e(exit): 退出程序
  44. a(add): 添加数据到队列
  45. g(get): 从队列取出数据
  46. h(head): 查看队列头的数据
  48. a
  49. 输出一个数
  50. 4
  51. 队列满，不能加入数据~
  52. s(show): 显示队列
  53. e(exit): 退出程序
  54. a(add): 添加数据到队列
  55. g(get): 从队列取出数据
  56. h(head): 查看队列头的数据
  58. g
  59. 取出的数据是1
  60. s(show): 显示队列
  61. e(exit): 退出程序
  62. a(add): 添加数据到队列
  63. g(get): 从队列取出数据
  64. h(head): 查看队列头的数据
  66. g
  67. 取出的数据是2
  68. s(show): 显示队列
  69. e(exit): 退出程序
  70. a(add): 添加数据到队列
  71. g(get): 从队列取出数据
  72. h(head): 查看队列头的数据
  74. s
  75. arr[2]=3
  76. s(show): 显示队列
  77. e(exit): 退出程序
  78. a(add): 添加数据到队列
  79. g(get): 从队列取出数据
  80. h(head): 查看队列头的数据
  82. g
  83. 取出的数据是3
  84. s(show): 显示队列
  85. e(exit): 退出程序
  86. a(add): 添加数据到队列
  87. g(get): 从队列取出数据
  88. h(head): 查看队列头的数据
  90. g
  91. 队列空，不能取数据
  92. s(show): 显示队列
  93. e(exit): 退出程序
  94. a(add): 添加数据到队列
  95. g(get): 从队列取出数据
  96. h(head): 查看队列头的数据
  1. //保存到磁盘
  2.     public  void setPan( File writer,int[][] array) throws IOException {
  3.         FileWriter out=new FileWriter(writer);
  4.         BufferedWriter bufferedWriter=new BufferedWriter(out);
  5.         for(int[] row :array){
  6.             for(int date:row){
  7.                 bufferedWriter.write(date+" ");
  8.             }
  9.             bufferedWriter.newLine();
  10.         }
  12.         bufferedWriter.close();
  13.         out.close();
  14.     }