A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 神之梦   /  2013-7-7 15:02  /  9792 人查看  /  182 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

开始挑战
回复 使用道具 举报
杨晓燕 发表于 2013-7-7 20:49
oooo,有道理,收了,哈哈

:lol你苗,你太好了,怎么发现的
回复 使用道具 举报
要积分,来答题,要回复。
回复 使用道具 举报
本帖最后由 张歆明 于 2013-7-8 14:50 编辑

版主  第二题我已经重新做了   第一题和第三题没问题吧  
第二题的代码:
  1. package test2;

  2. import java.util.ArrayList;
  3. import java.util.Arrays;
  4. import java.util.HashSet;
  5. import java.util.List;
  6. import java.util.Random;
  7. import java.util.Set;

  8. /*
  9. 2、求出1-100之间的素数,假设有n个,将这些素数存入a[n+1]的数组中。
  10. (其中n个是求出的各个素数,还有一个是随机添加其中的一个素数)
  11.       这样数组中就有相同的两个素数,写一个搜索算法,找出数组中相同的那个素数。
  12.      (随机添加的素数,可手动指定,也可利用随机方法产生)
  13. */

  14. /*
  15. * 思路:
  16. * (1). 循环判断1-100之间哪些数是素数
  17. * (2). 将产生的素数存入一个数组,这时候随机产生一个素数并随机产生一个索引位置   通过插入的方式 将这个
  18. *                 素数存入相应的随机的位置
  19. * (3).        上面的数组除最后一个要查找的元素以外,前面所有的元素顺从大到小排过顺序的。采用折半查找即可
  20. * */
  21. public class Test2 {
  22.         public static void main(String[] args) {
  23.                 int upBound =100;
  24.                 //1.获取1-100的所有的质数
  25.                 List<Integer> primes =getPrimes(upBound);
  26.                 System.out.println("1-100以内的素数是:"+ primes);
  27.                
  28.                 //2.将产生的素数存入一个数组,这时候随机产生一个素数
  29.                         //并随机产生一个索引位置   通过插入的方式 将这个
  30.                         //素数存入相应的随机的位置
  31.                 int[] primesArr =toArray(primes);
  32.                 System.out.println("产生的数组是: "+ Arrays.toString(primesArr));
  33.                
  34.                 //3.由于随机生成的数字插入的位置未知,现在要找出这个数,可以利用Set集合的属性  将数组中的元素逐次添加到
  35.                         //Set集合中  一旦添加失败  说明这个元素是重复的 这样就找出了重复加入的那个素数
  36.                 int repeatedPrime =detectRepeatedPrime(primesArr);
  37.                
  38.                 System.out.println("重复的数字是:"+ repeatedPrime);
  39.         }
  40.        
  41.         //检测重复加入的数字
  42.         private static int detectRepeatedPrime(int[] primesArr) {
  43.                 Set<Integer> assistSet =new HashSet<Integer>();
  44.                 int repeatedNum =0;
  45.                 for(int element: primesArr){
  46.                         boolean flag =assistSet.add(element);
  47.                         if(flag)
  48.                                 System.out.println(element+"添加成功...");
  49.                         else{
  50.                                 System.out.println("**"+ element+"重复...");
  51.                                 //找到重复的元素就达到了目的   立刻结束添加操作
  52.                                 repeatedNum =element;
  53.                                 break;
  54.                         }
  55.                 }
  56.                 return repeatedNum;
  57.         }

  58.         //将产生的素数列表存入数组  并随机重复产生一个素数存入一个随机的位置
  59.         private static int[] toArray(List<Integer> primes) {
  60.                 int[] primeArr =new int[primes.size() +1]; //题目要求多一个元素
  61.                
  62.                 for(int x=0; x <primes.size(); x++){
  63.                         primeArr[x] =primes.get(x);
  64.                 }
  65.                
  66.                 //随机产生一个素数
  67.                 int randomPrime =primeArr[new Random().nextInt(primes.size())];
  68.                 System.out.println("随机产生的重复的素数是: "+ randomPrime);
  69.                
  70.                 //再次随机产生一个索引位置 并将这个随机产生的素数存入这个随机产生的索引位置
  71.                 int randomIndex =new Random().nextInt(primes.size());
  72.                 System.out.println("这个随机产生的素数存放到原数组的随机位置是: "+ randomIndex);
  73.                 insertIntoArray(randomPrime, randomIndex, primeArr);
  74.                 return primeArr;
  75.         }
  76.        
  77.         //将指定的数字存入指定的位置
  78.         private static void insertIntoArray(int num, int index,
  79.                         int[] primeArr) {
  80.                 //向指定数组的指定位置插入一个数字  现将数组中此位置以后的数字依次向后进行移位
  81.                 for(int i= primeArr.length-2; i>= index; i--){
  82.                         primeArr[i+1] =primeArr[i];
  83.                 }
  84.                
  85.                 //将指定的数字插入到指定的位置
  86.                 primeArr[index] =num;
  87.         }
  88.        
  89.         //获取指定范围的素数
  90.         private static List<Integer> getPrimes(int upBound) {
  91.                 List<Integer> primes =new ArrayList<Integer>();
  92.                
  93.                 for(int i=2; i<=100; i++){
  94.                         if(isPrime(i))
  95.                                 primes.add(i);
  96.                 }
  97.                 return primes;
  98.         }

  99.         //判断一个数是否为素数
  100.         private static boolean isPrime(int num){
  101.                 boolean isPrime =true;
  102.                 //--根据素数的定义 :在一个大于1的自然数中,除了1和此整数自身外,不能被其他自然数整除的数
  103.                 //--要对给定的数 i 判定除了1和自身(num)以外的整数 是不是有能被i整除的
  104.                 for(int i=2; i<num; i++){
  105.                         if(num%i==0){ //如果能被整除 整除标记isPrime标记为false  表示不是素数
  106.                                 isPrime =false;
  107.                                 //开区间(1, i)之间一旦有一个数能整除i
  108.                                 //--就表示i不是素数  直接跳出  不用继续进行判断 节省计算量
  109.                                 break;
  110.                         }
  111.                         //如果(1, i)之间都没有能整出i的数出现, 就表示这个数i是素数  要更新isPrime
  112.                         isPrime =true;
  113.                 }
  114.                 return isPrime;
  115.         }
  116. }
复制代码
不好意思 版主 一时疏忽 没有贴完整  额  这回完整啦 您看看对不对 :)

