===答题送技术分(最高9分) 第三周(已结束)===

黄少海 · 黄少海

白天没时间在上课没时间上网.晚上加班加点搞出来.望楼主见谅啊! 第三题文件名没改出来.不过新加了一个功能可以复制自定义后缀的文件.

/**
题目3、在一个文件夹内有文件夹和文件，文件名的格式为：数字+名称.java。
要求：把所有的.java文件复制一份，变为文件名格式为：数字+名称+数字.java。
（其中数字是相对应的，名称由字母组成。如：01Demo.java——>01Demo01.java)
*/
package test;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.Scanner;
class Exam {
public static void main(String[] args) {
Scanner s = new Scanner(System.in);
System.out.println("复制文件的目录(去掉结尾的两个\\否则运行失败):");
String sourcePath = s.next();
System.out.println("源目录路径字符的个数.(如d:\\demo有7个字符 ,就输入7 ).请输入:");
int count = s.nextInt();
System.out.println("文件存储的目录(去掉结尾的两个\\否则运行失败):");
String storePath = s.next();
System.out.println("要复制的文件后缀名(如.java)");
String layout = s.next();
File f = new File(sourcePath);//创建一个文件夹对象
reCopy(f, sourcePath,count,storePath,layout);//
}
/**
@param f 接收一个文件夹对象
@param sourcePath 被复制文件的路径.(去掉结尾的两个\否则运行失败)
@param storePath 复制目的目录(去掉结尾的两个\否则运行失败)
@param count 源目录路径字符的个数.(如d:\demo有7个字符 ,就输入7 )
@param layout 要复制的文件后缀名
*/
public static void reCopy(File f, String sourcePath, int count,
String storePath,String layout) {
//Copy c = new Copy();
File[] st = f.listFiles();//创建一个抽象路径名数组,存储文件对象
for (int i = 0; i < st.length; i++) {
//判断如果是文件就复制.文件夹跳过不操作
if(st[i].isFile()) {
String s =st[i]+"";
String fileName = s.substring(count);//提取要文件名
if(fileName.endsWith(layout)) {
System.out.println(fileName);
copyFile(sourcePath ,fileName, storePath);
}
//用字符流传输(FileReader)
}
}
}
//复制一个文件到另外一个文件夹
public static void copyFile(String sourcePath, String fileName,String storePath) {
FileReader fr = null;
FileWriter fw = null;
int c = 0;
try {
//创建输入流
fr = new FileReader(sourcePath+"\\"+fileName);
//创建输出流
fw = new FileWriter(storePath+"\\"+fileName);
//输入流直接存进输出流达到文件传输
while ( (c = fr.read()) != -1) {
fw.write(c);
}
fw.flush(); // 强制刷新流
} catch(Exception e) {
e.printStackTrace();
}finally {
try {
//关闭流
fr.close();
fw.close();//
System.out.println("已经成功复制文件");
}catch(Exception e){}
}
}
}

复制代码

秦兰之 · 秦兰之

/*
*题目：
*1、键盘录入一个正整数，将其分解质因数。如：输入30，打印出30=2*3*5。
*/
import java.util.Scanner;//分解质因数
public class fenjiezys {
public static void main(String[] args) {
System.out.println("输入所求数：");
Scanner r = new Scanner(System.in);
long n = r.nextLong();
int flag = 0;
for(long i=2; i<=n; i++){
if (n%i == 0) {
flag++;
if(flag == 1){
System.out.print(n+"="+i);
}
else
{
System.out.print("×"+i);
}
n = n/i;
i--;
}
}
if (flag == 0) {
System.out.println(n+" 为质数");
}
else
{
System.out.println(" 共有"+flag+"个质因数"); }
}
}

复制代码

刘张朋 · 刘张朋

刘张朋发表于 2013-7-8 15:04
抱着试试看的态度做了下，勉强做了第二、三题，不知道是否符合要求，但是对复习巩固确实很有效。第一题还是 ...

可能是贴进去的时候什么地方弄错了

