用Java random函数随机产生十个00000间整数,统计这些数中出现数字的频度。-学网-中国IT综合门户网站-提供健康,养生,留学,移民,创业,汽车等信息
> 信息中心 >
用Java random函数随机产生十个00000间整数,统计这些数中出现数字的频度。
来源：互联网 发表时间： 20:45:02 责任编辑：鲁晓倩字体：
为了帮助网友解决“用Java random函数随机产生十个00000间整数,统计这些数中出现数字的频度。”相关的问题，学网通过互联网对“用Java random函数随机产生十个00000间整数,统计这些数中出现数字的频度。”相关的解决方案进行了整理,用户详细问题包括:
未出现的不统计，输出统计结果。
，具体解决方案如下：解决方案1：
&; &nbsp,Integer& & }else{&I &I & & & &nbsp.put( & & & Integer value =& &;&+ &nbsp.util.out!= null){& & & System,Integer&gt.getKey() +& && & & & &nbsp. &nbsp.hasNext()){&& & Iterator ite =&& 10 ; & & & &nbsp.get(result).HashM hm = new HashMap& & & &nbsp.util,Integer&& }& & }& str = str + i++){& &().next(); }& & & & map = (MI &nbsp:&I & & &nbsp.entrySet(); HashMap& &nbsp.R }& & int result = &nbsp解决方案2：
//已通过本人测试....import&java.util.HashMimport&java.util.M//用Java&random函数随机产生十个00000间整数,统计这些数中出现数字的频度。public&class&Random&{&&&&public&static&void&main(String[]&args)&{//&&&&&&&&List&Integer&&list&=&new&ArrayList&Integer&();&&&&&&&&String&str&=&new&String();&&&&&&&&for&(int&i&=&0;&i&&&10;&i++)&{&&&&&&&&int&a&=&(int)&(Math.random()&*&10);&&&&&&&&int&b&=&(int)&(Math.random()&*&10);&&&&&&&&int&c&=&(int)&(Math.random()&*&10);&&&&&&&&int&d&=&(int)&(Math.random()&*&10);&&&&&&&&int&e&=&(int)&(Math.random()&*&10);&&&&&&&&int&f&=&(int)&(Math.random()&*&10);&&&&&&&&if(a&0){&&&&&&&&&&&&int&g&=&a*100000&+&b*10000+c*1000+d*100+e*10+f;&&&&&&&&&&&&System.out.println(&第&+(i+1)+&个随机数&&+g);&&&&&&&&&&&&str=str+g;&&&&&&&&}else{&&&&&&&&&&&&i--;&&&&&&&&}&&&&&&&&}&&&&&&&&int&strLength&=&str.length();&&&&&&&&Map&Integer,Integer&&map&=&new&HashMap&Integer,Integer&();&&&&&&&&for(int&i=0;i&10;i++){&&&&&&&&&&&&String&newLength&=&str.replaceAll(i+&&,&&);&&&&&&&&&&&&int&numLength&=&strLength-newLength.length();&&&&&&&&&&&&map.put(i,numLength);&&&&&&&&}&&&&&&&&for&(int&j=0;&j&10;j++)&{&&&&&&&&&&&&Integer&z&=&map.get(j);&&&&&&&&&&&&System.out.println(j+&出现&+z+&次&);&&&&&&&&}&&&&&&&&}}解决方案3：
);&rn=new&&&i&count++;&a[]=new&&&&&int&&for(int&&10;}&}else{&&j&&&&&&count=1;}&i&&j=i+1;&&nbsp.nextFloat();&-------&&S&&&&&S&}&&&&&&for(int&&nbspint&&r=count=1;float&&i++){&int[10];a[i]=100000+(int)(r*900000);&if(a[i]==a[j]){&&10.i++){&&&j++){&i=0;&&nbsp.&&&&&+count);Random&for(int&i=0;&&10;&&nbsp.println(a[i]+&Random().print(a[i]+&quot
1个回答1个回答1个回答1个回答1个回答1个回答1个回答1个回答1个回答1个回答
相关文章：
最新添加资讯
24小时热门资讯
Copyright © 2004- All Rights Reserved. 学网 版权所有
京ICP备号-1 京公网安备02号Java（60）
一、把数组转成ArrayList
为了将数组转换为ArrayList，开发者经常会这样做：
List&String& list = Arrays.asList(arr);
使用Arrays.asList()方法可以得到一个ArrayList，但是得到这个ArrayList其实是定义在Arrays类中的一个私有的静态内部类。这个类虽然和java.util.ArrayList同名，但是并不是同一个类。java.util.Arrays.ArrayList类中实现了set(),&get(),&contains()等方法，但是并没有定义向其中增加元素的方法。也就是说通过Arrays.asList()得到的ArrayList的大小是固定的。
如果在开发过程中，想得到一个真正的ArrayList对象（java.util.ArrayList的实例），可以通过以下方式：
ArrayList&String& arrayList = new ArrayList&String&(Arrays.asList(arr));
java.util.ArrayList中包含一个可以接受集合类型参数的构造函数。因为java.util.Arrays.ArrayList这个内部类继承了AbstractList类，所以，该类也是Collection的子类。
二、判断一个数组是否包含某个值
在判断一个数组中是否包含某个值的时候，开发者经常这样做：
Set&String& set = new HashSet&String&(Arrays.asList(arr));
return set.contains(targetValue);
在一文中，深入分析过，以上方式虽然可以实现功能，但是效率却比较低。因为将数组压入Collection类型中，首先要将数组元素遍历一遍，然后再使用集合类做其他操作。
在判断一个数组是否包含某个值的时候，推荐使用for循环遍历的形式或者使用Apache Commons类库中提供的ArrayUtils类的contains方法。
三、在循环中删除列表中的元素
在讨论这个问题之前，先考虑以下代码的输出结果：
ArrayList&String& list = new ArrayList&String&(Arrays.asList(&a&,&b&,&c&,&d&));
for(int i=0;i&list.size();i++){
list.remove(i);
System.out.println(list);
输出结果：
以上代码的目的是想遍历删除list中所有元素，但是结果却没有成功。原因是忽略了一个关键的问题：当一个元素被删除时，列表的大小缩小并且下标也会随之变化，所以当你想要在一个循环中用下标删除多个元素的时候，它并不会正常的生效。
也有些人知道以上代码的问题就由于数组下标变换引起的。所以，他们想到使用增强for循环的形式：
ArrayList&String& list = new ArrayList&String&(Arrays.asList(&a&,&b&,&c&,&d&));
for(String s:list){
if(s.equals(&a&)){
list.remove(s);
但是，很不幸的是，以上代码会抛出ConcurrentModificationException，有趣的是，如果在remove操作后增加一个break，代码就不会报错：
ArrayList&String& list = new ArrayList&String&(Arrays.asList(&a&,&b&,&c&,&d&));
for(String s:list){
if(s.equals(&a&)){
list.remove(s);
在一文中，深入分析了几种在遍历数组的同时删除其中元素的方法以及各种方法存在的问题。其中就介绍了上面的代码出错的原因。
迭代器（Iterator）是工作在一个独立的线程中，并且拥有一个 mutex 锁。 迭代器被创建之后会建立一个指向原来对象的单链索引表，当原来的对象数量发生变化时，这个索引表的内容不会同步改变，所以当索引指针往后移动的时候就找不到要迭代的对象，所以按照 fail-fast 原则 迭代器会马上抛出java.util.ConcurrentModificationException&异常。
所以，正确的在遍历过程中删除元素的方法应该是使用Iterator：
ArrayList&String& list = new ArrayList&String&(Arrays.asList(&a&, &b&, &c&, &d&));
Iterator&String& iter = list.iterator();
while (iter.hasNext()) {
String s = iter.next();
if (s.equals(&a&)) {
iter.remove();
next()方法必须在调用remove()方法之前调用。如果在循环过程中先调用remove()，再调用next()，就会导致异常ConcurrentModificationException。原因如上。
四、HashTable 和 HashMap 的选择
了解算法的人可能对HashTable比较熟悉，因为他是一个数据结构的名字。但在Java里边，用HashMap来表示这样的数据结构。Hashtable和 HashMap的一个关键性的不同是，HashTable是同步的，而HashMap不是。所以通常不需要HashTable，HashMap用的更多。
、等文章中介绍了他们的区别和如何选择。
五、使用原始集合类型
在Java里边，原始类型和无界通配符类型很容易混合在一起。以Set为例，Set是一个原始类型，而Set& ? &是一个无界通配符类型。 （可以把原始类型理解为没有使用泛型约束的类型）
考虑下面使用原始类型List作为参数的代码：
public static void add(List list, Object o){
list.add(o);
public static void main(String[] args){
List&String& list = new ArrayList&String&();
add(list, 10);
String s = list.get(0);
上面的代码将会抛出异常：
java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
使用原始集合类型是很危险的，因为原始集合类型跳过了泛型类型检查，是不安全的。Set、Set& ? &和Set& Object &之间有很大差别。关于泛型，可以参考下列文章：
六、访问级别
程序员们经常使用public作为类中的字段的修饰符，因为这样可以很简单的通过引用得到值，但这并不是好的设计，按照经验，分配给成员变量的访问级别应该尽可能的低。参考
七、ArrayList与LinkedList的选择
当程序员们不知道ArrayList与LinkedList的区别时，他们经常使用ArrayList，因为它看起来比较熟悉。然而，它们之前有巨大的性能差别。在、等文章中介绍过，简而言之，如果有大量的增加删除操作并且没有很多的随机访问元素的操作，应该首先LinkedList。（LinkedList更适合从中间插入或者删除（链表的特性））
八、可变与不可变
在一文中介绍过，不可变对象有许多的优点，比如简单，安全等等。同时，也有人提出疑问：既然不可变有这么多好处，为什么不把所有类都搞成不可变的呢？
通常情况下，可变对象可以用来避免产生过多的中间对象。一个经典的实例就是连接大量的字符串，如果使用不可变的字符串，将会产生大量的需要进行垃圾回收的对象。这会浪费CPU大量的时间，使用可变对象才是正确的方案(比如StringBuilder)。
String result=&&;
for(String s: arr){
result = result + s;
中也有关于这个的讨论。
九、父类和子类的构造函数
上图的代码中有两处编译时错误，原因其实很简单，主要和构造函数有关。首先，我们都知道：
如果一个类没有定义构造函数，编译器将会插入一个无参数的默认构造函数。
如果一个类中定义了一个带参数的构造函数，那么编译器就不会再帮我们创建无参的构造函数。
上面的Super类中定义了一个带参数的构造函数。编译器将不会插入默认的无参数构造函数。
我们还应该知道：
子类的所有构造函数（无论是有参还是无参）在执行时，都会调用父类的无参构造函数。
所以，编译器试图调用Super类中的无参构造函数。但是父类默认的构造函数未定义，编译器就会报出这个错误信息。
要解决这个问题，可以简单的通过
1)在父类中添加一个Super()构造方法，就像这样：
public Super(){}
2)移除自定义的父类构造函数
3)在子类的构造函数中调用父类的super(value)。
十、””还是构造函数
关于这个问题，也是程序员经常出现困惑的地方，在中也介绍过.
如果你只需要创建一个字符串，你可以使用双引号的方式，如果你需要在堆中创建一个新的对象，你可以选择构造函数的方式。
在String d = new String(&abcd&)时，因为字面值“abcd”已经是字符串类型，那么使用构造函数方式只会创建一个额外没有用处的对象。
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：522269次
积分：6087
积分：6087
排名：第3257名
原创：122篇
转载：189篇
评论：43条
(1)(1)(3)(4)(2)(9)(3)(17)(1)(4)(3)(4)(5)(6)(7)(9)(1)(13)(4)(13)(4)(2)(4)(2)(18)(16)(8)(4)(5)(6)(6)(11)(17)(8)(1)(4)(1)(5)(14)(10)(6)(4)(5)(7)(17)(4)(1)(8)(2)(4)Java程序员在写SQL时候常犯的10个错误
　作者: oschina译者　编辑:
　　4.通过JDBC分页技术给大量的结果进行分页操作　　大部分的数据库都会支持一些分页命令实现分页效果，譬如LIMIT..OFFSET,TOP..START AT,OFFSET..FETCH语句等。即使没有支持这些语句的数据库，仍有可能对ROWNUM(甲骨文)或者是ROW NUMBER() OVER()过滤(DB2,SQL Server2008等)，这些比在内存中实现分页更快速。在处理大量数据中，效果尤其明显。　　纠正：　　仅仅使用这些语句，那么一个工具(例如JOOQ)就可以模拟这些语句的操作。　　5.在java内存中加入数据　　从SQL的初期开始，当在SQL中使用JOIN语句时，一些开发者仍旧有不安的感觉。这是源自对加入JOIN后会变慢的固有恐惧。假如基于成本的优化选择去实现嵌套循环，在创建一张连接表源前，可能加载所有的表在数据库内存中，这可能是真的。但是这事发生的概率太低了。通过合适的预测，约束和索引，合并连接和哈希连接的操作都是相当的快。这完全是是关于正确元数据(在这里我不能够引用Tom Kyte的太多)。而且，可能仍然有不少的Java开发人员加载两张表通过分开查询到一个映射中，并且在某种程度上把他们加到了内存当中。　　纠正：　　假如你在各个步骤中有从各种表的查询操作，好好想想是否可以表达你的查询操作在单条语句中。　　6.在一个临时的笛卡尔积集合中使用 DISTINCT 或 UNION 消除重复项　　通过复杂的连接，人们可能会对SQL语句中扮演关键角色的所有关系失去概念。特别的，如果这涉及到多列外键关系的话，很有可能会忘记在JOIN .. ON子句中增加相关的判断。这会导致重复的记录，但或许只是在特殊的情况下。有些开发者因此可能选择DISTINCT来消除这些重复记录。从三个方面来说这是错误的：　　& 它(也许)解决了表面症状但并没有解决问题。它也有可能无法解决极端情况下的症状。　　& 对具有很多列的庞大的结果集合来说它很慢。DISTINCT要执行ORDER BY操作来消除重复。　　& 对庞大的笛卡尔积集合来说它很慢，还是需要加载很多的数据到内存中。　　解决方法:　　根据经验，如果你获得了不需要的重复记录，还是检查你的JOIN判断吧。可能在某个地方有一个很难觉察的笛卡尔积集合。　　7. 不使用MERGE语句　　这并不是一个过失，但是可能是缺少知识或者对于强悍的MERGE语句信心不足。一些数据库理解其它形式的更新插入(UPSERT)语句， 如 MYSQL的重复主键更新语句，但是MERGE在数据库中确是很强大，很重要，以至于大肆扩展SQL标准，例如SQL SERVER。　　解决之道:　　如果你使用像联合INSERT和UPDATE或者联合SELECT .. FOR UPDATE然后在INSERT或UPDATE等更新插入时，请三思。你完全可以使用一个更简单的MERGE语句来远离冒险竞争条件。　　8. 使用聚合函数代替窗口函数(window functions)　　在介绍窗口函数之前，在SQL中聚合数据意味着使用GROUP BY语句与聚合函数相映射。在很多情形下都工作得很好，如聚合数据需要浓缩常规数据，那么就在join子查询中使用group查询。
第1页：第2页：
大学生分期购物销量榜
IT168企业级[Java]实现按中文首字母排序
要实现&按中文首字母排序&操作，可以使用java.util包下的Arrays类的sort()函数。
Arrays类包含用来操作数组（比如排序和搜索）的各种方法。
比如对于排序操作的sort()函数，重载了多种静态函数以适应不同情况下的需要。
以下，我们应用最后一个重载函数来实现&按中文首字母排序&：
sort(T[] a, int fromIndex, int toIndex, Comparator c)
根据指定比较器产生的顺序对指定对象数组的指定范围进行排序。
代码举例：
package com.app.
import java.text.C
import java.util.A
* java实现按中文首字母排序的方式
public class TestDemo01 {
public static void main(String[] args) {
// Collator 类是用来执行区分语言环境的 String 比较的，这里选择使用CHINA
Comparator comparator = Collator.getInstance(java.util.Locale.CHINA);
String[] arrStrings = { &乔峰&, &郭靖&, &杨过&, &张无忌&,&韦小宝& };
// 使根据指定比较器产生的顺序对指定对象数组进行排序。
Arrays.sort(arrStrings, comparator);
for (int i = 0; i & arrStrings. i++)
System.out.println(arrStrings[i]);
执行结果：
至此，我们即完成了&按中文首字母排序&操作。
(window.slotbydup=window.slotbydup || []).push({
id: '2467140',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467141',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467142',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467143',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467148',
container: s,
size: '1000,90',
display: 'inlay-fix'}