blocks|key|3788635|text|a.您可以使用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3788636|switch+(zip)
{
case+93726:+case+93725:+case+92144:+return+100;
case+94550:+case+34599:+case+77375:+return+150;
}|code-block|syntax|javascript|3788637|-|3788638|或者创建一个HashMap<Integer,Integer>，并用“zip+to+value”条目填充它，如果你有那么多的案例，这应该会给你带来更好的性能。|offset|length|style|CODE|3788639|Map<Integer,Integer>+m+=+new+HashMap<>();
m.put(93726,100);|3788640|稍后，您可以调用|3788641|return+m.get(zip);|3788642|3788643|c.如果你的zip数是数万，你想在内存中工作，那么你应该考虑只保存10万个整数大小的数组：|3788644|int[]+arr=new+int[100000];|3788645|并用数据填充它：|3788646|arr[93726]=100;
.
.
.|3788647|entityMap^0|0|0|0|6|O|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|15|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|16|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|17|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|18|8|@$K|19|L|1A|M|N]]|9|@]|A|$]]|$1|O|3|P|5|D|7|1B|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|1C|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1D|8|@]|9|@]|A|$E|F]]|$1|U|3|H|5|6|7|1E|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|1F|8|@]|9|@]|A|$]]|$1|X|3|Y|5|D|7|1G|8|@]|9|@]|A|$E|F]]|$1|Z|3|10|5|6|7|1H|8|@]|9|@]|A|$]]|$1|11|3|12|5|D|7|1I|8|@]|9|@]|A|$E|F]]|$1|13|3|-4|5|6|7|1J|8|@]|9|@]|A|$]]]|14|$]]

a. You can either use a

<pre><code>switch (zip)
{
case 93726: case 93725: case 92144: return 100;
case 94550: case 34599: case 77375: return 150;
}
</code></pre>

-

b. or create a <code>HashMap&lt;Integer,Integer&gt;</code> and fill it with 'zip to value' entries, which should give you a much better performance if you have that many cases.

<pre><code>Map&lt;Integer,Integer&gt; m = new HashMap&lt;&gt;();
m.put(93726,100);
</code></pre>

later you could call

<pre><code>return m.get(zip);
</code></pre>

-

c. If your zip count is in the tens of thousands and you want to work all in memory, then you should consider just holding a hundred-thousand int sized array:

<pre><code>int[] arr=new int[100000];
</code></pre>

and filling it with the data:

<pre><code>arr[93726]=100;
.
.
.
</code></pre>

blocks|key|1332531|text|使用声明性数据。尤其是邮政编码可能会被更新、扩展、更正：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1332532|例如，使用zip.properties|1332533|points+=+100,+150

zip100+=+93726,+93725,+92144
zip150+=+94550,+34599,+77375,\
+++++++++88123,+12324,+23424|code-block|syntax|javascript|1332534|和|1332535|Map<Integer,+Integer>+zipToPoints+=+new+HashMap<>();|1332536|如果你得到的邮政编码带有前导零，也许最好使用字符串，或者小心地用基数10来解析它们(前导零是基数8，八进制)。|1332537|我不知道是否真的存在这样的限制，但一点编码的额外努力值得拥有所有的数据。|1332538|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Use declarative data. Especially as the zip codes might get updated, extended, corrected:

Using for instance a zip.properties

<pre><code>points = 100, 150

zip100 = 93726, 93725, 92144
zip150 = 94550, 34599, 77375,\
 88123, 12324, 23424
</code></pre>

And

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

If you got ZIP codes with leading zeroes maybe better use String or take care to parse them with base 10 (leading zero is base 8, octal).

Whether there really exists such a limitation I do not know, but the extra effort of a bit of coding is worth having all as data.

blocks|key|1332553|text|您可以创建一个Map，将每个邮政编码映射到一个整数。例如：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1332554|Map<Integer,+Integer>+zipCodeMap+=+new+HashMap<>();
zipCodeMap.put(93726,+100);|code-block|syntax|javascript|1332555|稍后，您可以从那里检索值。|1332556|Integer+value+=+zipCodeMap.get(93726);|1332557|现在，您仍然需要将每个邮政编码映射到一个值。我不会用Java代码这样做，而是使用数据库或从文本文件(例如csv)中读取。这主要取决于您的需求。|1332558|1332559|示例csv文件：|1332560|93726,+100
93727,+100
93726,+150|1332561|从csv文件读取：|1332562|InputStream+is+=+this.class.getResourceAsStream("/data.csv");
BufferedReader+reader+=+new+BufferedReader(new+InputStreamReader(is));
try+{
++++String+line;
++++while+((line+=+reader.readLine())+!=+null)+{
++++++++String[]+row+=+line.split(",");
++++++++int+zip+=+Integer.parseInt(row[0].trim());
++++++++int+value+=+Integer.parseInt(row[1].trim());
++++++++zipCodeMap.put(zip,+value);
++++}
}
catch+(IOException+ex)+{
++++//+handle+exceptions+here
}
finally+{
++++try+{
++++++++is.close();
++++}
++++catch+(IOException+e)+{
++++++++//+handle+exceptions+here
++++}
}|1332563|entityMap^0|7|3|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|14|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|15|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|16|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|17|8|@]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|18|8|@]|D|@]|E|$]]|$1|R|3|S|5|6|7|19|8|@]|D|@]|E|$]]|$1|T|3|U|5|H|7|1A|8|@]|D|@]|E|$I|J]]|$1|V|3|W|5|6|7|1B|8|@]|D|@]|E|$]]|$1|X|3|Y|5|H|7|1C|8|@]|D|@]|E|$I|J]]|$1|Z|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]]|10|$]]