package com.itheima;
import java.io.*;
import java.util.ArrayList;
import java.util.Random;
/*思路：
* 第二题：求出1-100之间的素数，假设有n个，将这些素数存入a[n+1]的数组中。（其中n个是求出的各个素数，还有一个是随机添加其中的一个素数）
* 这样数组中就有相同的两个素数，写一个搜索算法，找出数组中相同的那个素数。（随机添加的素数，可手动指定，也可利用随机方法产生）
* 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[i] = 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<=x;i++){
if(num%i==0)
return false; //num有1和其本身以外的因子，故不是素数
}
return true; //num没有1和其本身以外的因子，故不是素数
}
}

复制代码

刘张朋 · 刘张朋

刘张朋发表于 2013-7-9 08:39
可能是贴进去的时候什么地方弄错了

我错了，以前的代码的60行和61行，在测试时如果直接按enter或者输入字母不是按我想的那样执行的，下面是修改后的代码，[code]package com.itheima;

import java.io.*;
import java.util.ArrayList;
import java.util.Random;

/*思路：
* 第二题：求出1-100之间的素数，假设有n个，将这些素数存入a[n+1]的数组中。（其中n个是求出的各个素数，还有一个是随机添加其中的一个素数）
* 这样数组中就有相同的两个素数，写一个搜索算法，找出数组中相同的那个素数。（随机添加的素数，可手动指定，也可利用随机方法产生）
* 1.求1到100之间的素数，首先应该有一个判断某数是否为素数的方法。
* 2.因为素数的个数n不确定，而要将其

刘张朋 · 刘张朋

刘张朋发表于 2013-7-9 08:39
可能是贴进去的时候什么地方弄错了

我错了，以前代码在60行和61的，如果直接按enter和输入字母不是按我想的那样执行的，下面是修改后的代码：

package com.itheima;

import java.io.*;

import java.util.ArrayList;

import java.util.Random;

/*思路：

* 第二题：求出1-100之间的素数，假设有n个，将这些素数存入a[n+1]的数组中。（其中n个是求出的各个素数，还有一个是随机添加其中的一个素数）

* 这样数组中就有相同的两个素数，写一个搜索算法，找出数组中相同的那个素数。（随机添加的素数，可手动指定，也可利用随机方法产生）

* 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=="") ||! (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[i] = 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不是素数，负数不考虑

for(int i=2;i*i<=num;i++){

if(num%i==0)

return false; //num有1和其本身以外的因子，故不是素数

}

return true; //num没有1和其本身以外的因子，故不是素数

}

}

复制代码

以防万一 · 以防万一

咦，我盗了太阳发表于 2013-7-8 22:32
好吧，我是第一次动脑子去想一个Java问题，虽然过程有点苦逼，但是我写出来了

虽然只有素数这个。。。。

额，，，，，，，，好吧，题错了，是第二题，，，，，忘记了

方珂 · 方珂

来做做题目~

longlangcx · longlangcx

57楼发的第三题，改了半天，最后发现原来是题目看错了，按照java命名习惯，想当然的以为是要将Demo01.java改成01Demo01.java，结果原来是反过来要将01Demo.java改01Demo01.java。

对原程序做了一些修改，代码如下：

/*
* 题目：在一个文件夹内有文件夹和文件，文件名的格式为：数字+名称.java。
* 要求：把所有的.java文件复制一份，变为文件名格式为：数字+名称+数字.java。
* （其中数字是相对应的，名称由字母组成。如：01Demo.java——>01Demo01.java)
*
* 分析：首先要获取文件夹中文件名为数字+名称.java的所有文件列表。
* 要实现此目标可以使用File.list(过滤器)方法，将目标文件夹定义为一个File对象，然后
* 设置一个过滤器类FileFilter，过滤条件为.java结尾，并且文件名中含有数字。
* 由于过滤器类仅仅创建了一个对象，并且设定的是本类的特有处理方式，不具备复用性，因此
* 可以将这个FileFilter类设置为本类的匿名内部类。
*
* 获得了要复制的文件列表之后，使用循环复制列表中的所有文件，调用改名方法将复制的目标文件名
* 改为目标值，在改名方法中，可以使用正则表达式来获取文件名开头的数字部分，将原文件名与此
* 数字部分+.java进行连接之后，即可获得新文件名。
*
* 复制文件方法中，在这里使用了文件类型兼容型更强的文件输入输出流进行复制，复制的目标文件名
* 为新文件名。
*/
import java.util.Scanner;
import java.io.File;
import java.io.FilenameFilter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
public class Test3 {
public static void main(String[] args) {
//从控制台获取文件夹的绝对路径
Scanner in = new Scanner(System.in);
System.out.print("请输入此文件夹的绝对路径，如d:/workspaces/test/src :");
String path = in.nextLine();
//将此文件夹定义为一个File对象pathFile
File pathFile = new File(path);
//将过滤器类设计为了一个实现了FilenameFilter接口的匿名内部类
//此过滤器的过滤条件为获取所有文件名必须以.java或.JAVA结尾并开头包含数字但不全为数字
//通过调用过滤器对象，将符合条件的.java文件的文件名存入一个字符串数组list中
String[] list = pathFile.list(new FilenameFilter(){
@Override
public boolean accept(File dir, String name) {
return name.matches("\\d+\\D+.*\\.java") || name.matches("\\d+\\D+.*\\.JAVA");
}
});
//遍历java文件清单，将其中的所有.java文件改名复制到同一个文件夹中。
//copyFile为自定义的赋值单个文件的方法。
//改名过程调用了自定义的getNewName方法。
//如设定的文件夹不存在，则list为null，捕获空指针异常，并给出提示。
try{
for(String s : list){
String fullPath = path + "/" + s;
copyFile(fullPath, path + "/" + getNewName(s));
}
}catch(NullPointerException e){
System.out.println("输入的文件夹路径有误！");
}
}
/**
* 此方法用于将指定的字符串结尾处的数字连接到原文件名的开始，生成新的字符串
* @param name 要处理的原字符串
* @return 返回处理后的字符串
*/
private static String getNewName(String name){
//获取文件名中的数字
String[] numArr = name.split("\\D+");
//去除文件名中的java后缀
String[] strArr = name.split("\\.java|\\.JAVA");
//strArr[0]为去除后缀的文件名，numArr[0]为文件名开头的数字，最后再加上.java后缀
return strArr[0] + numArr[0] + ".java";
}
/**
* 此方法用于复制单个文件
* @param oldPath 原文件路径
* @param newPath 复制后路径
*/
public static void copyFile(String oldPath, String newPath) {
try {
File newFile = new File(newPath);
if(newFile.exists()){
System.out.println(newPath + "已存在，跳过复制");
return;
}
//设置文件输入输出流
FileInputStream in = new FileInputStream(oldPath);
FileOutputStream out = new FileOutputStream(newPath);
//1kb的byte数组
byte[] buffer = new byte[1024];
//循环读取数据，直至读空位置
while ( (in.read(buffer)) != -1) {
out.write(buffer);
}
//关闭流
out.close();
in.close();
}catch (Exception e) {
System.out.println("复制文件过程中出错");
e.printStackTrace();
}
}
}

