blocks|key|388202|text|如果你只需要计算04，你真的不需要存储整个文件。例如，你可以读取每一行，并检查它是否是04的(并添加到计数器或其他东西中)。你甚至可以逐个字符地读取文件，但这对于提高效率(如果有的话)来说可能有点乏味。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|388203|如果您需要对文件进行更复杂的处理，则此方法可能无法完成任务。但除非你具体说明那是什么，否则我不能说它到底是什么。|388204|entityMap^0|8|2|17|2|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

If you only need to count the <code>04</code>'s, you REALLY don't need to store the whole file. You could, for example, read each line and check it for <code>04</code>'s (and adding to a counter, or whatever). You could even just read character by character, but that might be a bit tedious for the slight (if any) efficiency gains.

If the processing you need to do on the file is more complex, this approach may not be up to the task. But unless you specify what that is, I can't say if it is or not.

blocks|key|386397|text|您应该使用一个地图来保存事件的计数，如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|386398|public+static+void+main(String[]+args)+throws+IOException+{
Pattern+splitter+=+Pattern.compile("\\s%2B");
try(Stream<String>+stream+=+Files.lines(Paths.get("input.txt")))+{
++++Map<String,Long>+result+=+stream.flatMap(splitter::splitAsStream)
++++++++++++.collect(Collectors.groupingBy(Function.identity(),
++++++++++++++++++++Collectors.counting()));
++++System.out.println(result);
}}|code-block|syntax|javascript|386399|或者加载数据并在多个阶段进行解析：|386400|public+static+void+main(String[]+args)+throws+IOException+{
++++//+1.+load+the+data+array
++++String[][]+data;
++++try(Stream<String>+stream+=+Files.lines(Paths.get("numbers.txt")))+{
++++++++data+=+stream.map(line+->+line.split("\\s%2B")).toArray(String[][]::new);
++++}
++++System.out.format("Total+lines+=+%25d%25n",+data.length);

++++//+2.+count+the+occurrences+of+each+word
++++Map<String,Long>+countDistinct+=+Arrays.stream(data).flatMap(Arrays::stream)
++++++++++++.collect(Collectors.groupingBy(Function.identity(),
++++++++++++++++++++Collectors.counting()));
++++System.out.println("Count+of+04+=+"+%2B+countDistinct.getOrDefault("04",+0L));

++++//+3.+calculate+correlations+
++++Map<String,Map<String,Long>>+correlations;
++++correlations+=+Arrays.stream(data).flatMap((String[]+row)+->+{
++++++++Set<String>+words+=+new+HashSet<>(Arrays.asList(row));
++++++++return+words.stream().map(word+->+new+AbstractMap.SimpleEntry<>(word,+words));
++++}).collect(Collectors.toMap(kv+->+kv.getKey(),
++++++++++++kv+->+kv.getValue().stream()
++++++++++++++++++++.collect(Collectors.toMap(Function.identity(),+v+->+1L)),
++++++++++++(map1,+map2)+->+{
++++++++++++++++map2.entrySet().forEach(kv+->+map1.merge(kv.getKey(),+kv.getValue(),+Long::sum));
++++++++++++++++return+map1;
++++++++++++}));
++++System.out.format("Lines+with+04+=+%25d%25n",+++++++++++
++++++++correlations.getOrDefault("04",+Collections.EMPTY_MAP).getOrDefault("04",+0L));
++++System.out.format("Lines+with+both+04+and+07+=+%25d%25n",+++++++++++
++++++++correlations.getOrDefault("04",+Collections.EMPTY_MAP).getOrDefault("07",+0L));
}|386401|编辑：|style|BOLD|386402|这里有一个(也许)更容易阅读的版本，它不使用流/功能方法：|386403|public+static+void+main(String[]+args)+throws+IOException+{
++++long+lineCount+=+0;
++++Map<String,Long>+wordCount+=+new+HashMap<>();
++++Map<String,Map<String,Long>>+correlations+=+new+HashMap<>();
++++try(Stream<String>+stream+=+Files.lines(Paths.get("numbers.txt")))+{
++++++++Iterable<String>+lines+=+stream::iterator;
++++++++Set<String>+lineWords+=+new+HashSet<>();
++++++++for(String+line+:+lines)+{
++++++++++++lineCount%2B%2B;
++++++++++++for(String+word+:+line.split("\\s%2B"))+{
++++++++++++++++lineWords.add(word);
++++++++++++++++wordCount.merge(word,+1L,+Long::sum);
++++++++++++}
++++++++++++for(String+wordA+:+lineWords)+{
++++++++++++++++Map<String,Long>+relate+=+correlations.computeIfAbsent(wordA,
++++++++++++++++++++++++key+->+new+HashMap<>());
++++++++++++++++for(String+wordB+:+lineWords)+{
++++++++++++++++++++relate.merge(wordB,+1L,+Long::sum);
++++++++++++++++}
++++++++++++}
++++++++}
++++}
++++System.out.format("Total+lines+=+%25d%25n",+lineCount);
++++System.out.println("Count+of+04+=+"+%2B+wordCount.getOrDefault("04",+0L));
++++System.out.format("Lines+with+04+=+%25d%25n",+++++++++++
++++++++correlations.getOrDefault("04",+Collections.EMPTY_MAP).getOrDefault("04",+0L));
++++System.out.format("Lines+with+both+04+and+07+=+%25d%25n",+++++++++++
++++++++correlations.getOrDefault("04",+Collections.EMPTY_MAP).getOrDefault("07",+0L));
}|386404|输出：|386405|项目总数=4
04计数=4
线04+=4
同时具有04和07的行=3|blockquote|386406|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.oracle.com/javase/8/docs/api/java/util/Map.html^0|7|2|0|0|0|0|0|0|3|0|0|0|0|3|0|0^^$0|@$1|2|3|4|5|6|7|17|8|@]|9|@$A|18|B|19|1|1A]]|C|$]]|$1|D|3|E|5|F|7|1B|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|1C|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|1D|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|1E|8|@$A|1F|B|1G|O|P]]|9|@]|C|$]]|$1|Q|3|R|5|6|7|1H|8|@]|9|@]|C|$]]|$1|S|3|T|5|F|7|1I|8|@]|9|@]|C|$G|H]]|$1|U|3|V|5|6|7|1J|8|@$A|1K|B|1L|O|P]]|9|@]|C|$]]|$1|W|3|X|5|Y|7|1M|8|@]|9|@]|C|$]]|$1|Z|3|-4|5|6|7|1N|8|@]|9|@]|C|$]]]|10|$11|$5|12|13|14|C|$15|16]]]]

