使用Java中的RandomAccessFile类来实现将一个20MB的文本文件倒序写入另一个文件的操作。该类提供了以随机访问方式读写文件的功能。我们可以使用该类打开原文件和目标文件，然后在原文件中从后往前读取每个字符，并将其逐个写入目标文件中，即可实现文件倒序的操作。
import java.io.IOException;
import java.io.RandomAccessFile;
public class ReverseFile {
public static void main(String[] args) throws IOException {
String sourceFilePath = "path/to/source/file.txt";
String targetFilePath = "path/to/target/file.txt";
// 打开原文件和目标文件
RandomAccessFile sourceFile = new RandomAccessFile(sourceFilePath, "r");
RandomAccessFile targetFile = new RandomAccessFile(targetFilePath, "rw");
// 定位到原文件的最后一个字符
long sourceLength = sourceFile.length();
sourceFile.seek(sourceLength - 1);
// 循环读取原文件中的字符，并将其逐个写入目标文件中
for (long i = sourceLength - 1; i >= 0; i--) {
sourceFile.seek(i);
char c = (char) sourceFile.read();
targetFile.write(c);
}
// 关闭文件
sourceFile.close();
targetFile.close();
}
}
Fisher-Yates shuffle算法（也称为Knuth shuffle算法）是一种用于随机打乱序列的算法，其时间复杂度为O(n)，空间复杂度为O(1)。算法的基本思想是，从序列中随机选取一个元素，将其与最后一个元素交换位置，然后在剩余的元素中随机选取一个元素，将其与倒数第二个元素交换位置，以此类推，直到所有元素都被选取完毕。
以下是使用Fisher-Yates shuffle算法实现从1到一千万随机抽取不重复数字的示例代码：
import java.util.Arrays;
import java.util.Random;
public class RandomNumbers {
public static void main(String[] args) {
int n = 10000000;
int[] numbers = new int[n];
for (int i = 0; i < n; i++) {
numbers[i] = i + 1;
}
Random random = new Random();
for (int i = n - 1; i >= 1; i--) {
int j = random.nextInt(i + 1);
int temp = numbers[i];
numbers[i] = numbers[j];
numbers[j] = temp;
}
System.out.println(Arrays.toString(Arrays.copyOfRange(numbers, 0, n)));
}
}
这段代码中，我们首先创建了一个包含1到10000000的整数数组numbers，然后使用Fisher-Yates shuffle算法将数组中的元素随机打乱顺序，最后输出前n个元素。 需要注意的是，由于Java中的数组下标从0开始，因此在实现Fisher-Yates shuffle算法时，需要将i的初始值设为n-1。另外，由于Java中的数组不能动态调整大小， 因此在输出结果时，需要使用Arrays.copyOfRange函数截取前n个元素。使用Java中的File类和HashMap类来实现将一个目录下所有TXT文档内的单词出现频次倒序输出到文件的操作。该操作可以分为两个步骤：
第一步，遍历指定目录下所有的TXT文档，读取其中的单词，并统计每个单词的出现频次。可以使用Java的IO流实现读取文件，并使用正则表达式或空格作为分隔符来分离单词。可以使用HashMap类来统计每个单词的出现频次。
第二步，将统计结果按照出现频次倒序排列，并输出到文件中。可以使用Java的集合类和IO流来实现这一步。
以下是示例代码：
import java.io.*;
import java.util.*;
public class WordFrequencyCounter {
public static void main(String[] args) throws IOException {
String dirPath = "/path/to/directory";
String outputPath = "/path/to/output/file.txt";
// 统计单词出现频次
Map<String, Integer> wordCountMap = countWords(dirPath);
// 按照出现频次倒序排列
List<Map.Entry<String, Integer>> wordCountList = new ArrayList<>(wordCountMap.entrySet());
wordCountList.sort(Map.Entry.comparingByValue(Comparator.reverseOrder()));
// 输出到文件
writeToFile(wordCountList, outputPath);
}
private static Map<String, Integer> countWords(String dirPath) throws IOException {
Map<String, Integer> wordCountMap = new HashMap<>();
File dir = new File(dirPath);
File[] files = dir.listFiles((dir1, name) -> name.toLowerCase().endsWith(".txt"));
for (File file : files) {
BufferedReader reader = new BufferedReader(new FileReader(file));
String line;
while ((line = reader.readLine()) != null) {
String[] words = line.split("\\W+");
for (String word : words) {
String key = word.toLowerCase();
wordCountMap.put(key, wordCountMap.getOrDefault(key, 0) + 1);
}
}
reader.close();
}
return wordCountMap;
}
private static void writeToFile(List<Map.Entry<String, Integer>> wordCountList, String outputPath) throws IOException {
BufferedWriter writer = new BufferedWriter(new FileWriter(outputPath));
for (Map.Entry<String, Integer> entry : wordCountList) {
writer.write(entry.getKey() + " " + entry.getValue() + "\n");
}
writer.close();
}
}
在上面的代码中，我们首先指定了目录路径和输出文件路径。然后，在countWords方法中，我们使用File类获取指定目录下所有的TXT文件，并使用BufferedReader类逐行读取文件内容。对于每一行，我们使用正则表达式\W+来分隔单词，并将单词转换为小写形式，然后使用HashMap类统计每个单词的出现频次。在writeToFile方法中，我们将统计结果按照出现频次倒序排列，并输出到指定的输出文件中。
需要注意的是，由于在读取和写入文件时会产生IOException异常，因此我们需要在代码中使用throws IOException声明可能抛出该异常。另外，在使用HashMap类统计单词出现频次时，需要小心处理单词的大小写形式，以避免同一个单词因大小写不同而被统计多次。
使用grep命令结合通配符来查找/var/log目录下所有内容包含”abc”的所有.log文件。具体命令如下：
grep -r "abc" /var/log/*.log
该命令中，-r选项表示递归地查找目录下的文件，"abc"表示要查找的内容，/var/log/*.log表示要查找的目录和文件名通配符，其中*表示匹配任意字符，.log表示匹配以.log结尾的文件名。
该命令会输出所有内容包含”abc”的.log文件的文件名和匹配的行数。如果要只输出文件名，可以使用-l选项，即：
grep -rl "abc" /var/log/*.log
该命令中，-l选项表示只输出匹配的文件名，不输出匹配的行数。
需要注意的是，grep命令默认区分大小写，如果要忽略大小写，可以使用-i选项，即：
grep -ril "abc" /var/log/*.log
该命令中，-i选项表示忽略大小写。
grep是一种常用的Linux命令，用于在文件中查找指定的文本模式。grep命令可以在一个或多个文件中搜索指定的字符串，并将包含该字符串的行输出到终端。
grep命令的基本语法如下：
grep [OPTIONS] PATTERN [FILE...]
其中，[OPTIONS]表示可选的命令选项，PATTERN表示要搜索的文本模式，[FILE...]表示要搜索的文件列表。如果没有指定文件列表，则grep命令会从标准输入中读取数据进行搜索。
grep命令常用的选项包括：
-r：递归搜索指定目录下的所有文件。-i：忽略字母大小写。-v：反向搜索，即输出不包含指定字符串的行。-w：只匹配整个单词，而不是字符串的一部分。-n：输出匹配行的行号。-c：输出匹配的行数而非具体的匹配行。
除了常用选项外，grep命令还支持一些正则表达式的语法，如^表示匹配行首，$表示匹配行尾，.表示任意单个字符等。
例如，要在文件file.txt中查找包含字符串”example”的行，可以使用以下命令：
grep "example" file.txt
如果要忽略大小写，可以使用-i选项：
grep -i "example" file.txt
如果要输出匹配行的行号，可以使用-n选项：
grep -n "example" file.txt
如果要在文件夹dir下递归地查找包含字符串”example”的行，可以使用以下命令：
grep -r "example" dir/
需要注意的是，grep命令默认是区分大小写的。如果要忽略大小写，需要使用-i选项。
要统计每个文件中包含字符串"abc"的行数，可以使用grep命令的-c选项。该选项会输出每个文件中匹配到的行数。例如，执行以下命令：
grep -rc "abc" /var/log/*.log
grep命令会递归搜索/var/log/目录下所有以.log结尾的文件，查找包含字符串"abc"的行，并输出每个文件中匹配到的行数。输出的结果格式一般为：
/var/log/somefile.log:2
/var/log/anotherfile.log:1
其中，每一行对应一个文件的搜索结果，包含两个部分：
/var/log/somefile.log：搜索结果所在的文件名。2：文件中包含字符串"abc"的行数。
需要注意的是，如果搜索结果包含多个文件，grep命令会依次输出每个文件的搜索结果，文件之间会用一个换行符分隔开。如果要统计所有文件中包含字符串"abc"的总行数，可以使用grep -rc "abc" /var/log/*.log | awk -F ':' '{s+=$2} END {print s}'命令，其中awk命令会将每行输出的第二个字段（即匹配到的行数）相加并输出总和。
awk是一种非常强大的文本处理工具，在实际使用中有很多常见的用法，以下是一些常见的awk用例：
- 提取文件中的某些字段
假设我们有一个文件data.txt，内容如下：
Alice 25 80
Bob 30 70
Charlie 40 90
如果我们想要提取该文件中每个人的姓名和分数，可以使用以下命令：
awk '{print $1, $3}' data.txt
该命令会对data.txt文件逐行读取，并输出每行的第一个和第三个字段，即每个人的姓名和分数。
- 过滤文件中的数据
假设我们有一个文件data.txt，内容如下：
Alice 25 80
Bob 30 70
Charlie 40 90
如果我们想要只输出该文件中分数大于80分的行，可以使用以下命令：
awk '$3 > 80 {print}' data.txt
该命令会对data.txt文件逐行读取，并判断每行的第三个字段是否大于80分，如果是则输出该行。
- 统计文件中某个字段的总和
假设我们有一个文件data.txt，内容如下：
Alice 25 80
Bob 30 70
Charlie 40 90
如果我们想要计算该文件中所有人的分数总和，可以使用以下命令：
awk '{sum+=$3} END {print "Total score: ", sum}' data.txt
该命令会对data.txt文件逐行读取，并将每行的第三个字段相加。在文件处理完毕后，awk命令会执行END块中的命令，计算分数总和并输出结果。
- 根据某个字段对文件进行分组
假设我们有一个文件data.txt，内容如下：
Alice 25 80
Bob 30 70
Charlie 40 90
Alice 35 85
Bob 28 75
Charlie 42 95
如果我们想要根据该文件中每个人的姓名对数据进行分组，并计算每个人的平均分数，可以使用以下命令：
awk '{sum[$1]+=$3; count[$1]+=1} END {for (name in sum) print name, sum[name]/count[name]}' data.txt
该命令会对data.txt文件逐行读取，并将每行的第一个字段作为分组依据，将每个人的分数相加并记录行数。在文件处理完毕后，awk命令会执行END块中的命令，计算每个人的平均分数并输出结果。
以上是awk的一些常见用法，还有很多其他的用法和技巧，可以根据具体需求进行学习和实践。
基于Java语言实现的读写锁示例：
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class RWLock {
private final Lock lock = new ReentrantLock();
private final Condition readCondition = lock.newCondition();
private final Condition writeCondition = lock.newCondition();
private int readCount = 0;
private int writeCount = 0;
public void readLock() throws InterruptedException {
lock.lock();
try {
while (writeCount > 0) {
readCondition.await();
}
readCount++;
} finally {
lock.unlock();
}
}
public void readUnlock() {
lock.lock();
try {
readCount--;
if (readCount == 0) {
writeCondition.signal();
}
} finally {
lock.unlock();
}
}
public void writeLock() throws InterruptedException {
lock.lock();
try {
while (readCount > 0 || writeCount > 0) {
writeCondition.await();
}
writeCount++;
} finally {
lock.unlock();
}
}
public void writeUnlock() {
lock.lock();
try {
writeCount--;
readCondition.signalAll();
writeCondition.signal();
} finally {
lock.unlock();
}
}
}
这个读写锁包含了一个ReentrantLock和两个Condition对象，以及两个计数器readCount和writeCount。readLock()方法用于获取读锁，如果有其他线程持有写锁，则当前线程会等待；readUnlock()方法用于释放读锁，如果没有其他线程持有读锁，则唤醒所有等待的写锁请求。writeLock()方法用于获取写锁，如果有其他线程持有读锁或写锁，则当前线程会等待；writeUnlock()方法用于释放写锁，如果有等待的线程，则唤醒所有等待的读锁或写锁请求。
需要注意的是，这个读写锁是一种基本的实现方式，可能存在一些性能问题，如读锁和写锁的竞争关系等。在实际使用中，需要根据具体情况进行优化和调整。
0 条评论