复制代码

修改的地方：
1. 过滤器肯定是要改的，过滤条件改成了数字开头且不全为数字的.java或.JAVA文件。之前报数组越界应该是因为题目看错所以没考虑数字开头的java文件。
2.复制时添加了捕获空指针异常，这样在用户的文件夹路径输入错误时可以给出提示。
3.获取新名字的方法相应的也要改正，将文件名去除后缀 + 文件名开头的数字 + .java后缀。
4.在文件复制的方法中，添加了文件存在判断，当改名后的文件存在时跳过复制并给出提示，否则就把复制的内容添加到这个已存在文件的后面去了。

杨彬 · 杨彬

技术分啊

星仔子 · 星仔子

瞅瞅啊，膜拜，学习，提高，练习。

方珂 · 方珂

第一题：

import java.util.Scanner;
import java.util.Vector;
public class Decomposition {
public static void main(String[] args) {
System.out.println("请输入一个正整数:");
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
//我们首先要得到输入的正整数以内的所有质数
Vector<Integer> v = new Vector<Integer>();
Lab:for(int i=2;i<=num;i++)
{
for(int j =2;j<=i/2;j++)
{
if(i%j==0&&i!=2)//如果i能被整除，继续循环
{
continue Lab;
}
}
v.add(i);//如果能正常完成内层for循环，说明i是质数。
}
System.out.println("分解结果是：");
boolean flag =true;
for(int k=0;k<v.size();k++)
{
int z =(int)v.get(k);
if(num<z)
break;
if(num%z==0)//如果能被整除，说明z是num的一个质因数。
{
if (flag == true){
System.out.print(num+"="+z);
flag = false;
}
else{
System.out.print("*"+z);
}
k--;//因为有可能num还能被z整除，所以重新执行一遍.
num=num/z;
}
}
sc.close();
}
}

