同样环境与 java 做了个对比，差的不是一星半点！先看执行结果，同样环境下读取同一个400M左右数据文件，以下截图是测试结果：
JAVA 代码：
package ccb;
import java.io.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class syc
{
static String fp = "D:\\ccb\\ONL_STLM_JNL_410_20190625.dat";
// static String fp = "D:\\ccb\\ONL.dat";
static File sourceFile = new File(fp);
public static void main(String[] args) throws Exception
{
long s0 = System.currentTimeMillis();
long lnu = get_line_number();
System.out.println(String.format("文件共有：%s行", lnu));
long s1 = System.currentTimeMillis();
System.out.println(String.format("统计文件行数用时：%s", (s1-s0)));
long t1 = System.currentTimeMillis();
// 读取文件内容，并进行归类
Map<String, List<String>> mapList = read_data();
long t2 = System.currentTimeMillis();
// 将文件内容写入磁盘
write_data(mapList);
long t3 = System.currentTimeMillis();
System.out.println(String.format("t1=%s, t2=%s, 读取耗时=%s, 写入耗时=%s, 合计耗时=%s",
t1, t2, (t2-t1), (t3-t2), (t3-t1)));
}
/**
* 带缓存读取文件，归类
* @return Map
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public static Map<String, List<String>> read_data() {
Map<String, List<String>> mapList = new HashMap<>();
// 带缓存的输入流读取
BufferedReader buff = null;
try {
buff = new BufferedReader(new FileReader(sourceFile));
String line = "";
while ((line = buff.readLine()) != null) {
String[] items = line.split("\\|@\\|");
String type_name = items[1];
if (mapList.containsKey(type_name)) {
List tempList = mapList.get(type_name);
tempList.add(line);
mapList.put(type_name, tempList);
} else {
List lines = new ArrayList<>();
lines.add(line);
mapList.put(type_name, lines);
}
}
buff.close();
} catch (Exception e) {
e.printStackTrace();
} finally {
if (buff != null) {
try {
buff.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
System.out.println(String.format("找到的%s类别:", mapList.size()));
return mapList;
}
/**
* 带缓存写入文件
* @param mapList
* @throws IOException
*/
public static void write_data(Map<String, List<String>> mapList) throws IOException {
FileWriter fWriter = new FileWriter(sourceFile + ".result");
BufferedWriter buff = new BufferedWriter(fWriter);
for (Map.Entry<String, List<String>> entry : mapList.entrySet()) {
List<String> lines = entry.getValue();
System.out.println(String.format("--%s %s", entry.getKey(), lines.size()));
for (String line : lines) {
buff.write(line + "\n");
}
}
try {
buff.close();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 返回文件的总行数
* @return
*/
public static long get_line_number() throws IOException {
File file = new File(fp);
FileReader reader = new FileReader(file);
LineNumberReader line_num_reader = new LineNumberReader(reader);
long lineNu = 0;
while (line_num_reader.readLine() != null)
lineNu++;
return lineNu;
}
}
Golang 代码：
package main
import (
"bufio"
_ "container/list"
"fmt"
"io"
"os"
"strings"
"time"
)
func main() {
file_path := "ONL_STLM_JNL_410_20190625.dat"
new_file_path := file_path + ".result"
t1 := time.Now().UnixNano() / 1e3
// lines := read_file(file_path)
mapList := read_file(file_path)
t2 := time.Now().UnixNano() / 1e3
write_file(mapList, new_file_path)
t3 := time.Now().UnixNano() / 1e3
fmt.Printf("t1=%v, t2=%v, 读取耗时=%v, 写入耗时=%v, 合计耗时=%v\n",
t1, t2, (t2-t1)/1e3, (t3-t2)/1e3, (t3-t1)/1e3)
}
// 逐行读取文件
func read_file(fp string) map[string][]string {
file, err := os.Open(fp)
if err != nil {
fmt.Printf("读取文件错误: %s\n", err)
return nil
}
defer file.Close()
br := bufio.NewReader(file)
//声明一个切片
// var file_list []string
//声明一个 map
mapList := make(map[string][]string)
for {
b_line, _, err := br.ReadLine()
if err == io.EOF {
break
}
// 向 list 中追加元素
// file_list.PushBack(string(line))
// file_list = append(file_list, string(line)+"\n")
line := string(b_line)
// 使用map
items := strings.Split(line, "|@|")
type_name := items[1]
if mapValue, has_key := mapList[type_name]; has_key {
mapValue := append(mapValue, line)
mapList[type_name] = mapValue
} else {
//创建一个临时切片
tmp_slice := []string{line}
mapList[type_name] = tmp_slice
}
}
// 输出 list 长度
// fmt.Println(file_list)
return mapList
}
func line2map(lines []string) map[string][]string {
/*
_, err := os.Stat(new_file_path)
if err == nil {
//文件存在，删除重建
}
*/
//类别
mapList := make(map[string][]string)
//第一次循环，查找分类
for _, value := range lines {
item := strings.Split(value, "|@|")
//类别名称，作为map主键
key := item[1]
if mapValue, has_key := mapList[key]; has_key {
//包含该类别, map的value继续添加
mapValue := append(mapValue, value)
mapList[key] = mapValue
} else {
//不包含该类别, 新增一个key
lines := []string{value}
mapList[key] = lines
}
/*
//判断类型是否在切片中
_, found := in_array(classes, item[1])
if !found {
classes = append(classes, item[1])
}
*/
}
//找到的类别 共12个类别
fmt.Printf("找到的%d类别：\n", len(mapList))
return mapList
}
/*
Find获取一个切片并在其中查找元素。
如果找到它，它将返回它的密钥，否则它将返回-1和一个错误的bool
*/
//从切片中查找
func in_array(slice []string, val string) (int, bool) {
for i, item := range slice {
if item == val {
return i, true
}
}
return -1, false
}
// 写入文件
func write_file(mapList map[string][]string, new_file_path string) {
file_handle, err := os.OpenFile(new_file_path, os.O_CREATE|os.O_RDWR, 0666)
buf := bufio.NewWriter(file_handle)
if err != nil {
fmt.Println("打开新文件错误：", err)
return
}
defer file_handle.Close()
//遍历map
for key, value := range mapList {
fmt.Printf("--%s %v\n", key, len(value))
for nu := range value {
// fmt.Print(value[nu]) //行末带有换行符
buf.WriteString(value[nu])
}
}
//缓存写入文件
/*
fmt.Println(item)
fmt.Printf("%v | %v", key, string(value))
*/
err = buf.Flush()
if err != nil {
fmt.Printf("写入磁盘错误： ", err)
}
}