test2_1.jpg (105.79 KB, 下载次数: 0)

test2_1.jpg

评分

参与人数 1技术分 +4 收起 理由
神之梦 + 4 很给力!

查看全部评分

回复 使用道具 举报
第一题,
  1. package test;

  2. import java.io.BufferedReader;
  3. import java.io.IOException;
  4. import java.io.InputStreamReader;

  5. public class TestFactorization {
  6.         public static void main(String[] args) {
  7.                 BufferedReader bfbr = new BufferedReader(new InputStreamReader(System.in));
  8.                 System.out.println("请输入要分解因数的数,按回车确认");//
  9.                 try {
  10.                         String line = bfbr.readLine();
  11.                         int num = Integer.parseInt(line);//获得输入的数
  12.                         showFactorization(num);
  13.                 } catch (IOException e) {
  14.                         e.printStackTrace();
  15.                 }catch(Exception e){
  16.                         e.printStackTrace();
  17.                         throw new RuntimeException("输入非法,请输入数字");
  18.                 }
  19.                
  20.         }

  21.         /**
  22.          * 这个函数就是用来计算质因数了
  23.          * @param num
  24.          */
  25.         private static void showFactorization(int num) {
  26.                 int n = num;
  27.                 StringBuilder sb = new StringBuilder();
  28.                 for(int i=2; i<=num/2; i++){
  29.                         while(n%i == 0){
  30.                                 sb.append(i + "*");
  31.                                 n = n/i;
  32.                         }
  33.                        
  34.                         if(n < i) //这个判断条件可以减少循环次数,节省资源
  35.                                 break;
  36.                 }
  37.                
  38.                 if(sb.length() != 0){
  39.                         sb.deleteCharAt(sb.length()-1);//如果不是素数,就把多余的*给去掉
  40.                 }else{
  41.                         sb.append(1 +"*" + num);//如果是素数,就这样输出
  42.                 }
  43.                
  44.                 System.out.println(sb.toString());
  45.         }
  46. }
复制代码
输出结果
请输入要分解因数的数,按回车确认
13
1*13

请输入要分解因数的数,按回车确认
100
2*2*5*5


第二题
  1. package test;

  2. import java.util.ArrayList;
  3. import java.util.List;
  4. import java.util.Random;

  5. public class TestPrime {

  6.         public static void main(String[] args) {
  7.                 Integer[] arr = getPrimeArr();
  8.                 System.out.println("数组中相同的两个元素角标为" + getSame(arr));
  9.         }
  10.        
  11.         public static Integer[] getPrimeArr(){
  12.                 List<Integer> arrList = new ArrayList<Integer>();
  13.                 for(int i=1; i<=100; i++){
  14.                         if(isPrime(i))
  15.                                 arrList.add(i);
  16.                 }
  17.                
  18.                 //这段代码简化了,就是arrList.add(int, Integer)只不过两个参数都通过随机工具来确定
  19.                 arrList.add(new Random().nextInt(arrList.size()),arrList.get(new Random().nextInt(arrList.size())));
  20.                
  21.                 System.out.println(arrList);
  22.                 return arrList.toArray(new Integer[arrList.size()]);
  23.         }
  24.        
  25.         //该方法判断一个数是否为素数
  26.         public static boolean isPrime(int i){
  27.                 if(i == 1||i==2||i==3)
  28.                         return true;
  29.                 else{
  30.                         for(int j=2; j<=i/2; j++){
  31.                                 if(i%j == 0 ){
  32.                                         return false;                               
  33.                                 }
  34.                         }
  35.                 }               
  36.                 return true;
  37.         }
  38.        
  39.         //这个方法可以再优化,然后寻找到拥有三个以上的相同元素的数组中相同元素的角标,这里是根据题目写的简洁版
  40.         public static String getSame(Integer[] arr){
  41.                 List<Integer> arrList = new ArrayList<Integer>();
  42.                
  43.                 String str = null;
  44.                 for(int i=0; i<arr.length; i++){
  45.                         if(!arrList.contains(arr[i])){
  46.                                 arrList.add(arr[i]);
  47.                         }else
  48.                                 str =  arrList.indexOf(arr[i]) + "," + i;
  49.                 }
  50.                
  51.                 return str;
  52.         }

  53. }