复制代码

运行结果：

第二题：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class Prime {
public static void main(String[] args) {
//获取100以内的素数
List<Integer> list = new ArrayList<Integer>();
Lab:for(int i=2;i<=100;i++)
{
for(int j =2;j<=i/2;j++)
{
if(i%j==0&&i!=2)//如果i能被整除，继续循环
{
continue Lab;
}
}
list.add(i);//如果能正常完成内层for循环，说明i是质数。
}
//无序化得到的素数List，存入数组，并随机生成一个相同的素数
int number = list.size();
int[] primes = new int[number + 1];
int random = (int) (Math.random() * number);
primes[random] = list.get(random);
for (int i = 0; i < number + 1; i++) {
if (i != random) {
int index = (int) (Math.random() * list.size());
primes[i] = list.get(index);
list.remove(index);
}
}
//寻找相同的素数
Map<Integer, Integer> map = new HashMap<Integer, Integer>();
for (int i = 0; i < primes.length; i++) {
if (map.put(primes[i], i) != null) {
System.out.println("相同的素数是" + primes[i]);
break;
}
}
}
}

复制代码

运行结果：

第三题：

import java.io.File;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class FileCopy {
public static void main(String[] args) throws IOException
{
try
{
String filePath = "d:/java/demo/";
File inFile = new File(filePath);
File[] files = inFile.listFiles();//列出当前路径下所有文件
for(int i = 0; i < files.length; i++)
{
File file = files[i];
if(file != null && file.isFile())//如果是文件且不为空
{
String fileName = file.getName();//获得文件名
//修改文件名
if("java".equalsIgnoreCase(fileName.substring(fileName.indexOf(".")+1)))
{
char ch[] = fileName.toCharArray();
int end = 0;
for(int j = 0; j < ch.length; j++)
if(ch[j] < '0' || ch[j] > '9')
{
end = j;
j = ch.length;
}
String newFileName = fileName.replace(".", fileName.substring(0,end)+".");//重新命名文件
//复制文件
BufferedReader br = new BufferedReader(new FileReader(file));
File outFile = new File(filePath + newFileName);
BufferedWriter bw = new BufferedWriter(new FileWriter(outFile));
char buf[] = new char[1024];
int len = 0;
while((len = br.read(buf)) != -1)
bw.write(buf, 0, len);
bw.close();
br.close();
}
}
}
} catch (Exception e)
{
e.printStackTrace();
}
}
}

复制代码

运行结果：

急求技术分，希望版主酌情给分，谢谢。

董延京 · 董延京

来晚了哦

陈昊 · 陈昊

import java.util.Scanner;
public class FenJie{
public static void main(String[] args){
System.out.println("请输入一个正整数：");
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int a=2;
if(n<1){//当n小于1的时候，数字不能分解。
System.out.println("被分解数无效，请重新输入");
return;
}
if(n==a){//当分解数为a时，分解的因数为1与他本身相乘。
System.out.println(n+"="+"1*"+n);
}
if(n>a){//当n>a时，打印分解数n=;
System.out.print(n+"=1");
while(n>=a){
if(n%a==0){
n=n/a;//当n%a余数为0，且n/a为它本身的时候打印出*和a的值
System.out.print("*"+a);
}
else{
a=a+1;//a+1的值赋值给a.
}
}
}
System.out.println("");
}
}

复制代码

风乐 · 风乐

看一看，瞧一瞧

一木榜公 · 一木榜公

本帖最后由一木榜公于 2013-7-9 20:46 编辑

2、求出1-100之间的素数，假设有n个，将这些素数存入a[n+1]的数组中。
（其中n个是求出的各个素数，还有一个是随机添加其中的一个素数）
 这样数组中就有相同的两个素数，写一个搜索算法，找出数组中相同的那个素数。
（随机添加的素数，可手动指定，也可利用随机方法产生）
 (注：存入数组后，数组中的所有元素理论上是无序的，相同的那个素数不一定就等于a[n]，而是被存入了数组中的某个角标上)

/*
思路：
1，找出1——100的素数，存入一个数组中
（1），计数器思想，计算素数的个数，接着可以定义数组
（2），将素数随机存入数组
2，在这些素数中随机取一个，放入数组，位置不确定
（1）遍历数组找到，数组元素为0的位置
（2）将随机产生的素数放入该位置
3，搜索出两个相同素数，和在数组中的位置
用折半查找相同的素数。

*/
import java.util.Random; //int nextInt();

