如何在java中,实现对queue的用法
referencequeue简单使用
ReferenceQueue是一个用于处理垃圾回收的引用队列。
当一个对象被垃圾回收时，其相应的包装类（即ref对象）会被放入队列中。
我们可以从队列中获取到相应的对象信息，同时进行额外的处理，比如反向操作、数据清理等。
以下是一个简单的使用示例：
1. 创建一个引用队列：
```java
ReferenceQueue<Object> queue = new ReferenceQueue<>();
```
2. 创建一个WeakReference对象，将需要被引用的对象包装在其中，并将其放入引用队列中：
```java
Object value = new Object();
WeakReference<Object> weakReference = new WeakReference<>(value, queue);
```
3. 定期从引用队列中获取被引用的对象：
```java
while (true) {
Reference<? extends Object> reference = queue.poll();
if (reference == null) {
break;
}
// 进行相应的处理操作，例如反向操作或数据清理等
// ...
}
```
通过以上步骤，我们就可以使用ReferenceQueue来处理垃圾回收的引用队列，并从队列中获取被引用的对象进行额外的处理。
queue的用法和例句
queue的用法和例句Queue是一种常见的数据结构，它按照FIFO（先进先出）的原则对元素进行管理。
在计算机科学中，Queue常常用于处理需要先进先出的数据操作。
本文将逐步解释Queue的用法，并提供一些相关的例句。
首先，我们来了解如何创建一个Queue。
在许多编程语言中，Queue通常是通过类或者库来实现的。
例如，在Python中，可以使用collections库中的deque类来创建一个Queue。
下面是一个创建和初始化Queue的例子：from collections import dequequeue = deque()在这个例子中，我们通过import语句引入了collections库中的deque 类。
然后，我们使用deque()函数创建了一个空的Queue。
接下来，我们来看一些常见的Queue操作。
最基本的Queue操作是入队和出队。
入队（enqueue）操作将元素添加到Queue的末尾，而出队（dequeue）操作则将队首的元素移除。
下面是几个使用enqueue和dequeue操作的例子：queue.append(1) # 入队元素1queue.append(2) # 入队元素2queue.append(3) # 入队元素3queue.popleft() # 出队元素1queue.popleft() # 出队元素2在这个例子中，我们使用append()方法将元素添加到Queue的末尾，然后使用popleft()方法将队首的元素移除。
这样就实现了先进先出的原则。
除了入队和出队操作，Queue还支持其他一些常见的操作，例如获取队首元素（peek），判断Queue是否为空等。
下面是一些使用这些操作的例子：queue.append(4) # 入队元素4print(queue[0]) # 输出队首元素print(len(queue)) # 输出Queue的长度print(queue) # 输出整个Queueprint(queue[1]) # 输出队列中的第二个元素在这个例子中，我们使用索引操作获取队首元素，使用len()函数获取Queue的长度，使用print()语句输出整个Queue，并使用索引获取队列中的第二个元素。
java中concurrentlinkedqueue用法
java中concurrentlinkedqueue用法ConcurrentLinkedQueue是Java并发包（java.util.concurrent）中的一个线程安全的Queue，它按照 FIFO （先进先出）原则对元素进行排序。
ConcurrentLinkedQueue中的所有操作都是线程安全的，允许多个线程同时对其进行读写操作，无需额外的同步控制。
下面将详细介绍ConcurrentLinkedQueue的用法。
一、基本用法可以使用构造函数创建ConcurrentLinkedQueue对象，例如：```javaConcurrentLinkedQueue<Integer> queue = new ConcurrentLinkedQueue<>();```2. 添加元素可以使用add()方法向队列中添加元素，例如：```javaqueue.add(1);queue.add(2);```3. 移除元素可以使用remove()方法从队列中移除元素，如果成功则返回true，否则返回false。
例如：```javaboolean success = queue.remove(1); // true，因为1在队列中```4. 获取队列大小可以使用size()方法获取队列中当前元素数量。
例如：```javaint size = queue.size(); // 返回当前队列中的元素数量```二、并发操作ConcurrentLinkedQueue允许多个线程同时对其进行读写操作，无需额外的同步控制。
这意味着多个线程可以同时向队列中添加或移除元素，而不会发生竞争和数据不一致的情况。
这种并发操作的能力使得ConcurrentLinkedQueue在多线程环境下非常有用。
三、其他特性1. 线程安全：ConcurrentLinkedQueue是线程安全的，可以在多个线程之间共享使用，无需额外的同步控制。
linkedblockingqueue 方法
linkedblockingqueue 方法LinkedBlockingQueue是Java中提供的一个高性能的有界阻塞队列。
它底层采用链表实现，支持并发读写，广泛应用于Java多线程编程中。
LinkedBlockingQueue方法1. add(E) ：添加元素到队列尾部，如果队列已满，会抛出IllegalStateException异常。
2. offer(E) ：添加元素到队列尾部，如果队列已满，会返回false。
3. put(E) ：添加元素到队列尾部，如果队列已满，会一直阻塞。
4. offer(E, timeout, TimeUnit) ：添加元素到队列尾部，如果队列已满，会等待指定时间，如果还是无法添加，会返回false。
5. poll() ：获取并移除队列头部元素，如果队列为空，会返回null。
6. remove() ：获取并移除队列头部元素，如果队列为空，会抛出NoSuchElementException异常。
7. take() ：获取并移除队列头部元素，如果队列为空，会一直阻塞。
8. poll(timeout, TimeUnit) ：获取并移除队列头部元素，如果队列为空，会等待指定时间，如果还是没有元素，会返回null。
9. peek() ：获取但不移除队列头部元素，如果队列为空，会返回null。
10. size() ：获取队列中元素个数。
11. drainTo(Collection) ：将队列中所有元素移除并添加到给定集合中。
特点1.阻塞队列：当队列满时，put()方法将阻塞调用线程，直到队列变得可用；当队列为空时，take()方法将阻塞调用线程，直到队列变得可用。
2.并发安全性：是使用重入锁（ReentrantLock）来实现线程同步，同时使用两个Condition来实现所有元素插入插入条件队列和所有元素删除的条件队列，从而避免线程竞争。
3.有界队列：队列大小可以设置成有限的，从而避免了由于内存不足而导致的系统崩溃。
queue take 和offer方法
queue take 和offer方法queue的take()和offer()方法是Java中用于操作队列的两个常用方法。
它们分别用于从队列中取出元素和向队列中添加元素。
下面将详细介绍这两个方法的功能和使用方法。
1. take()方法：take()方法用于从队列中取出并删除队列的头部元素。
如果队列为空，该方法会让当前线程进入等待状态，直到有元素可用或者线程被中断。
当有元素可用时，该方法会立即返回并返回队头元素。
使用示例：```BlockingQueue<String> queue = new LinkedBlockingQueue<>();try {String element = queue.take();System.out.println("从队列中取出元素：" + element);} catch (InterruptedException e) {e.printStackTrace();}```2. offer()方法：offer()方法用于向队列的尾部添加元素。
如果队列已满，该方法会立即返回false；否则，将元素添加到队列中，并返回true。
使用示例：```BlockingQueue<String> queue = new LinkedBlockingQueue<>(5);boolean result = queue.offer("element");if (result) {System.out.println("元素添加成功");} else {System.out.println("队列已满，添加元素失败");}```需要注意的是，take()方法在队列为空时会使当前线程等待，而offer()方法在队列已满时会立即返回false。
因此，在使用这两个方法时要注意处理可能发生的线程阻塞或添加失败的情况。
javaqueue的用法
javaqueue的用法Java Queue 的用法Java Queue 是一种基于 FIFO（先进先出）原则的集合框架，可以用于存储和管理一组元素。
在Java 中，Queue 接口是一个标准的接口，它定义了队列的基本操作方法。
Queue 接口有许多实现类，包括LinkedList、PriorityQueue 和 ArrayDeque 等。
1. 创建一个 Queue在 Java 中创建一个 Queue 可以使用以下代码：```Queue<String> queue = new LinkedList<>();```这将创建一个 LinkedList 类型的队列。
您也可以使用 PriorityQueue 或 ArrayDeque 类型来创建队列。
2. 添加元素到队列Java Queue 提供了两种方法来添加元素到队列中：```offer(E element)：将指定元素插入此队列。
add(E element)：将指定元素插入此队列。
如果插入失败，则抛出异常。
```示例代码：```queue.offer("a");queue.add("b");queue.offer("c");```3. 获取并删除队首元素Java Queue 提供了两种方法来获取并删除队首元素：```poll()：获取并删除此队列的头部。
remove()：获取并删除此队列的头部。
如果操作失败，则抛出异常。
```示例代码：```String head = queue.poll();System.out.println(head);String head2 = queue.remove();System.out.println(head2);```输出结果为：```ab```4. 获取但不删除队首元素Java Queue 提供了两种方法来获取但不删除队首元素：```peek()：获取但不删除此队列的头部。
java中queue的常用方法
java中queue的常⽤⽅法LinkedList是Queue的实现类，可以如下声明：Queue<String> queue = new LinkedList<String>();offer，add 区别：⼀些队列有⼤⼩限制，因此如果想在⼀个满的队列中加⼊⼀个新项，多出的项就会被拒绝。
这时新的 offer ⽅法就可以起作⽤了。
它不是对调⽤ add() ⽅法抛出⼀个 unchecked 异常，⽽只是得到由 offer() 返回的 false。
poll，remove 区别：remove() 和 poll() ⽅法都是从队列中删除第⼀个元素。
remove() 的⾏为与 Collection 接⼝的版本相似， 但是新的 poll() ⽅法在⽤空集合调⽤时不是抛出异常，只是返回 null。
因此新的⽅法更适合容易出现异常条件的情况。
peek，element区别：element() 和 peek() ⽤于在队列的头部查询元素。
与 remove() ⽅法类似，在队列为空时， element() 抛出⼀个异常，⽽ peek() 返回 null。
常⽤操作(注意只有Deque及其⼦类才可以使⽤，详情看源码)操作头操作头操作尾操作尾会抛异常不会抛异常会抛异常不会抛异常插⼊addFirst(e)offerFirst(e)addLast(e)offerLast(e)删除removeFirst()pollFirst()removeLast()pollLast()取值getFirst()peekFirst()getLast()peekLast() Deque实现队列操作：操作队列⽅法相同操作⽅法会抛异常⼊队add(e)addLast(e)出队remove()removeFirst()得到队头的引⽤element()getFirst()不会抛异常⼊队offer(e)offerLast(e)出队poll()pollFirst()得到队头的引⽤peek()peekFirst()⽤Deque可以实现Stack的功能：注意采⽤的是头插法，所以出栈也是从头出的存在下列⽅法，功能⼀样，名称有区别：push(E e) : addFirst(E e)pop() : removeFirst()peek() ： peekFirst()Java使⽤Deque实现栈的功能，注意只调⽤push / pop /peek 即可，避免调⽤Deque的其它⽅法Map中定义的⽅法：添加、删除、修改操作：Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中void putAll(Map m):将m中的所有key-value对存放到当前map中Object remove(Object key)：移除指定key的key-value对，并返回valuevoid clear()：清空当前map中的所有数据元素查询的操作：Object get(Object key)：获取指定key对应的valueboolean containsKey(Object key)：是否包含指定的keyboolean containsValue(Object value)：是否包含指定的valueint size()：返回map中key-value对的个数boolean isEmpty()：判断当前map是否为空boolean equals(Object obj)：判断当前map和参数对象obj是否相等元视图操作的⽅法：Set keySet()：返回所有key构成的Set集合Collection values()：返回所有value构成的Collection集合Set entrySet()：返回所有key-value对构成的Set集合总结：常⽤⽅法：添加：put(Object key,Object value)删除：remove(Object key)修改：put(Object key,Object value)查询：get(Object key)长度：size()遍历：keySet() / values() / entrySet()。
queue的poll方法
queue的poll方法队列（queue）是一种常见的数据结构，在计算机科学中被广泛使用。
队列通常被描述为一条通道，数据以先进先出（First-In-First-Out, FIFO）的方式进出。
Java中的Queue是一个非常常见的队列实现。
它是一个接口，包含了多个方法，其中最常用的方法是add()（添加元素）、remove()（移除元素）和poll()（移除并返回队列的头部元素）。
在本篇文章中，我们将对Queue的poll()方法进行详细介绍，并提供一些使用示例。
1. Java中Queue Interface的定义Java中的Queue Interface是一个集合接口，它继承自java.util.Collection接口。
Queue Interface定义了一些常见的添加元素、删除元素、检查队首、队尾元素以及检查队列的大小的方法。
下面是Queue interface中最常用的方法：boolean add(E element)：将给定元素插入此队列中。
E remove()：移除并返回此队列的头部。
E poll()：移除并返回此队列的头部，如果此队列为空，则返回null。
E peek()：检索但不移除此队列的头部，如果此队列为空，则返回null。
int size()：返回队列中元素的数量。
2. poll()方法的详细介绍在Java中，poll()方法用于移除并返回队列的头部元素。
如果队列为空，则返回null。
下面是poll()方法的语法：public E poll()下面是poll()方法的一些关键特征：下面是一个基本的Queue Interface的实现示例。
在这个示例中，我们将从队列中移除一些元素，并打印剩余的元素。
import java.util.LinkedList;import java.util.Queue;public class QueueExample {// 添加元素到队列queue.add(1);queue.add(2);queue.add(3);// 打印队列中的所有元素System.out.println("队列中的元素：" + queue);输出结果：队列中的元素：[1, 2, 3]移除并返回的元素：1剩余的元素：[2, 3]在上面的代码中，我们创建了一个Queue，并添加三个整数到该队列中。
java 队列方法
java 队列方法
Java中的队列（Queue）是一种先进先出（FIFO）的数据结构。
常用的队列方法有以下几种：
1. add(E e)：将元素添加到队尾，若队列满了则抛出异常；
2. offer(E e)：将元素添加到队尾，若队列满了则返回false；
3. remove()：返回队头元素并将其从队列中移除，若队列为空
则抛出异常；
4. poll()：返回队头元素并将其从队列中移除，若队列为空则
返回null；
5. element()：返回队头元素但不将其从队列中移除，若队列为
空则抛出异常；
6. peek()：返回队头元素但不将其从队列中移除，若队列为空
则返回null。
除了以上方法之外，队列还有一些其他的常用方法，比如
size()方法用于返回队列的大小，isEmpty()方法用于判断队列
是否为空等。
需要注意的是，Java中的Queue接口是一个泛型接口，因此
可以存储任何类型的对象。
常用的实现类有LinkedList和ArrayDeque。
其中，LinkedList的底层实现是一个双向链表，
而ArrayDeque则是一个循环数组。
两者的区别在于
LinkedList的插入和删除操作比较慢，但随机访问元素比ArrayDeque快；而ArrayDeque的插入和删除操作比较快，但
随机访问元素比LinkedList慢。
使用队列可以简化程序设计，使得任务能够按照一定的顺序进行处理。
在Java程序设计中，队列经常被用于异步处理，多线程编程等场景中。
queue的用法java
queue的用法java队列（Queue）是一种数据结构，它遵循先进先出（FIFO）的原则，即最早加入队列的元素最早被取出。
在Java中，有多种方式可以实现队列，其中最常见的是使用java.util.Queue接口及其实现类。
一、java.util.Queue接口java.util.Queue是java.util包中的一个接口，它定义了队列的通用行为。
Java提供了多个Queue实现类，如LinkedList、ArrayDeque等。
使用这些类创建队列非常简单，只需创建一个对象即可。
二、使用LinkedList实现QueueLinkedList类实现了Queue接口，因此可以使用它来创建队列。
以下是一个使用LinkedList实现Queue的示例：```javaQueue<String>queue=newLinkedList<>();queue.add("apple");//添加元素到队列中queue.add("banana");//添加元素到队列中StringfrontElement=queue.poll();//从队列中取出第一个元素System.out.println(frontElement);//输出：apple```三、使用ArrayDeque实现QueueArrayDeque类也实现了Queue接口，但它与LinkedList相比，更适合于频繁的入队和出队操作。
以下是一个使用ArrayDeque实现Queue的示例：```javaQueue<String>queue=newArrayDeque<>();queue.add("apple");//添加元素到队列中queue.add("banana");//添加元素到队列中StringfrontElement=queue.pollFirst();//从队列中取出第一个元素（等同于poll()方法）System.out.println(frontElement);//输出：apple```四、其他Queue实现类除了LinkedList和ArrayDeque之外，Java还提供了其他一些Queue实现类，如PriorityQueue等。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
如何在java中，实现对queue的用法学习java时，queue的用法很重要，其实队列是一种数据结构．它有两个基本操作：在队列尾部加人一个元素，和从队列头部移除一个元素就是说，队列以一种先进先出的方式管理数据，如果你试图向一个已经满了的阻塞队列中添加一个元素或者是从一个空的阻塞队列中移除一个元索，将导致线程阻塞．在多线程进行合作时，阻塞队列是很有用的工具。
工作者线程可以定期地把中间结果存到阻塞队列中而其他工作者线线程把中间结果取出并在将来修改它们。
在java的学习中，Queue继承了Collection接口。
可以用LinkedList实现了Queue接口。
在方法中的参数类型如果是Queue 时，就完全只能访问Queue接口所定义的方法了，而不能直接访问LinkedList的非Queue的方法。
BlockingQueue 继承了Queue接口。
如果第一个线程集运行得比第二个慢，则第二个线程集在等待结果时就会阻塞。
如果第一个线程集运行得快，那么它将等待第二个线程集赶上来。
下表显示了jdk1.5中的阻塞队列的操作：add增加一个元索，如果队列已满，则抛出一个IIIegaISlabEepeplian异常Remove移除并返回队列头部的元素，如果队列为空，则抛出一个NoSuchElementException异常Element返回队列头部的元素，如果队列为空，则抛出一个NoSuchElementException异常offer添加一个元素并返回true ，如果队列已满，则返回falsePoll移除并返问队列头部的元素，如果队列为空，则返回nullPeek返回队列头部的元素，如果队列为空，则返回nullput添加一个元素，如果队列满，则阻塞take移除并返回队列头部的元素，如果队列为空，则阻塞remove、element、offer 、poll、peek 其实是属于Queue接口。
阻塞队列的操作可以根据它们的响应方式分为以下三类：aad、removee和element操作在你试图为一个已满的队列增加元素或从空队列取得元素时抛出异常。
当然，在多线程程序中，队列在任何时间都可能变成满的或空的，所以你可能想使用offer、poll、peek方法。
这些方法在无法完成任务时只是给出一个出错示而不会抛出异常。
注意：poll和peek方法出错进返回null。
因此，向队列中插入null 值是不合法的。
还有带超时的offer和poll方法变种，例如，下面的调用：boolean success = q.offer(x,100,LISECONDS);尝试在100毫秒内向队列尾部插入一个元素。
如果成功，立即返回true；否则，当到达超时进，返回false。
同样地，调用：Object head = q.poll(100, LISECONDS);如果在100毫秒内成功地移除了队列头元素，则立即返回头元素；否则在到达超时时，返回null。
最后，我们有阻塞操作put和take。
put方法在队列满时阻塞，take 方法在队列空时阻塞。
java.ulil.concurrent包提供了阻塞队列的4个变种。
默认情况下，LinkedBlockingQueue的容量是没有上限的（说的不准确，在不指定时容量为Integer.MAX_VALUE，不要然的话在put时怎么会受阻呢），但是也可以选择指定其最大容量，它是基于链表的队列，此队列按FIFO （先进先出）排序元素。
ArrayBlockingQueue在构造时需要指定容量，并可以选择是否需要公平性，如果公平参数被设置true，等待时间最长的线程会优先得到处理（其实就是通过将ReentrantLock设置为true来达到这种公平性的：即等待时间最长的线程会先操作）。
通常，公平性会使你在性能上付出代价，只有在的确非常需要的时候再使用它。
它是基于数组的阻塞循环队列，此队列按FIFO（先进先出）原则对元素进行排序。
PriorityBlockingQueue是一个带优先级的队列，而不是先进先出队列。
元素按优先级顺序被移除，该队列也没有上限（看了一下源码，PriorityBlockingQueue是对PriorityQueue的再次包装，是基于堆数据结构的，而PriorityQueue是没有容量限制的，与ArrayList一样，所以在优先阻塞队列上put时是不会受阻的。
虽然此队列逻辑上是无界的，但是由于资源被耗尽，所以试图执行添加操作可能会导致OutOfMemoryError），但是如果队列为空，那么取元素的操作take就会阻塞，所以它的检索操作take是受阻的。
另外，往入该队列中的元素要具有比较能力。
最后，DelayQueue（基于PriorityQueue来实现的）是一个存放Delayed 元素的无界阻塞队列，只有在延迟期满时才能从中提取元素。
该队列的头部是延迟期满后保存时间最长的Delayed 元素。
如果延迟都还没有期满，则队列没有头部，并且poll将返回null。
当一个元素的getDelay(TimeUnit.NANOSECONDS) 方法返回一个小于或等于零的值时，则出现期满，poll就以移除这个元素了。
此队列不允许使用null 元素。
下面是延迟接口：Java代码1.public interface Delayed extends Comparable<Delayed> {2. longgetDelay(TimeUnit unit);3.}放入DelayQueue的元素还将要实现compareTo方法，DelayQueue 使用这个来为元素排序。
下面的实例展示了如何使用阻塞队列来控制线程集。
程序在一个目录及它的所有子目录下搜索所有文件，打印出包含指定关键字的文件列表。
从下面实例可以看出，使用阻塞队列两个显著的好处就是：多线程操作共同的队列时不需要额外的同步，另外就是队列会自动平衡负载，即那边（生产与消费两边）处理快了就会被阻塞掉，从而减少两边的处理速度差距。
下面是具体实现：Java代码1.public class BlockingQueueTest {2. public static void main(String[] args) {3. Scanner in = new Scanner(System.in);4. System.out.print("Enter base directory (e.g. /usr/local/jdk5.0/src): ");5. String directory = in.nextLine();6. System.out.print("Enter keyword (e.g. volatile): ");7. String keyword = in.nextLine();8.9. final int FILE_QUEUE_SIZE = 10;// 阻塞队列大小10. final int SEARCH_THREADS = 100;// 关键字搜索线程个数11.12. // 基于ArrayBlockingQueue的阻塞队列13. BlockingQueue<File> queue = new ArrayBlockingQueue<File>(14. FILE_QUEUE_SIZE);15.16. //只启动一个线程来搜索目录17. FileEnumerationTask enumerator = new FileEnumerationTask(queue,18. new File(directory));19. new Thread(enumerator).start();20.21. //启动100个线程用来在文件中搜索指定的关键字22. for (int i = 1; i <= SEARCH_THREADS; i++)23. new Thread(new SearchTask(queue, keyword)).start();24. }25.}26.classFileEnumerationTask implements Runnable {27. //哑元文件对象，放在阻塞队列最后，用来标示文件已被遍历完28. public static File DUMMY = new File("");29.30. privateBlockingQueue<File> queue;31. private File startingDirectory;32.33. publicFileEnumerationTask(BlockingQueue<File> queue, File startingDirectory) {34. this.queue = queue;35. this.startingDirectory = startingDirectory;36. }37.38. public void run() {39. try {40. enumerate(startingDirectory);41. queue.put(DUMMY);//执行到这里说明指定的目录下文件已被遍历完42. } catch (InterruptedException e) {43. }44. }45.46. // 将指定目录下的所有文件以File对象的形式放入阻塞队列中47. public void enumerate(File directory) throwsInterruptedException {48. File[] files = directory.listFiles();49. for (File file : files) {50. if (file.isDirectory())51. enumerate(file);52. else53. //将元素放入队尾，如果队列满，则阻塞54. queue.put(file);55. }56. }57.}58.classSearchTask implements Runnable {59. privateBlockingQueue<File> queue;60. private String keyword;61.62. publicSearchTask(BlockingQueue<File> queue, String keyword) {63. this.queue = queue;64. this.keyword = keyword;65. }66.67. public void run() {68. try {69. boolean done = false;70. while (!done) {71. //取出队首元素，如果队列为空，则阻塞72. File file = queue.take();73. if (file == FileEnumerationTask.DUMMY) {74. //取出来后重新放入，好让其他线程读到它时也很快的结束75. queue.put(file);76. done = true;77. } else78. search(file);79. }80. } catch (IOException e) {81. e.printStackTrace();82. } catch (InterruptedException e) {83. }84. }85. public void search(File file) throws IOException {86. Scanner in = new Scanner(new FileInputStream(file));87. intlineNumber = 0;88. while (in.hasNextLine()) {89. lineNumber++;90. String line = in.nextLine();91. if (line.contains(keyword))92. System.out.printf("%s:%d:%s%n", file.getPath(), lineNumber,93. line);94. }95. in.close();96. }97.}。