You could create a <code>Map</code> which maps each zip code to an integer. For example:

<pre><code>Map&lt;Integer, Integer&gt; zipCodeMap = new HashMap&lt;&gt;();
zipCodeMap.put(93726, 100);
</code></pre>

And later you can retrieve values from there.

<pre><code>Integer value = zipCodeMap.get(93726);
</code></pre>

Now you still have to map each zipcode to a value. I would not do that in Java code but rather use a database or read from a text file (csv for example). This depends mostly on your requirements.

<hr>

Example csv file:

<pre><code>93726, 100
93727, 100
93726, 150
</code></pre>

Reading from a csv file:

<pre><code>InputStream is = this.class.getResourceAsStream("/data.csv");
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
try {
 String line;
 while ((line = reader.readLine()) != null) {
 String[] row = line.split(",");
 int zip = Integer.parseInt(row[0].trim());
 int value = Integer.parseInt(row[1].trim());
 zipCodeMap.put(zip, value);
 }
}
catch (IOException ex) {
 // handle exceptions here
}
finally {
 try {
 is.close();
 }
 catch (IOException e) {
 // handle exceptions here
 }
}
</code></pre>

blocks|key|1338677|text|有一个zip的地图，codes.just返回值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1338678|Map<Integer,Integer>+zipValues+=+new+HashMap<Integer,Integer>();
zipValues.put(93726,100);|code-block|syntax|javascript|1338679|。|1338680|1338681|诸若此类。或者，您可以从属性文件中读取并填充地图。|1338682|则代替使用if，|1338683|+return+zipValues.get(zipCode);|1338684|假设zipCode=93726，它将返回u+100。|1338685|干杯。|1338686|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|W|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|X|8|@]|9|@]|A|$]]|$1|I|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|Z|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|10|8|@]|9|@]|A|$]]|$1|N|3|O|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|P|3|Q|5|6|7|12|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|13|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|U|$]]

Have a map of the zip codes.just return the value. 
 

<pre><code>Map&lt;Integer,Integer&gt; zipValues = new HashMap&lt;Integer,Integer&gt;();
zipValues.put(93726,100);
</code></pre>

. 
. 
And so on. or u can read from a prop file and populate the map. 
 
then instead of using the if(s), 

<pre><code> return zipValues.get(zipCode);
</code></pre>

so say zipCode=93726, it will return u 100. 
 
Cheers.