class TestDemo2
{
 /*
 ** 判断一个整数是否是素数
 */
 public static boolean isSuShu(int num)
 {
 //小于1的整数不是素数
 if( num <=1 )
 return false;

 //能被小于num/2的数整除不是素数
 for(int x = 2; x <= num/2; x++ )
 {
 if( num % x == 0 )
 return false;
 }

 return true;
 }

 /*
 ** 求 1到某个整数之间的素数的总数
 */
 public static int countSuShu(int num)
 {
 int count = 0;
 for(int x =2; x <num; x++)
 {
 if(isSuShu(x))
 count++;
 }

 return count;
 }

 /*
 ** 将一个非0整数随机存入一个整型数组
 */
 public static void saveIntToArray(int[] arr, int num)
 {
 Random rand = new Random(); //能够随机产生一个数的对象

 int len = arr.length;
 int p = rand.nextInt(len); //能够产生0~arr.length-1的整数
 //将一个非0整数存入数组
 while(true)
 {
 if(arr[p] != 0)
 p = rand.nextInt(len);
 else
 {
 arr[p] = num;
 return;
 }
 }
 }
 /*
 ** 遍历数组
 */
 public static void printArray(int[] arr)
 {
 System.out.print("[ ");
 for(int x = 0; x < arr.length; x++ )
 {
 if(x != arr.length-1)
 System.out.print(arr[x]+" ");
 else
 System.out.println(arr[x]+" ]");
 }
 }

 /*
 ** 折半查找，从角标为i的位置开始查找
 */
 public static int halfSearch(int[] arr,int i,int key)
 {
 int min=i, max=arr.length-1, mid=(min+max)/2;
 while(min<=max)
 {
 if(key == arr[mid])
 return mid;
 else if(key > arr[mid])
 min = mid + 1;
 else
 max = mid - 1;
 mid=(min+max)/2;
 }
 return -1;
 }

 /*
 ** 打印数组中相同的元素
 */
 public static void printSame(int[] arr)
 {
 for(int x = 0; x < arr.length; x++)
 {
 int p = halfSearch(arr, x+1, arr[x]);
 if(p!= -1)
 System.out.println("数组中第"+(p+1)+"个元素和第"+(x+1)+"个元素相同为："+arr[x]);

 }

 }

 public static void main(String[] args)
 {

 int n = countSuShu(100); //计算素数的个数

 int[] arr = new int[n+1]; // 定义数组

 for(int x=2;x<100; x++) //找出1——100之间的素数，随机存入一个数组中
 {
 if(isSuShu(x))
 saveIntToArray(arr,x);
 }

 Random r =new Random();
 for(int y = 0; y < arr.length; y++) //将随机产生的素数放入数组元素为0的位置
 {
 if(arr[y]==0)
 {
 int p = r.nextInt(arr.length);
 while(p == y)
 {
 p = r.nextInt(arr.length);
 }
 arr[y] = arr[p];
 break;
 }
 }
 //打印数组
 printArray(arr);

 //打印数组中相同的元素
 printSame(arr);

 }
}

一木榜公 · 一木榜公

一木榜公发表于 2013-7-9 00:07
编译结果：

哥们，初学者，不容易啊，给点分吧:handshake

程序中多了个判断是否存在正整数，所以才有了“7这个正整数不存在质因数”

朱晓杰 · 朱晓杰

俺来猫一猫，顺便顶楼主

杨彬 · 杨彬