复制代码
输出结果
[1, 2, 3, 17, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
数组中相同的两个元素角标为3,8

第三题
  1. package test;

  2. import java.io.BufferedInputStream;
  3. import java.io.BufferedOutputStream;
  4. import java.io.File;
  5. import java.io.FileInputStream;
  6. import java.io.FileNotFoundException;
  7. import java.io.FileOutputStream;
  8. import java.io.IOException;
  9. import java.util.regex.Matcher;
  10. import java.util.regex.Pattern;

  11. public class CopyFileDemo {

  12.         public static void main(String[] args) {
  13.                 File file = new File("E:\\cn");
  14.                 overFile(file);
  15.         }
  16.        
  17.         /**
  18.          * 遍历文件夹 进行复制,题目指明了文件名称的格式,如果更严谨点还应该在方法中加入判断是否为java文件的语句
  19.          * @param file
  20.          */
  21.         public static void overFile(File file){
  22.                 if(!file.exists())
  23.                         return ;
  24.                 if(file.isDirectory()){
  25.                         File[] files = file.listFiles();
  26.                         for(File f: files){
  27.                                 if(f.isDirectory())
  28.                                         overFile(f);
  29.                                 else{
  30.                                         copyFile(f.getAbsoluteFile());
  31.                                 }
  32.                         }
  33.                 }else{
  34.                         copyFile(file.getAbsoluteFile());
  35.                 }
  36.         }
  37.        
  38.         public static void copyFile(File file){
  39.                 BufferedInputStream bis = null;
  40.                 BufferedOutputStream bos = null;
  41.                 try {
  42.                         bis = new BufferedInputStream(new FileInputStream(file));
  43.                         bos = new BufferedOutputStream(new FileOutputStream(changeName(file)));//调用变更名字的方法来创建复制的文件
  44.                        
  45.                         byte[] buf = new byte[1024];
  46.                         int len = 0;
  47.                         while((len = bis.read(buf)) != -1){
  48.                                 bos.write(buf, 0, len);
  49.                         }
  50.                 } catch (FileNotFoundException e) {
  51.                         e.printStackTrace();
  52.                 } catch (IOException e) {
  53.                         e.printStackTrace();
  54.                 }finally{
  55.                         try {
  56.                                 if(bis != null){
  57.                                         bis.close();
  58.                                         bis = null;
  59.                                 }                               
  60.                         } catch (IOException e) {
  61.                                 e.printStackTrace();
  62.                         }
  63.                         try {
  64.                                 if(bos != null){
  65.                                         bos.close();
  66.                                         bos = null;
  67.                                 }                               
  68.                         } catch (IOException e) {
  69.                                 e.printStackTrace();
  70.                         }
  71.                        
  72.                 }
  73.         }
  74.        
  75.         /**
  76.          * 变更文件名称,获得复制文件的目的文件名称
  77.          * @param file
  78.          * @return
  79.          */
  80.         public static File changeName(File file){
  81.                 String[] strs = file.getAbsolutePath().split("\\\\");               
  82.                 String str = strs[strs.length -1];
  83.                 StringBuffer sb = new StringBuffer(str);
  84.                 Pattern p = Pattern.compile("([0-9]+)[\\w]+");//正则表达式的应用
  85.                 Matcher m = p.matcher(str);
  86.                 if(m.find()){                       
  87.                         sb.insert(sb.lastIndexOf(".java"), m.group(1));
  88.                 }
  89.                
  90.                 //通过文件路径的父路径和改变好的目的文件名称创建新的文件路径
  91.                 return new File(file.getParent() + File.separator + sb.toString());
  92.         }

  93. }
复制代码
运行结果在我电脑上是成功的,不知道怎么上传图片 所以就没截图了

评分

参与人数 1技术分 +6 收起 理由
神之梦 + 6 很给力!

查看全部评分

回复 使用道具 举报
看下啦,努力赚分
回复 使用道具 举报
  1. import java.util.Scanner;


  2. public class Demo2 {
  3.         public static void main(String[] args) {
  4.                 Scanner sc = new Scanner(System.in);//用户键盘输入数字
  5.                 System.out.println("请输入你想分解的数字");
  6.                         int number = sc.nextInt();//控制台获得想分解的数字
  7.                         int z = 2;//2为最小质数
  8.                 while (number> z) {
  9.                     if (number % z== 0) {//但number能被k整除,则应打印出z的值
  10.                         System.out.print(z+"x");
  11.                         }
  12.                     number = number / z;//并用number除以z的结果,作为新的数number,重复执行循环里的步骤
  13.                    
  14.                     if (number % z != 0) {//(3)如果number不能被z整除,则用z+1作为k的值,重复执行循环里的步骤
  15.                         z++;
  16.                     }
  17.                 }
  18.                 System.out.println(z);
  19.             }
  20.         }
  21.    
复制代码
回复 使用道具 举报
第一次回复发表于31#  昨天 21:49~
该中饭了,先发前两道~

第一题
  1. import java.util.Scanner;

  2. /*
  3. * 题目1:键盘录入一个正整数,将其分解质因数。如:输入30,打印出30=2*3*5。
  4. *
  5. * 分析:  应用递归的方法求解。
  6. *       从2开始取模数对录入的正整数进行取模,如果模为零,则二者相除的结果作为被模数继续递归取模,
  7. *       如果模不为0,则被模数不变,模数加1,继续递归,直到模数增加到被模数的1/2以上。
  8. *
  9. */
  10. public class Test1 {

  11.         public static void main(String[] args) {
  12.                 //从控制台获取一个整数
  13.                 Scanner in = new Scanner(System.in);
  14.                 System.out.print("请输入一个正整数:");
  15.                 int i = in.nextInt();
  16.                 //调用递归方法获取结果
  17.                 diGui(i,2,i);
  18.         }
  19.         /**
  20.          * 递归方法,将输入的正整数进行分解为质因数并输出
  21.          * @param a 被模数
  22.          * @param b 模数
  23.          * @param x 控制台输入的原值
  24.          */
  25.        
  26.         //只为完成题目要求,就private好了。
  27.         private static void diGui(int a, int b, final int x){
  28.                 //结束条件:当b大于a的一半时输出最后一个被模数,如果被模数一直无变化,说明是质数。
  29.                 if(a < b * 2){
  30.                         if(a != x)
  31.                                 System.out.println(a);
  32.                         else
  33.                                 System.out.println("您输入的是一个质数,无法分解");
  34.                         return;
  35.                 }
  36.                 //如果可整除,则继续用此数进行递归,否则将被模数+1。
  37.                 else if(a % b == 0){
  38.                         if(a == x)
  39.                                 System.out.print(x + "= ");
  40.                         System.out.print(b + "* ");
  41.                         diGui(a / b, b, x);
  42.                 }else
  43.                         diGui(a, b + 1, x);
  44.         }
  45. }/* Output:
  46. 请输入一个正整数:90
  47. 90= 2* 3* 3* 5
  48. *///:~
复制代码
第二题
  1. import java.util.ArrayList;
  2. import java.util.Arrays;
  3. import java.util.Random;


  4. /*
  5. * 题目2:求出1-100之间的素数,假设有n个,将这些素数存入a[n+1]的数组中。
  6. * (其中n个是求出的各个素数,还有一个是随机添加其中的一个素数)
  7. *  这样数组中就有相同的两个素数,写一个搜索算法,找出数组中相同的那个素数。
  8. *   (随机添加的素数,可手动指定,也可利用随机方法产生)
  9. *  (注:存入数组后,数组中的所有元素理论上是无序的,相同的那个素数不一定就等于a[n],
  10. *  而是被存入了数组中的某个角标上)
  11. *
  12. * 分析: 首先要找出1-100之间的素数。素数的判断可以用二重循环嵌套,也可以用递归,这里用
  13. *       for循环嵌套,外层枚举数,内层枚举2~sqrt(外层数字)之间的数对外层数取模。内层枚举结束
  14. *       依然没找到模0的数则外层为素数。
  15. *      
  16. *       因为找到的素数不是直接打印而是放在数组中,而查找过程结束前找到的素数个数未知,
  17. *       因此使用ArrayList临时存放找到的素数,之后根据ArrayList中元素的个数确定数组大小,再
  18. *       将其移动到数组内。
  19. *      
  20. *       因为要在数组中添加一个重复的素数,所以数组大小可以定义为实际素数大小加1。再移入数组时,先
  21. *       随机产生一个角标,移入时跳过此位置,之后再在素数中随机找一个放入此位,至此a[n+1]数组就搞定了。
  22. *      
  23. *       之后要解决的就是如何在一个无序数组中找到重复元素,可以使用排序后临位比较的方法,但效率较低,
  24. *       因此可以使用类似选择排序的方式查找重复,但不进行换位操作,这样效率较高。
  25. *
  26. */

  27. public class Test2 {

  28.         public static void main(String[] args) {
  29.                 //定义一个ArrayList用于临时存储找到的素数
  30.                 ArrayList<Integer> list = new ArrayList<Integer>();
  31.                
  32.                 //嵌套循环寻找素数,找到后插入到list中,模数限定不大于被模数的平方根,以提高效率
  33.                 for(int i = 2; i <= 100; i++){
  34.                         for(int j = 2;; j++){
  35.                                 if(j > (int)Math.sqrt(i)){
  36.                                         list.add(i);
  37.                                         break;
  38.                                 }
  39.                                 if(i % j == 0)
  40.                                         break;
  41.                         }
  42.                 }
  43.                
  44.                 //输出找到的list,这里直接调用了list的toString方法。
  45.                 System.out.println("1-100之间的素数有:\n" + list);
  46.                
  47.                 //创建了一个int数组,大小为素数个数+1
  48.                 int size = list.size();
  49.                 int[] arr = new int[size + 1];
  50.                
  51.                 //生成随机数,randomNum为随机生成的1-100中的某素数,randomPos是插入数组中的位置
  52.                 //这样可以让每次运行时插入的数和插入的位置都不同
  53.                 Random rand = new Random();
  54.                 int randomNum = list.get(rand.nextInt(size));
  55.                 int randomPos = rand.nextInt(size);
  56.                
  57.                 //下面将ArrayList中的元素移动到数组中,在随机位插入随机素数,在尾位插入跳过的素数
  58.                 for(int i = 0; i < arr.length - 1; i++){
  59.                         if(i == randomPos){
  60.                                 arr[i] = randomNum;
  61.                                 continue;
  62.                         }
  63.                         arr[i] = list.get(i);
  64.                 }
  65.                 arr[arr.length - 1] = list.get(randomPos);
  66.                
  67.                 //输出完成插入后的数组
  68.                 System.out.println("插入随机素数之后的数组为:\n" + Arrays.toString(arr));
  69.                
  70.                 //使用类似选择排序的方式进行多次比较,但不交换元素的位置,即实际不排序
  71.                 for(int i = 0; i < arr.length -1; i++){
  72.                         for(int j = i + 1; j < arr.length; j++){
  73.                                 if(arr[i] == arr[j])
  74.                                         System.out.println("重复元素为" + arr[i] + " ,出现位置为角标" + i + "和角标" + j);
  75.                         }
  76.                 }
  77.         }
  78. }/* Output:
  79. 1-100之间的素数有:
  80. [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
  81. 插入随机素数之后的数组为:
  82. [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 11, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 47]
  83. 重复元素为11 ,出现位置为角标4和角标14
  84. *///:~
复制代码

评分

参与人数 1技术分 +6 收起 理由
神之梦 + 6 很给力!

查看全部评分

回复 使用道具 举报
本帖最后由 王洪波 于 2013-7-8 22:03 编辑

首先谢谢版主能够指出错误。
我重新改了下,如还有错,请再指出。
  1. package com.itheima.bbs.c5a3;

  2. import java.util.ArrayList;
  3. import java.util.Arrays;
  4. import java.util.Collections;
  5. import java.util.HashMap;
  6. import java.util.List;
  7. import java.util.Map;
  8. import java.util.Random;

  9. /**
  10. * 2、求出1-100之间的素数,假设有n个,将这些素数存入a[n+1]的数组中。(其中n个是求出的各个素数,还有一个是随机添加其中的一个素数)
  11.       这样数组中就有相同的两个素数,写一个搜索算法,找出数组中相同的那个素数。(随机添加的素数,可手动指定,也可利用随机方法产生)
  12. */
  13. public class CopyOftest2
  14. {
  15.         public static void main(String[] args)
  16.         {       
  17.                 List<Integer> primes = new ArrayList<Integer>();
  18.                 primes.add(2);//2 为素数先加进去
  19.                 for(int i=3; i<=100; i+=2)
  20.                 {
  21.                         if(isPrime(i))
  22.                                 primes.add(i);
  23.                 }
  24.                 int size = primes.size();//原数组的大小
  25.                 Random random = new Random();
  26.                 //随机生成一个索引
  27.                 int index = random.nextInt(size);
  28.                 int s = primes.get(index);//额外添加的的素数
  29.                 System.out.println("额外添加的的相同素数"+s);
  30.                 //添加素数到随机位置
  31.                 int pos = random.nextInt(size);
  32.                 primes.add(pos, s);
  33.                 //输出结果
  34.                 printArray(primes);
  35.                 //找数组中相同的两个素数
  36.                 searchSame(primes);
  37.         }
  38.         /**
  39.          * 在集合list中查找元素i
  40.          */
  41.         private static void searchSame(List<Integer> list)
  42.         {       
  43.                 int index = -1;
  44.                 for(int i=1,size=list.size(); i<size; i++)
  45.                 {       
  46.                         //改动点:这里用二分查找相同元素,前面的元素可能是无序的,考虑不周.这里改成了用indexOf()去前边元素中找
  47.                         index = list.subList(0, i).indexOf(list.get(i));//从数组前边元素【0,i-1】中找
  48.                         if(-1 != index)//包含当前元素
  49.                         {
  50.                                 //找到了
  51.                                 System.out.println("位置"+i+"与位置"+index+"上的素数相同!都为:"+list.get(i));
  52.                                 return;
  53.                         }
  54.                 }
  55.                 System.out.println("没有找到相同元素!");
  56.         }
  57.         private static void printArray(List<Integer> primes)
  58.         {
  59.                 for(int i=1,size=primes.size(); i<=size; i++)
  60.                 {       
  61.                         //十个一行输出
  62.                                 System.out.print((i-1)+":"+primes.get(i-1)+" ");
  63.                                 if(i%10 == 0)
  64.                                         System.out.println();
  65.                 }
  66.                 System.out.println();
  67.         }

  68.         /**
  69.          * 判断i是否为素数
  70.          */
  71.         private static boolean isPrime(int i)
  72.         {       
  73.                 for(int j=2; j<i; j++)
  74.                 {
  75.                         if(i%j == 0)
  76.                                 return false;
  77.                 }
  78.                 return true;
  79.         }
  80. }
复制代码

评分

参与人数 1技术分 +3 收起 理由
神之梦 + 3 很给力!

查看全部评分

回复 使用道具 举报
先看题目
回复 使用道具 举报
水一下:lol

评分

参与人数 1黑马币 +3 收起 理由
神之梦 + 3 欢迎,能给出指导性意见就最好了.

查看全部评分

回复 使用道具 举报
这个必须顶
回复 使用道具 举报
抱着试试看的态度做了下,勉强做了第二、三题,不知道是否符合要求,但是对复习巩固确实很有效。第一题还是不会啊,还请多多指教哦。

          第二题:求出1-100之间的素数,假设有n个,将这些素数存入a[n+1]的数组中。(其中n个是求出的各个素数,还有一个是随机添加其中的一个素数)
这样数组中就有相同的两个素数,写一个搜索算法,找出数组中相同的那个素数。(随机添加的素数,可手动指定,也可利用随机方法产生)

package com.itheima;
import java.io.*;
import java.util.ArrayList;
import java.util.Random;
/*思路:
* 1.求1到100之间的素数,首先应该有一个判断某数是否为素数的方法。
* 2.因为素数的个数n不确定,而要将其存放于数组,但是数组长度是固定的,如直接定义数组,
* 其长度无法准确定义,但是想到集合是可变长度的,且ArrayList可转换为数组,故使用
* ArrayList先存放数组元素,再转换为int数组。
* 3.要在素数数组中随机插入一个素数,可使用ArrayList的add(int index, E element) 方法,
* 其添加位置index有Random类随机产生。而添加的素数由手动键盘输入。
* 4.查找相同的那个素数可由两个for语句嵌套遍历数组得到。
*/
public class TestTwo {
/**
  * @param args
  * @throws Exception
  */
public static void main(String[] args) throws Exception {
  
  //调用getPrimeToList方法。得到素数对应Integer组成的ArrayList集合
  ArrayList<Integer> al = primeToList();
  //调用listToArray(ArrayList<Integer> al)方法,将al转换成int[];
  int[] arr = listToArray(al);//如输入的不是数字,会产生异常
  String prime = getAlikeEle(arr);
  System.out.println(prime);

}
//获取相同的素数,
public static String getAlikeEle(int[] arr){
  for(int x=0;x<arr.length-2;x++){
   for(int y=x+1;y<arr.length-1;y++){
    if(arr[x]==arr[y])
     return "相同的素数"+arr[x]+"位于素数表的"+x+"位置和"+y;
       //该处的素数表值得是按从小到大排列的100以内的素数表
   }
  }
  return -1+"";
}

//在ArrayList集合中随机插入录入的素数,并返回一个Object数组
public static int[] listToArray(ArrayList<Integer> al)throws Exception{
  //产生一个位于在al角标内的随机数,用于指定素数插入的位置
  int r = new Random().nextInt(al.size()-1);
  
  //创建键盘输入流,读取键盘录入的素数的字符串表示形式。
  BufferedReader bufr =
    new BufferedReader(new InputStreamReader(System.in));
  
  //读取键盘录入,去除两端空格。
  String line = bufr.readLine().trim();
  //如果输入为null,或者不是纯数字,报异常
  if((line==null) && (line.matches("\\d{1,3}")))
   throw new RuntimeException("输入的不是数字");
  //将int类型的字符串转换为Integer对象
  Integer insertPrime = Integer.valueOf(line);
  
  //判断输入的数字是否为1到100间的素数,如不是直接报异常
  int a = insertPrime;
  if(a<1 || a>100 || !(TestTwo.isPrime(a)))
   throw new RuntimeException("输入的素数不是1到100间的素数");
  
  
  //将输入的素数随机插入al集合中
  al.add(r, insertPrime);
  
  //遍历Object[]将其转换为int数组
  int[] arr = new int[al.size()];
  for(int i=0;i<al.size();i++){
   arr = al.get(i);
  }
  return arr;
}


//获取1到100内的素数,并存放到一个ArrayList集合中
public static ArrayList<Integer> primeToList(){

  //创建ArrayList,并加范型,只允许存入Integer类型的对象
  ArrayList<Integer> al = new ArrayList<Integer>();
  for(int x=2;x<100;x++){ //因1和100都不是素数,故不作判断
   if(TestTwo.isPrime(x))
    al.add(x); //自动装箱,x封装为Integer
  }
  if(al.size()==0)
   return null; //如果al为null,表示1到100之间无素数
  return al;  
}

/*判断一个数是否为素数的方法
  *参考素数判定的“埃拉托斯特尼筛法”,检查一个正整数N是否为素数,
  *最简单的方法就是试除法,将该数N用小于等于根号N的所有素数去试除,若均无法整除,则N为素数
  */
public static boolean isPrime(int num){
  if(num<=1)
   return false; //1不是素数,负数不考虑

  int x = (int) Math.ceil(Math.sqrt(num));
  for(int i=2;i*i<=x;i++){
   if(num%i==0)
    return false; //num有1和其本身以外的因子,故不是素数
  }
  return true; //num没有1和其本身以外的因子,故不是素数
}
}


         第三题:在一个文件夹内有文件夹和文件,文件名的格式为:数字+名称.java。
  要求:把所有的.java文件复制一份,变为文件名格式为:数字+名称+数字.java。
(其中数字是相对应的,名称由字母组成。如:01Demo.java——>01Demo01.java)

package com.itheima;
import java.io.*;
/*
* 思路分析:
*1.复制.java文件用FileReader和FileWriter,可加BufferedReader和BufferedWriter提高效率。
*2. 同时因为只复制.java文件,需要进行文件过滤,用File对象的
*  File[] listFiles(FilenameFilter filter) 方法获取.java文件对象。
* 这里不采用获取文件名的方式,因为要判断.java文件不是目录,而是文件,同时在读取流读取的时候也可直接使用。
*3.获取文件名前面的数字,加到原文件名的.java前面。
*4.将数据写到新文件名对应的目标文件中
*/
public class TestThree {
/**
  * @param args
  */
public static void main(String[] args) {
  // TODO Auto-generated method stub
  File file = new File("F:\\");
  if(!(file.exists()&&file.isDirectory()))
   throw new NullPointerException("路径有误"); //如给定的文件夹不存在,抛异常
  
  //new一个本类对象调用复制文件的方法
  new TestThree().copyJava(file);
}
//实现.java文件复制的方法,此方法只能实现复制后的文件仍处于原文件夹内
public void copyJava(File file){
  //获取.java文件对象,需传入一个过滤器,并将对象存入一个File数组中
  File[] files = file.listFiles(new FilterByJava());

  //定义读取流和写入流,因操作文本文件,用字符流缓冲区提高效率
  BufferedReader bufr = null;
  BufferedWriter bufw = null;

  //for循环实现对每一个.java文件的读写
  for(File srcFile : files){
   
   if(srcFile.isDirectory()) //如果srcFile是一个后缀为.java的目录
    continue;    //不再复制,而继续遍历下一个文件。
   
   //获取复制的目的地,并用正则表达式获取写入目的地的字符串表示,即copyName
   String[] sfile = srcFile.getAbsolutePath().split("\\.");
   String copyName = sfile[0].replaceAll("((\\d+)(.)+)","$1$2")+".java";   
   File desFile = new File(copyName);
   
   try{   
    bufr = new BufferedReader(new FileReader(srcFile));
    bufw = new BufferedWriter(new FileWriter(desFile));
    String line = null;
   
    //频繁的读写操作
    while((line=bufr.readLine())!=null){
     bufw.write(line);
     bufw.newLine();
     bufw.flush();
    }
   }
   catch(IOException e){
    throw new RuntimeException("文件复制失败!");
   }
   finally{
    try {
     if(bufw!=null)
      bufw.close();
    }
    catch (IOException ex1) {
      // TODO Auto-generated catch block
      throw new RuntimeException("写入流关闭异常");
    }
    finally{
     if(bufr!=null)
      try{
       bufr.close();
      }
      catch(IOException ex2){
       throw new RuntimeException("读取流关闭异常");
      }
    }
   }
  }
}
}
/**按文件名过滤.java文件
* */
class FilterByJava implements FilenameFilter{
@Override
public boolean accept(File dir, String name) {
  // TODO Auto-generated method stub
  return name.endsWith(".java");
}

}

itheima.zip

3.83 KB, 阅读权限: 100, 下载次数: 0

评分

参与人数 1技术分 +2 收起 理由
神之梦 + 2 第三题的

查看全部评分

回复 使用道具 举报
本帖最后由 camml 于 2013-7-8 15:14 编辑
  1. import java.util.*;
  2. class Demo1{
  3.         public static void main(String[] args){
  4.                  //输入一个正整数,并赋值给x
  5.                 int x;
  6.                 Scanner in = new Scanner(System.in);
  7.                 System.out.print("请输入一个正整数:");
  8.                 x = in.nextInt();
  9.                //匿名初始化一个对象
  10.                new PrimeSplit(x);
  11.        }
  12. }
  13. class PrimeSplit{
  14.         //将最小的质数赋值给k
  15.        int k = 2;
  16.        public PrimeSplit(int x){
  17.                 //当输入的是1或2时特殊处理
  18.                if(x<=1){
  19.                      System.out.println(x+"是无效的被分解数");
  20.                }
  21.                else if(x==2){
  22.                     System.out.println(x+"分解后的质因数为: 1*"+x);
  23.                }else {
  24.                     //1是所有的正整数的质数,后面和输出语句相连
  25.                     System.out.print(x+"分解后的质因数为: 1");
  26.                      while(k<=x){
  27.                            //输入的数除以最小质数后重新循环
  28.                           if(x%k==0){
  29.                                   System.out.print("*"+k);
  30.                                   x = x/k;
  31.                           }
  32.              //如果k不能被x整除,就将k++
  33.             else{
  34.                 k++;
  35.             }
  36.          }
  37.       }
  38.   }
  39. }
复制代码

评分

参与人数 1技术分 +1 收起 理由
神之梦 + 1 1不属于素数也不是质数

查看全部评分

回复 使用道具 举报
  1. package day06静态;
  2. import java.util.Scanner;


  3. public class Demo2 {
  4.         public static void main(String[] args) {
  5.                 Scanner sc = new Scanner(System.in);//用户键盘输入数字
  6.                 System.out.println("请输入你想分解的数字");
  7.                         int number = sc.nextInt();//控制台获得想分解的数字
  8.                         int z = 2;//2为最小质数
  9.                 while (number> z) {
  10.                     if (number % z== 0) {//但number能被k整除,则应打印出z的值
  11.                         System.out.print(z+"x");
  12.                         number = number / z;//并用number除以z的结果,作为新的数number,重复执行循环里的步骤
  13.                         }
  14.                     
  15.                     
  16.                     if (number % z != 0) {//(3)如果number不能被z整除,则用z+1作为k的值,重复执行循环里的步骤
  17.                         z++;
  18.                     }
  19.                 }
  20.                 System.out.println(z);
  21.             }
  22.         }
  23.    
复制代码
刚刚看了一下,number = number / z;  应该放在if循环里面,保证可以整除最小质数。
回复 使用道具 举报
哥们儿,我是39楼的,帖子地址:http://bbs.itheima.com/forum.php ... 9314&pid=399428
你说我的第三题测试时出现角标越界异常,我运行了几遍没问题啊,用Eclipse和直接用cmd运行都没问题啊,都可以正常复制文件,
不知道你运行时出问题的语句在哪一行?
我把第三题的代码再贴一次,你看一下
  1. /*
  2. 在一个文件夹内有文件夹和文件,文件名的格式为:数字+daxiang.java。
  3. 要求:把所有的.java文件复制一份,变为文件名格式为:数字+daxiang+数字.java。
  4. (其中数字是相对应的,名称由字母组成。在本例中,文件名应该由"数字+daxiang.java"变为"数字+daxiang+数字.java")
  5. */
  6. /*
  7. 基本思路:1,用递归方法获取到源目录下的java文件;
  8. 2,用缓冲流将源文件复制到目的文件夹下的目的文件;
  9. 3,用字符串的split方法拆分并重新组合出目的文件的文件名;
  10. @author:蚂蚁搬家;
  11. */

  12. import java.io.*;

  13. public class CopyFile
  14. {
  15.                 public static void main(String [] args)
  16.                 {
  17.                                 File file = new File("F:\\答题有分");                        //源文件夹封装为File对象;
  18.                                 get(file);                                                                                                                                //调用get方法实现题目要求;
  19.                 }
  20.                
  21.                 /*用递归方法获取源目录下的每个java文件,然后调用copyFile方法,将源文件复制到另一个文件夹中,
  22.                 并对文件按照题目要求进行更名;*/
  23.                 public static void get(File srcFile)                                
  24.                 {
  25.                                 File[] files  = srcFile.listFiles();                //列出源目录下的所有文件和目录;
  26.                                
  27.                                 for(File file : files)
  28.                                 {
  29.                                         if(file.isDirectory())                                //如果是目录,递归调用get方法;
  30.                                         {
  31.                                                         get(file);
  32.                                         }       
  33.                                         else
  34.                                         {
  35.                                                 if(file.getName().endsWith(".java"))                //如果是java文件,调用copyFile方法;
  36.                                                 {
  37.                                                         copyFile(file);       
  38.                                                 }
  39.                                         }
  40.                                 }
  41.                 }
  42.                
  43.                 //将源文件复制到目的文件夹,并对源文件按照题目要求更名;
  44.                 public static void copyFile(File file)
  45.                 {
  46.                                 BufferedReader br = null;
  47.                                 BufferedWriter bw = null;
  48.                                 try
  49.                                 {
  50.                                                 br = new BufferedReader(new FileReader(file));
  51.                                                
  52.                                                 String srcName = file.getName();                //获取源文件的文件名;
  53.                                                 String[] tempName = srcName.split("daxiang");         //将源文件名用“daxiang”拆分,拆分出来的结果是“数字”和“.java”;
  54.                                                 String lastedName = tempName[0] + "daxiang" + tempName[0] + tempName[1];        //重新组合出来的结果就是"数字+daxiang+数字.java";
  55.                                                
  56.                                                 bw = new BufferedWriter(new FileWriter("F:\\目标文件夹\\" + lastedName));
  57.                                                
  58.                                                 String buf = null;
  59.                                                 while((buf = br.readLine()) != null)
  60.                                                 {
  61.                                                         bw.write(buf);
  62.                                                         bw.newLine();
  63.                                                         bw.flush();       
  64.                                                 }
  65.                                 }
  66.                                 catch(IOException e)
  67.                                 {
  68.                                         System.out.println("文件复制失败!");       
  69.                                 }
  70.                                
  71.                                 finally
  72.                                 {
  73.                                         try
  74.                                         {
  75.                                                         if(br != null)
  76.                                                                 br.close();
  77.                                         }       
  78.                                         catch(IOException e)
  79.                                         {
  80.                                                        
  81.                                         }
  82.                                        
  83.                                         try
  84.                                         {
  85.                                                 if(bw != null)
  86.                                                 bw.close();       
  87.                                         }
  88.                                         catch(IOException e)
  89.                                         {
  90.                                                        
  91.                                         }
  92.                                 }
  93.                 }
  94. }

  95.        

复制代码

评分

参与人数 1技术分 +2 收起 理由
神之梦 + 2 赞一个!

查看全部评分

回复 使用道具 举报
下午有事耽搁了~还好时间还没到~第一次回复发表于31#  昨天 21:49~

补发下第三题:

  1. /*
  2. *  题目: 在一个文件夹内有文件夹和文件,文件名的格式为:数字+名称.java。
  3. *        要求:把所有的.java文件复制一份,变为文件名格式为:数字+名称+数字.java。
  4. *       (其中数字是相对应的,名称由字母组成。如:01Demo.java——>01Demo01.java)
  5. *
  6. *  分析:首先要获取文件夹中文件名为数字+名称.java的所有文件列表。
  7. *        要实现此目标可以使用File.list(过滤器)方法,将目标文件夹定义为一个File对象,然后
  8. *        设置一个过滤器类FileFilter,过滤条件为.java结尾,并且文件名中含有数字。
  9. *        由于过滤器类仅仅创建了一个对象,并且设定的是本类的特有处理方式,不具备复用性,因此
  10. *        可以将这个FileFilter类设置为本类的匿名内部类。
  11. *        
  12. *        获得了要复制的文件列表之后,使用循环复制列表中的所有文件,调用改名方法将复制的目标文件名
  13. *        改为目标值,在改名方法中,可以使用正则表达式来获取文件名中的数字部分,将此数字部分与原文
  14. *        件名进行连接之后,即可获得新文件名。
  15. *        
  16. *        复制文件方法中,在这里使用了文件类型兼容型更强的文件输入输出流进行复制,复制的目标文件名
  17. *        为新文件名。
  18. */


  19. import java.util.Scanner;
  20. import java.io.File;
  21. import java.io.FilenameFilter;
  22. import java.io.FileInputStream;
  23. import java.io.FileOutputStream;

  24. public class Test3 {

  25.         public static void main(String[] args) {
  26.                
  27.                 //从控制台获取文件夹的绝对路径
  28.                 Scanner in = new Scanner(System.in);
  29.                 System.out.print("请输入此文件夹的绝对路径,如d:/workspaces/test/src :");
  30.                 String path = in.nextLine();
  31.                
  32.                 //将此文件夹定义为一个File对象pathFile
  33.                 File pathFile = new File(path);
  34.                
  35.                 //将过滤器类设计为了一个实现了FilenameFilter接口的匿名内部类
  36.                 //此过滤器的过滤条件为获取所有文件名必须以.java结尾并包含数字
  37.                 //通过调用过滤器对象,将符合条件的.java文件的文件名存入一个字符串数组list中
  38.                 String[] list = pathFile.list(new FilenameFilter(){
  39.                         @Override
  40.                         public boolean accept(File dir, String name) {
  41.                                 return (name.endsWith("java")) && (name.split("\\D+").length != 0);
  42.                         }
  43.                 });
  44.                
  45.                 //遍历java文件清单,将其中的所有.java文件改名复制到同一个文件夹中。
  46.                 //copyFile为自定义的赋值单个文件的方法。
  47.                 //改名过程调用了自定义的getNewName方法。
  48.                 for(String s : list){
  49.                         String fullPath = path + "/" + s;
  50.                         copyFile(fullPath, path + "/" + getNewName(s));
  51.                 }
  52.         }
  53.        
  54.         /**
  55.          * 此方法用于将指定的字符串结尾处的数字连接到原文件名的开始,生成新的字符串
  56.          * @param name 要处理的原字符串
  57.          * @return 返回处理后的字符串
  58.          */
  59.         private static String getNewName(String name){
  60.                 String[] strArr = name.split("\\D+");
  61.                 return strArr[1] + name;
  62.         }

  63.         /**        
  64.          * 此方法用于复制单个文件
  65.          * @param oldPath 原文件路径
  66.          * @param newPath 复制后路径         
  67.          */      
  68.         public static void copyFile(String oldPath, String newPath) {
  69.                 try {
  70.                         //设置文件输入输出流
  71.                         FileInputStream in = new FileInputStream(oldPath);         
  72.                         FileOutputStream out = new FileOutputStream(newPath);
  73.                        
  74.                         //1kb的byte数组
  75.                         byte[] buffer = new byte[1024];
  76.                         //循环读取数据,直至读空位置
  77.                         while ( (in.read(buffer)) != -1) {
  78.                                         out.write(buffer);
  79.                         }
  80.                         //关闭流
  81.                         in.close();
  82.                 }catch (Exception e) {              
  83.                         System.out.println("复制文件过程中出错");
  84.                         e.printStackTrace();
  85.                 }
  86.         }
  87. }
复制代码
技术分马上要够了~~求助攻~~{:soso_e142:}

点评

运行出现角标越界错误,我测试的文件夹了还有些其他的.java文件,哥们你查找下可能的情况  发表于 2013-7-9 01:31
回复 使用道具 举报
明早要考试啊、、、悲催、、我是看题呢还是看题呢还是看题呢还是看题呢
回复 使用道具 举报
第二题
  1. /**
  2. * 2、求出1-100之间的素数,假设有n个,将这些素数存入a[n+1]的数组中。(其中n个是求出的各个素数,还有一个是随机添加其中的一个素数)
  3. *这样数组中就有相同的两个素数,写一个搜索算法,找出数组中相同的那个素数。(随机添加的素数,可手动指定,也可利用随机方法产生)
  4. *
  5. *思路 :1先求出1-100中素数的个数n.建立长度为n+1的数组.
  6. *          2循环判断1到100中的数,是素数就存入数组中.
  7. *          3手动添加一个11的素数到数组a[n+1]中.
  8. *          4输出相同数的角标.
  9. */

  10. package a0703;

  11. public class Exam2 {

  12.         public static void main(String[] args) {
  13.                 int  n= 0;//素数的个数
  14.                 for (int i = 2; i <= 100; i++) {
  15.                         if (isPrime(i)) {
  16.                                 n++;        //计算数组长度;               
  17.                         }
  18.                 }
  19.                
  20.                 int [] a= new int [n+1];//数组长度
  21.                 a[n] = 11;   //手动添加一个素数11到数组中.
  22.                 n = 0;
  23.                 for (int i = 2; i <= 100; i++) {
  24.                         if (isPrime(i)) { //调用质数判断函数
  25.                                 a[n] = i;        //i是质数存入数组中
  26.                                 n++;                //
  27.                         }
  28.                 }       
  29.                
  30.                 for (int x = 0; x < a.length-1; x++) {//每个元素分别和比他角标大的元素进行比较
  31.                         for(int y = 1; y < a.length; y++) {
  32.                                 if (a[x] == a[y] && x != y) {  //两个数相等并且角标不一样
  33.                                         System.out.println("在数组角标为:"+x+"和"+y+"的两个元素相等");
  34.                                 }
  35.                         }
  36.                 }
  37.         }
  38.        
  39.         /**判定一个数是否是质数
  40.          * @param int n 接收一个int类型的变量。       
  41.          * @return false 这个数不是质数
  42.          *                         true 这个数是质数
  43.          */
  44.         private static boolean isPrime(int n) {//判定一个数是否是质数

  45.                 for(int i=2; i<=Math.sqrt(n); i++){
  46.                         if(n%i==0){
  47.                                 return false;
  48.                         }
  49.                 }
  50.                 return true;
  51.         }
  52. }
复制代码

评分

参与人数 1技术分 +2 收起 理由
神之梦 + 2 能把数组元素输出,并输出相同的数,而不只.

查看全部评分

回复 使用道具 举报
本帖最后由 肥猫 于 2013-7-8 21:08 编辑

第二题上交...
  1. /**
  2. 功能:求出1-100之间的素数,假设有n个,将这些素数存入a[n+1]的数组中。
  3. (其中n个是求出的各个素数,还有一个是随机添加其中的一个素数)
  4. 这样数组中就有相同的两个素数,写一个搜索算法,找出数组中相同的那个素数。
  5. (随机添加的素数,可手动指定,也可利用随机方法产生)
  6. author:肥猫
  7. */

  8. import java.util.*;

  9. class Test333
  10. {
  11.       public static void main(String[] args)
  12.       {
  13.             ArrayList<Integer> al = new ArrayList<Integer>();//先定义一个底层基于数组的容器来存储1-100的素数。
  14.             al.add(2);//由于素数本身的意义所以需要手动添加第一个元素2。
  15.             boolean b = false;
  16.             for(int i =2;i<=100;i++)//双重循环找出符合条件的素数并添加到容器中。
  17.            {
  18.                   for(int j =2;j<i;j++)
  19.                  {
  20.                        if(i%j==0)
  21.                       {
  22.                            b=false;
  23.                            break;
  24.                        }
  25.                        else
  26.                             b=true;
  27.                 }
  28.                 if(b)
  29.                 {
  30.                      al.add(i);
  31.                 }
  32.            }
  33.             int x=al.size()+1;
  34.             int[] a = new int[x];//根据容器的大小动态初始化数组。
  35.             for(int k=0;k<x-1;k++)
  36.            {
  37.                  a[k]=al.get(k);//将集合容器的值赋到数组中。
  38.             }
  39.             System.out.println("数组的长度是:"+a.length);
  40.             int key =a[(int)(Math.random()*(x-2))];//利用角标,随即抽取前面的角标将获得的值置于最后一位。
  41.             a[x-1]=key;
  42.             System.out.println("随机到的质数为:"+key);
  43.             System.out.print("数组:");
  44.             for(int l=0;l<a.length;l++){//遍历数组并输出以便于用二分法对其查找。
  45.             if(a[l]==key&&l!=x-1)
  46.            {
  47.                  System.out.print(a[l] +",");
  48.            }
  49.            else if(a[l]==a[x-1])
  50.            {
  51.                  System.out.println(a[l]);
  52.            }
  53.            else
  54.            {
  55.                  System.out.print(a[l]+",");
  56.            }
  57. }
  58. System.out.print("查找元素的索引是:");
  59. System.out.println(Arrays.binarySearch(a,0,x-1,key));//二分法对数组查找其索引。
  60. }
  61. }
复制代码


评分

参与人数 1技术分 +2 收起 理由
神之梦 + 2 随机产生的那个素数,不一定就是在最后一位.

查看全部评分

回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马