blocks|key|5256805|text|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5256806|由于|ordered-list-item|5256807|，您可能应该对您的邮政编码使用字符串常量|5256808|-+in+some+places,+some+start+with+0
-+in+some+places,+they+may+contain+letters+as+well+as+numbers|code-block|syntax|javascript|5256809|​|5256810|5256811|如果您使用Object+(+String或Integer)作为常量，我经常使用Collection.contains(zip)作为每个if语句中条件的惰性快捷方式。该集合包含该条件的所有常量，您可能会使用一个专门用于查找的子类，可能是HashSet。请记住，如果您按照其他地方的建议使用HashMap解决方案，您的键也将是Integer对象，因此您将在任何情况下对键进行散列，只需要将结果值存储在收集建议中即可。|offset|length|style|CODE|5256812|5256813|我怀疑对于一个大型常量集合，散列可能会比在if语句中遍历大量==条件直到找到正确的条件要快得多。(如果最常用的常量出现在前面，并且在第一个if常量中出现，这可能会有所帮助|5256814|在一个完全不同的注释中(即策略而不是代码)，您应该看看是否可以对您的ZIPs进行分组。我的意思是，例如，如果您知道"923xx“和"924xx”形式的所有(或大多数)压缩都会导致250的返回，那么您可能会大大缩短条件语句的使用时间。例如，用于String+ZIPs的zip.startsWith("923")+%7C%7C+zip.startsWith("923")或用于int的(zip+/+100)+==+923+%7C%7C+(zip+/+100)+==+924。|5256815|组的少量更具体的异常仍然可以处理，您只需要在更一般的条件之前拥有更具体的条件。|5256816|entityMap^0|0|0|0|0|0|0|5|6|E|6|L|7|13|O|39|7|3Z|7|4H|7|0|0|L|2|U|2|1X|2|0|3D|6|3P|1A|52|3|56|14|0|0^^$0|@$1|2|3|-4|4|5|6|12|7|@]|8|@]|9|$]]|$1|A|3|B|4|C|6|13|7|@]|8|@]|9|$]]|$1|D|3|E|4|5|6|14|7|@]|8|@]|9|$]]|$1|F|3|G|4|H|6|15|7|@]|8|@]|9|$I|J]]|$1|K|3|L|4|5|6|16|7|@]|8|@]|9|$]]|$1|M|3|-4|4|5|6|17|7|@]|8|@]|9|$]]|$1|N|3|O|4|C|6|18|7|@$P|19|Q|1A|R|S]|$P|1B|Q|1C|R|S]|$P|1D|Q|1E|R|S]|$P|1F|Q|1G|R|S]|$P|1H|Q|1I|R|S]|$P|1J|Q|1K|R|S]|$P|1L|Q|1M|R|S]]|8|@]|9|$]]|$1|T|3|-4|4|5|6|1N|7|@]|8|@]|9|$]]|$1|U|3|V|4|5|6|1O|7|@$P|1P|Q|1Q|R|S]|$P|1R|Q|1S|R|S]|$P|1T|Q|1U|R|S]]|8|@]|9|$]]|$1|W|3|X|4|5|6|1V|7|@$P|1W|Q|1X|R|S]|$P|1Y|Q|1Z|R|S]|$P|20|Q|21|R|S]|$P|22|Q|23|R|S]]|8|@]|9|$]]|$1|Y|3|Z|4|5|6|24|7|@]|8|@]|9|$]]|$1|10|3|-4|4|5|6|25|7|@]|8|@]|9|$]]]|11|$]]

<ol>
<li>You should probably use String constants for you ZIP codes since

<ul>
<li>in some places, some start with 0</li>
<li>in some places, they may contain letters as well as numbers</li>
</ul></li>
<li>If you are using an <code>Object</code> (either <code>String</code> or <code>Integer</code>) for your constants, I have often used <code>Collection.contains(zip)</code> as a lazy shortcut for the condition in each if statement. That collection contains all the constants for that condition, and you would probably use a subclass that is geared towards finding, perhaps <code>HashSet</code>. Keep in mind that if you use a <code>HashMap</code> solution as suggested elsewhere, your keys will be <code>Integer</code> objects too, so you will do hashing on the keys in any case, you just won't need to store the result values in the collection suggestion.

I suspect that for a large collection of constants, hashing may turn out to be faster than having to work through the large number of <code>==</code> conditions in the <code>if</code> statement until you get to the right condition. (It may help a bit if the most-used constants come first, and in the first <code>if</code> statement...)</li>
</ol>

On a completely different note (i.e. strategy instead of code), you should see if you could group your ZIPs. What I mean is for example, that if you know that all (or most) ZIPs of the forms "923xx" and "924xx" result in a return of 250, you could potentially shorten your conditionals considerably. E.g. <code>zip.startsWith("923") || zip.startsWith("923")</code> for <code>String</code> ZIPs, or <code>(zip / 100) == 923 || (zip / 100) == 924</code> for <code>int</code>.

A small number of more specific exceptions to the groups can still be handled, you just need to have the more specific conditionals before the more general conditionals.

What I am trying to do is assign a number value to a group of zip codes and then use that number to do a calculation later on in the program. What I have now is

<pre><code>if (zip == 93726 || zip == 93725 || zip == 92144) {
 return 100;
 }

else if (zip == 94550 || zip == 34599 || zip == 77375) {
 return 150;
 }
</code></pre>

and then I take the variable and use it in a calculation. Assigning the number to the variable and the calculation all work but what I have ran into is apparently android only allows you to have so many lines of code and I have ran out of lines with just using if else statements. My question is what would be a better what to go about this?

I am not trying to assign a city to each zip because I have seen that they have services that do that from other posters.

Assigning values to zip codes

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我尝试做的是将一个数值赋给一组邮政编码，然后在稍后的程序中使用该数值进行计算。我现在所拥有的是if (zip == 93726 || zip == 93725 || zip == 92144) {    return 100;  }else if (zip == 94550 || zip == 34599 || zip...

问为邮政编码赋值
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为邮政编码赋值EN