版主你好，第一题代码如下

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;/*
* 键盘录入一个正整数，将其分解质因数。如：输入30，打印出30=2*3*5
*
* 思路：键盘接收数字然后找到该数字内所有质数，再找到该质数该有的个数然后字符串拼接输出
* */
public class Test5 { public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.println("请输入一个正整数：：");
int num = in.nextInt();
//定义一个计数集合存放质因数个数
List<Integer> counts=new ArrayList<Integer>();
//定义一个质数集合存放质数
List<Integer> zhiyinshu=new ArrayList<Integer>();
StringBuilder builder=new StringBuilder();
builder.append(num+"=");
getZhiYinShu(num,counts,zhiyinshu);
int zys=0;
int count=0;
for(int i=0;i<zhiyinshu.size();i++){
//循环集合回去质数
zys=zhiyinshu.get(i);
//获取个数
count=counts.get(i);
for(int j=0;j<count-1;j++){
builder.append(zys+"*");
}
//判断结尾
if(i<zhiyinshu.size()-1){
builder.append(zys+"*");
}else{
builder.append(zys);
}
}
System.out.println("结果为：："+builder);
} // 判断一个数是否为素数
private static boolean zhiShu(int num) {
boolean b = true;
for (int i = 2; i < num; i++) {
if (num % i == 0) {
b = false; // 不是素数直接跳出
break;
}
// 如果是质数就更改标记
b = true;
}
return b;
} // 找出该正整数范围内的质因数
private static void getZhiYinShu(int num, List<Integer> counts,
List<Integer> zhiyinshu) {
for (int i = 2; i <= num; i++) {
// 判断i是不是输入的这个数的质因数
int numTemp = num;
int count = 0;
if (zhiShu(i) && (numTemp % i == 0)) {
//如果是质因数就存到质因数集合中
zhiyinshu.add(i);
//循环判断因式个数并添加到个数集合
while (numTemp % i == 0) {
count++;
numTemp = numTemp / i;
}
counts.add(count);
}
}
}}

复制代码

运行结果如图

杨彬 · 杨彬

第二题代码如下

import java.util.HashSet;
import java.util.Iterator;
import java.util.Random;
import java.util.Set;/*
* 求出1-100之间的素数，假设有n个，将这些素数存入a[n+1]的数组中。（其中n个是求出的各个素数，还有一个是随机添加其中的一个素数）
这样数组中就有相同的两个素数，写一个搜索算法，找出数组中相同的那个素数。（随机添加的素数，可手动指定，也可利用随机方法产生）
(注：存入数组后，数组中的所有元素理论上是无序的，相同的那个素数不一定就等于a[n]，而是被存入了数组中的某个角标上)思路：先定义一个HashSet集合存入100以内的所有质数，然后定义一个长度是（n+1）的数组储存Set集合中的质数
再随机生成一个数组中的素数存到数组最后位置，循环迭代数组并把数据存入一个新的Set集合中并找到与随机产生的
数重复的数字 * */
public class Test6 { public static void main(String[] args) {
int num = 100;
Set<Integer> set = getZhiYinShu(num);// 0-24
Set<Integer> set1 = new HashSet<Integer>();
System.out.print("1~100所有的质数为：：");
System.out.println(set); // 将集合中的元素添加到集合中
int[] arr = setToArray(set);// 0-25
// 定义随机数r
Random r = new Random();
// 将随机生成的角标下的数存入数组中（n+1）处
arr[arr.length - 1] = arr[r.nextInt(arr.length)];
System.out.println("随机插入的质数为：：" + arr[arr.length - 1]);
System.out.println();
for (int x = 0; x < arr.length - 1; x++) {
set1.add(arr[x]);
if (arr[x] == arr[arr.length - 1]) {
System.out.println("添加失败，数字重复：" + arr[x]);
continue;
} else {
System.out.println(arr[x] + "添加成功！");
}
}
} // 转换集合中的元素到数组中
private static int[] setToArray(Set<Integer> set) {
int[] arr = new int[set.size() + 1];// 26
Iterator<Integer> it = set.iterator();
int i = 0;
while (it.hasNext()) {
arr[i] = it.next();
i++;
}
return arr;
} // 判断一个数是否为素数
private static boolean zhiShu(int num) {
boolean b = true;
for (int i = 2; i < num; i++) {
if (num % i == 0) {
b = false; // 不是素数直接跳出
break;
}
// 如果是质数就更改标记
b = true;
}
return b;
} // 找出该正整数范围内的质因数
private static Set<Integer> getZhiYinShu(int num) { Set<Integer> set = new HashSet<Integer>();
for (int i = 2; i <= num; i++) {
if (zhiShu(i)) {
// 如果是质因数就存到质因数集合中
set.add(i);
}
}
return set;
}}

复制代码

第二题运行结果

fycrik · fycrik

看看题难不难

帐号		自动登录	找回密码
密码			加入黑马

===答题送技术分(最高9分) 第三周(已结束)===

评分

评分

评分

评分

评分

评分

评分

评分

浏览过的版块

黑马骑士勋章