You should use a <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Map.html" rel="nofollow noreferrer">Map</a> to hold the count of occurrences, like so:
<pre><code>public static void main(String[] args) throws IOException {
Pattern splitter = Pattern.compile(&quot;\\s+&quot;);
try(Stream&lt;String&gt; stream = Files.lines(Paths.get(&quot;input.txt&quot;))) {
 Map&lt;String,Long&gt; result = stream.flatMap(splitter::splitAsStream)
 .collect(Collectors.groupingBy(Function.identity(),
 Collectors.counting()));
 System.out.println(result);
}}
</code></pre>
Or load the data and parse it in multiple stages:
<pre><code>public static void main(String[] args) throws IOException {
 // 1. load the data array
 String[][] data;
 try(Stream&lt;String&gt; stream = Files.lines(Paths.get(&quot;numbers.txt&quot;))) {
 data = stream.map(line -&gt; line.split(&quot;\\s+&quot;)).toArray(String[][]::new);
 }
 System.out.format(&quot;Total lines = %d%n&quot;, data.length);

 // 2. count the occurrences of each word
 Map&lt;String,Long&gt; countDistinct = Arrays.stream(data).flatMap(Arrays::stream)
 .collect(Collectors.groupingBy(Function.identity(),
 Collectors.counting()));
 System.out.println(&quot;Count of 04 = &quot; + countDistinct.getOrDefault(&quot;04&quot;, 0L));

 // 3. calculate correlations 
 Map&lt;String,Map&lt;String,Long&gt;&gt; correlations;
 correlations = Arrays.stream(data).flatMap((String[] row) -&gt; {
 Set&lt;String&gt; words = new HashSet&lt;&gt;(Arrays.asList(row));
 return words.stream().map(word -&gt; new AbstractMap.SimpleEntry&lt;&gt;(word, words));
 }).collect(Collectors.toMap(kv -&gt; kv.getKey(),
 kv -&gt; kv.getValue().stream()
 .collect(Collectors.toMap(Function.identity(), v -&gt; 1L)),
 (map1, map2) -&gt; {
 map2.entrySet().forEach(kv -&gt; map1.merge(kv.getKey(), kv.getValue(), Long::sum));
 return map1;
 }));
 System.out.format(&quot;Lines with 04 = %d%n&quot;, 
 correlations.getOrDefault(&quot;04&quot;, Collections.EMPTY_MAP).getOrDefault(&quot;04&quot;, 0L));
 System.out.format(&quot;Lines with both 04 and 07 = %d%n&quot;, 
 correlations.getOrDefault(&quot;04&quot;, Collections.EMPTY_MAP).getOrDefault(&quot;07&quot;, 0L));
}
</code></pre>
EDIT:
Here is a (perhaps) easier to read version that doesn't use a Stream/functional approach:
<pre><code>public static void main(String[] args) throws IOException {
 long lineCount = 0;
 Map&lt;String,Long&gt; wordCount = new HashMap&lt;&gt;();
 Map&lt;String,Map&lt;String,Long&gt;&gt; correlations = new HashMap&lt;&gt;();
 try(Stream&lt;String&gt; stream = Files.lines(Paths.get(&quot;numbers.txt&quot;))) {
 Iterable&lt;String&gt; lines = stream::iterator;
 Set&lt;String&gt; lineWords = new HashSet&lt;&gt;();
 for(String line : lines) {
 lineCount++;
 for(String word : line.split(&quot;\\s+&quot;)) {
 lineWords.add(word);
 wordCount.merge(word, 1L, Long::sum);
 }
 for(String wordA : lineWords) {
 Map&lt;String,Long&gt; relate = correlations.computeIfAbsent(wordA,
 key -&gt; new HashMap&lt;&gt;());
 for(String wordB : lineWords) {
 relate.merge(wordB, 1L, Long::sum);
 }
 }
 }
 }
 System.out.format(&quot;Total lines = %d%n&quot;, lineCount);
 System.out.println(&quot;Count of 04 = &quot; + wordCount.getOrDefault(&quot;04&quot;, 0L));
 System.out.format(&quot;Lines with 04 = %d%n&quot;, 
 correlations.getOrDefault(&quot;04&quot;, Collections.EMPTY_MAP).getOrDefault(&quot;04&quot;, 0L));
 System.out.format(&quot;Lines with both 04 and 07 = %d%n&quot;, 
 correlations.getOrDefault(&quot;04&quot;, Collections.EMPTY_MAP).getOrDefault(&quot;07&quot;, 0L));
}
</code></pre>
Output:
<blockquote>
Total lines = 4
Count of 04 = 4
Lines with 04 = 4
Lines with both 04 and 07 = 3
</blockquote>

