如何使用scanner（java）处理它？

我有一个关于扫描仪的问题；我在一家小公司工作；我们有一个软件；它生成一个大的文本文件；我们必须从中获得一些有用的信息；为了节省时间，我想用java编写一个简单的应用程序；你能指引我吗

例如，我想要这个输出

输出

---

射频识别：25 布莱德：562 WifiID:2610 RFID:33

RFID计数：2

比如,；这是我的文本文件，因为我们的软件生成的每个文件都有14000行：）

我用这个源代码测试它，但我不能处理它；

---

请帮帮我

---

非常感谢…

您的第一行有问题

您需要在字符串文本中转义反斜杠（

“i:\\1.txt”

而不是

“i:\1.txt”

）

用于读取文件的

扫描仪

构造函数采用

文件

参数（或

InputStream

参数）。接受

字符串

参数的构造函数正在读取该实际字符串。看

试一试

一些起始代码：

String filename = "your_text_file";
Scanner sc = new Scanner(filename);

// use the scanner to iterate through every line in the file:
try{
while(sc.hasNextLine()){
    String line = sc.nextLine();
    // split the line up into space-separated tokens:
    String[] tokens = line.split();
    // look through the tokens to find what you are looking for:
    for(int i = 0; i<tokens.length; i++){
        if(tokens[i].equals("search_word){
             // Do stuff
        }
    }
}
} // end try
catch(Exception e){}

String filename=“您的文本文件”；
Scanner sc=新扫描仪（文件名）；
//使用扫描仪遍历文件中的每一行：
试一试{
while（sc.hasNextLine（））{
字符串行=sc.nextLine（）；
//将该行拆分为空格分隔的标记：
String[]tokens=line.split（）；
//通过令牌查找您要查找的内容：
对于（int i=0；i您建议的源代码不会执行您想要的操作。Scanner使用分隔符分隔输入。默认分隔符为空白（空格、制表符或换行符）。Scanner.hasNext（）只会告诉您是否有新的空白标记。Scanner.next（）只返回该标记。请注意，Scanner.findInLine（pattern）不会影响这些标记，因为它只会在当前行中搜索提供的模式

可能是这样的（我没有测试过）：

我建议您忘记使用scanner，只使用一个BufferedReader和两个Pattern对象，因为该方法对于您想要执行的操作更加灵活。
准备运行：

public class ScannerTest {

    private static void readFile(String fileName) {

        try {
            HashMap<String, Integer> map = new HashMap<String, Integer>();
            File file = new File(fileName);

            Scanner scanner = new Scanner(file).useDelimiter(";");
            while (scanner.hasNext()) {
                String token = scanner.next();
                String[] split = token.split(":");
                if (split.length == 2) {
                    Integer count = map.get(split[0]);
                    map.put(split[0], count == null ? 1 : count + 1);
                    System.out.println(split[0] + ":" + split[1]);
                } else {
                    split = token.split("=");
                    if (split.length == 2) {
                        Integer count = map.get(split[0]);
                        map.put(split[0], count == null ? 1 : count + 1);
                        System.out.println(split[0] + ":" + split[1]);
                    }
                }
            }
            scanner.close();
            System.out.println("Counts:" + map);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        readFile("test.txt");
    }
}

公共类扫描测试{
私有静态void readFile（字符串文件名）{
试一试{
HashMap=newHashMap（）；
文件=新文件（文件名）；
Scanner Scanner=新的扫描仪（文件）。使用分隔符（；）；
while（scanner.hasNext（））{
字符串标记=scanner.next（）；
String[]split=token.split（“：”）；
如果（split.length==2）{
整数计数=map.get（拆分[0]）；
put（拆分[0]，计数==null？1:count+1）；
System.out.println（拆分[0]+“：”+拆分[1]）；
}否则{
拆分=标记。拆分（“”）；
如果（split.length==2）{
整数计数=map.get（拆分[0]）；
put（拆分[0]，计数==null？1:count+1）；
System.out.println（拆分[0]+“：”+拆分[1]）；
}
}
}
scanner.close（）；
System.out.println（“计数：+map”）；
}catch（filenotfounde异常）{
e、 printStackTrace（）；
}
}
公共静态void main（字符串[]args）{
readFile（“test.txt”）；
}
}
下面是一个使用以下内容的示例：

import java.io.IOException；
导入java.io.StreamTokenizer；
导入java.io.StringReader；
导入java.util.HashMap；
导入java.util.Scanner；
公共级扫描测试{
私有静态最终字符串s=“”
+“aaaa；RFID=25；\n”
+“BBBB；BBBBBBBB；bbbbbbbbbbbb；\n”
+“CCCCC；FFFDDSFDD；BLUID=562；DFSFDFSF；\n”
+“fgfdgdf；terter；fdgfdgtryt；\n”
+“trtretrre；WifiID=2610；trterytuytuyu；\n”
+“ZXZXZXZ；popopopwwepp；RFID:33；aasasds…\n”
+“gfdgfgfd；GFDGFD；FDGFD；\n”；
公共静态void main（字符串[]args）{
长启动=System.nanoTime（）；
标记化；
System.out.println（System.nanoTime（）-start）；
start=System.nanoTime（）；
扫描；
System.out.println（System.nanoTime（）-start）；
}
私有静态void标记化（字符串s）{
HashMap=newHashMap（）；
StreamTokenizer令牌=新的StreamTokenizer（新的StringReader）；
tokens.whitespaceChars（“；”，“；”）；
试一试{
int标记；
字符串id；
做{
id=tokens.sval；
token=tokens.nextToken（）；
如果（令牌=='='| |令牌=='：'）{
token=tokens.nextToken（）；
整数计数=map.get（id）；
put（id，count==null？1:count+1）；
System.out.println（id+“：”+（int）tokens.nval）；
}
}while（token！=StreamTokenizer.TT_EOF）；
System.out.println（“计数：+map”）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
}
专用静态无效扫描（字符串s）{
HashMap=newHashMap（）；
Scanner Scanner=新的扫描仪。使用分隔符（；）；
while（scanner.hasNext（））{
字符串标记=scanner.next（）；
String[]split=token.split（“：”）；
如果（split.length==2）{
整数计数=map.get（拆分[0]）；
put（拆分[0]，计数==null？1:count+1）；
System.out.println（拆分[0]+“：”+拆分[1]）；
}否则{
拆分=标记。拆分（“”）；
如果（split.length==2）{
整数计数=map.get（拆分[0]）；
put（拆分[0]，计数==null？1:count+1）；
System.out.println（拆分[0]+“：”+拆分[1]）；
}
}
}
scanner.close（）；
System.out.println（“计数：+map”）；
Scanner scanner = new Scanner(new File("i:\\1.txt"));

String filename = "your_text_file";
Scanner sc = new Scanner(filename);

// use the scanner to iterate through every line in the file:
try{
while(sc.hasNextLine()){
    String line = sc.nextLine();
    // split the line up into space-separated tokens:
    String[] tokens = line.split();
    // look through the tokens to find what you are looking for:
    for(int i = 0; i<tokens.length; i++){
        if(tokens[i].equals("search_word){
             // Do stuff
        }
    }
}
} // end try
catch(Exception e){}

Scanner scanner = new Scanner("i:\\1.txt");
scanner.useDelimiter(";");
Pattern words = Pattern.compile("(RFID=|BLUID=|WifiID=)");//just separate patterns with |
while (scanner.hasNextLine()) {
  key = scanner.findInLine(words);
  while (key != null) {
    String value = scanner.next();
    if (key.equals("RFID=") {
      System.out.print("RFID:" + value);
    } //continue with else ifs for other keys
    key = scanner.findInLine(words);
  }
  scanner.nextLine();
}

public class ScannerTest {

    private static void readFile(String fileName) {

        try {
            HashMap<String, Integer> map = new HashMap<String, Integer>();
            File file = new File(fileName);

            Scanner scanner = new Scanner(file).useDelimiter(";");
            while (scanner.hasNext()) {
                String token = scanner.next();
                String[] split = token.split(":");
                if (split.length == 2) {
                    Integer count = map.get(split[0]);
                    map.put(split[0], count == null ? 1 : count + 1);
                    System.out.println(split[0] + ":" + split[1]);
                } else {
                    split = token.split("=");
                    if (split.length == 2) {
                        Integer count = map.get(split[0]);
                        map.put(split[0], count == null ? 1 : count + 1);
                        System.out.println(split[0] + ":" + split[1]);
                    }
                }
            }
            scanner.close();
            System.out.println("Counts:" + map);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        readFile("test.txt");
    }
}

import java.io.IOException;
import java.io.StreamTokenizer;
import java.io.StringReader;
import java.util.HashMap;
import java.util.Scanner;

public class ScannerTest {

    private static final String s = ""
        + "AAAAAAAAAAAA;RFID=25;\n"
        + "BBBB;BBBBBBBB;BBBBBBBBBB;\n"
        + "CCCCC;fffdsfdsfdfsd;BLUID=562;dfsdfsf;\n"
        + "fgfdgdf;terter;fdgfdgtryt;\n"
        + "trtretrre;WifiID=2610;trterytuytutyu;\n"
        + "zxzxzxzxz;popopopwwepp;RFID:33;aasasds…\n"
        + "gfdgfgfd;gfdgfdgfd;fdgfgfgfd;\n";

    public static void main(String[] args) {
        long start = System.nanoTime();
        tokenize(s);
        System.out.println(System.nanoTime() - start);
        start = System.nanoTime();
        scan(s);
        System.out.println(System.nanoTime() - start);
    }

    private static void tokenize(String s) {
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        StreamTokenizer tokens = new StreamTokenizer(new StringReader(s));
        tokens.whitespaceChars(';', ';');
        try {
            int token;
            String id;
            do {
                id = tokens.sval;
                token = tokens.nextToken();
                if (token == '=' || token == ':') {
                    token = tokens.nextToken();
                    Integer count = map.get(id);
                    map.put(id, count == null ? 1 : count + 1);
                    System.out.println(id + ":" + (int) tokens.nval);
                }
            } while (token != StreamTokenizer.TT_EOF);
            System.out.println("Counts:" + map);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private static void scan(String s) {
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        Scanner scanner = new Scanner(s).useDelimiter(";");
        while (scanner.hasNext()) {
            String token = scanner.next();
            String[] split = token.split(":");
            if (split.length == 2) {
                Integer count = map.get(split[0]);
                map.put(split[0], count == null ? 1 : count + 1);
                System.out.println(split[0] + ":" + split[1]);
            } else {
                split = token.split("=");
                if (split.length == 2) {
                    Integer count = map.get(split[0]);
                    map.put(split[0], count == null ? 1 : count + 1);
                    System.out.println(split[0] + ":" + split[1]);
                }
            }
        }
        scanner.close();
        System.out.println("Counts:" + map);
    }
}

RFID:25
BLUID:562
WifiID:2610
RFID:33
Counts:{RFID=2, BLUID=1, WifiID=1}
1103000
RFID:25
BLUID:562
WifiID:2610
RFID:33
Counts:{RFID=2, BLUID=1, WifiID=1}
22772000