blocks|key|1250138|text|编辑:我误读到你已经把文件读入数组了。因此，您可以跳过处理子字符串数组中的每个条目。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1250139|假设您使用的是文本文件或类似的输入，您可以逐行读取文件，并在读取时计数每一行中的"04“号。您可以使用这样的缓冲读取器：|1250140|String+line;
while+((line+=+br.readLine())+!=+null)+{
++++//process+each+line
}|code-block|syntax|javascript|1250141|要计数所需字符串的出现次数，可以引用另一个答案：|1250142|字符串中出现的子字符串|offset|length|1250143|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/767759/occurrences-of-substring-in-a-string^0|0|0|0|0|0|B|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|10|8|@]|9|@$M|11|N|12|1|13]]|A|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

Edit: I misread that you've already read the file into an array. So you could just skip to processing each entry in the array for the substrings.

Assuming you are using a text file or similar for the input, you can read the file line-by-line and count the number of "04" in each line as you read it. You could use a buffered reader like this:

<pre><code>String line;
while ((line = br.readLine()) != null) {
 //process each line
}
</code></pre>

To count for the number of occurrences of your desired string, you can reference this other answer:

<a href="https://stackoverflow.com/questions/767759/occurrences-of-substring-in-a-string">Occurrences of substring in a string</a>

blocks|key|1250158|text|您在设计思想上“为时过早”；例如，在这里使用2D数组。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1250159|您知道，在开始考虑设计/实现选择之前，您确实需要更好地了解requirements。|offset|length|style|BOLD|1250160|示例:当您只关注时，关心的是测量某个数字出现的频率，总体上是，那么使用2D数组不会有任何好处。相反，您可以将所有的数字放入一个长List<Integer>中，然后对其使用一些花哨的java8流操作。|CODE|1250161|但是，如果这只是众多例子中的一个，那么管理内存中的数据的其他方法可能会更有效。|1250162|除此之外，如果您发现您将对这些数据所做的事情超出了简单的计算范围，那么Java可能不是这里的最佳选择。你看，像R这样的语言就是专门设计出来的:处理大量难以置信的数据；并让您“即时”访问范围广泛的各种统计操作。|1250163|要回答有关计数所有不同数字的出现情况的想法，这非常简单:这里使用Map<Integer,+Integer>；如：|1250164|Map<Integer,+Integer>+numbersWithCount+=+new+HashMap<>();

now+you+loop+over+your+data;+and+for+each+data+point:

int+currentNumber+=+...+next+number+from+your+input+data

int+counterForNum;
if+(numbersWithCount.containsKey(currentNumber))+{
++counterForNum+=+numbersWithCount.get(currentNumber)+%2B+1;
}+else+{
+++//+currentNumber+found+the+first+time
++counterForCurrentNumber+=+1;
}
numbersWithCount.put(currentNumber);|code-block|syntax|javascript|1250165|换句话说:您只需遍历所有传入的数字，对于其中的每一个，您要么创建一个新的计数器，要么增加一个已经存储的计数器。|1250166|如果您使用的是TreeMap而不是HashMap，那么您甚至可以对密钥进行排序。有很多可能性..。|1250167|entityMap^0|0|T|C|0|8|2|1S|D|0|0|1J|1|2K|C|0|0|1K|W|L|0|0|0|1J|0|0|1D|7|7|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|12|8|@$D|13|E|14|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|15|8|@$D|16|E|17|F|G]|$D|18|E|19|F|J]]|9|@]|A|$]]|$1|K|3|L|5|6|7|1A|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1B|8|@$D|1C|E|1D|F|G]|$D|1E|E|1F|F|G]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1G|8|@$D|1H|E|1I|F|G]|$D|1J|E|1K|F|J]]|9|@]|A|$]]|$1|Q|3|R|5|S|7|1L|8|@]|9|@]|A|$T|U]]|$1|V|3|W|5|6|7|1M|8|@$D|1N|E|1O|F|G]]|9|@]|A|$]]|$1|X|3|Y|5|6|7|1P|8|@$D|1Q|E|1R|F|G]|$D|1S|E|1T|F|J]]|9|@]|A|$]]|$1|Z|3|-4|5|6|7|1U|8|@]|9|@]|A|$]]]|10|$]]

You are "premature" in your design ideas; for example about using a 2D array here.

You see, you really have to get a better understanding of your requirements before you start thinking about design/implementation choices. 

Example: when you only care about measuring how often some number shows up overall then using a 2D array won't do any good. Instead, you could just put all numbers into one long <code>List&lt;Integer&gt;</code>; to then use some of the fancy java8 stream operations on that for example. 

But if that was just one example out of many, then other ways to manage your data in memory might be more efficient. 

Beyond that: if you find that the things you will be doing with this data goes beyond simple calculations - Java might probably not be the best choice here. You see, languages like R are specially designed to do just that: crunch incredible amounts of data; and giving you "instant" access to a wide range of statistical operations of all kind.

And to answer your idea about counting the occurrences of all the different numbers; that is really simple: you use a <code>Map&lt;Integer, Integer&gt;</code> here; like in:

<pre><code>Map&lt;Integer, Integer&gt; numbersWithCount = new HashMap&lt;&gt;();

now you loop over your data; and for each data point:

int currentNumber = ... next number from your input data

int counterForNum;
if (numbersWithCount.containsKey(currentNumber)) {
 counterForNum = numbersWithCount.get(currentNumber) + 1;
} else {
 // currentNumber found the first time
 counterForCurrentNumber = 1;
}
numbersWithCount.put(currentNumber);
</code></pre>

In other words: you just iterate over all incoming numbers, and for each of those, you either create a new counter; or increase one that was already stored. 

And if you use a <code>TreeMap</code> instead of a HashMap, you even get your keys sorted. Many possibilities there ...

the project I am currently working on has me reading a file and then doing analysis upon the data inside the data. Using FileReader I have read each line of the file into an Array. The file looks like the following:

<blockquote>
 01 02 03 04 05 06 
 02 03 04 05 06 07 
 03 04 05 06 07 08 
 04 05 06 07 08 09 
</blockquote>

These are not the exact numbers but they make a good example. I am now trying to find out how many times say the number "04" appears in my list of data. I was thinking of putting all the data in a two dimensional array by breaking each line apart but I am not quite sure how to do this. Will I need a parser or is it possible to use some type of string function (like split) to split this data apart and then store it into the Array?

Reading a File's Content and then doing analysis upon them

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我目前正在进行的项目让我读取一个文件，然后对数据中的数据进行分析。使用FileReader，我已经将文件的每一行读取到一个数组中。该文件如下所示：01 02 03 04 05 0602 03 04 05 06 0703 04 05 06 07 0804 05 06 07 08 09这些不是确切的数字，但它们是一个很好的...

问阅读文件内容，然后对其进行分析
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问阅读文件内容，然后对其进行分析EN