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

朱晓杰 · 朱晓杰

俺来猫一猫，顺便顶楼主

杨彬 · 杨彬

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

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

看看题难不难

一木榜公 · 一木榜公

一木榜公发表于 2013-7-9 20:40
2、求出1-100之间的素数，假设有n个，将这些素数存入a[n+1]的数组中。
（其中n个是求出的各个素数，还有一 ...

白天看视频，晚上做题所以有点赶……呵呵

左耳的鱼 · 左耳的鱼

回复看题，回复才能看到题。

杨彬 · 杨彬

本帖最后由杨彬于 2013-7-10 12:13 编辑

第三题代码如下

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;/*
* 在一个文件夹内有文件夹和文件，文件名的格式为：数字+名称.java。
要求：把所有的.java文件复制一份，变为文件名格式为：数字+名称+数字.java。
（其中数字是相对应的，名称由字母组成。如：01Demo.java——>01Demo01.java)
* */
public class Test7 { public static void main(String[] args) {
File oldFileDir = new File("F:\\aaa"); // 源文件文件夹对象
File newFileDir = new File("F:\\ccc"); // 目标文件夹对象 //所有文件名称路径
List<File> javaFileList = new ArrayList<File>();
getFiles(oldFileDir, javaFileList);
//所有新文件名称路径
List<File> listNewName=new ArrayList<File>();
nameSplit(javaFileList, listNewName, newFileDir);
// for(int i=0;i<listNewName.size();i++)
// System.out.println(listNewName.get(i)+"****"+ javaFileList.get(i));
//复制文件
copyFileList(javaFileList, listNewName);
}
//复制多个文件
private static void copyFileList(List<File> oldFileList,
List<File> newFileList) {
for(int i =0; i< oldFileList.size(); i++){
//调用复制文件方法
copyFile(oldFileList.get(i), newFileList.get(i));
}
}
//复制单个文件
private static void copyFile(File oldFile, File newFile) {
BufferedReader bufr =null;
BufferedWriter bufw =null;
try {
//因为我要复制的文件编码为本地编码（GBK），防止乱码
bufr =new BufferedReader(new InputStreamReader(new FileInputStream(oldFile), "GBK"));
bufw =new BufferedWriter(new FileWriter(newFile));
String line =null;
while((line =bufr.readLine()) !=null){
bufw.write(line);
bufw.newLine();
bufw.flush();
}
} catch (Exception e) {
System.out.println(e.toString());
} finally{
try{
if(bufr !=null)
bufr.close();
}catch(IOException e){
System.out.println(e.toString());
}
try{
if(bufw !=null)
bufw.close();
}catch(IOException e){
System.out.println(e.toString());
}
}
}
//获取新生成文件路径名称
private static void nameSplit(List<File> files,List<File> listNewName, File newFileDir) {
String ss=null;
for (int i = 0; i < files.size(); i++) {
String s = files.get(i).getName();
char[] arr = s.toCharArray();
int index = 0;
for (int j = 0; j < arr.length; j++) {
//判断英文字母位置角标
if (arr[j] >= 'a' && arr[j] <= 'z' || arr[j] >= 'A'
&& arr[j] <= 'Z') {
index = j;
break;
}
}
//截取.java前的文件名称
String[] arrs = s.split("\\.");
//拼接字符串生成新文件名称
ss=arrs[0]+s.substring(0, index)+"."+arrs[1];
//装成File对象，添加到新名称集合中封
listNewName.add(new File(newFileDir, ss));
}
} //该方法用来获取所有文件夹下所有的文件
private static void getFiles(File oldFileDir, List<File> javaFileList) { File[] fileDirs = oldFileDir.listFiles();
for (int i = 0; i < fileDirs.length; i++) {
//如果是目录递归调用该方法获取所有文件
if (fileDirs[i].isDirectory()) {
getFiles(fileDirs[i], javaFileList);
} else {
//判断文件是否以.java结尾
if(fileDirs[i].getName().endsWith(".java"))
javaFileList.add(fileDirs[i]);
}
}
}

复制代码

运行结果如图

星仔子 · 星仔子

<div class="blockcode"><blockquote>第三题：package test;
/*
3、在一个文件夹内有文件夹和文件，文件名的格式为：数字+名称.java。
要求：把所有的.java文件复制一份，变为文件名格式为：数字+名称+数字.java。
（其中数字是相对应的，名称由字母组成。如：01Demo.java——>01Demo01.java)
*/
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;
public class Test_three {
public static void main(String[] args) {
File file =new File("C:\\test1");
File file1 =new File("C:\\testCopy");
String fileName ="(0\\d+)(Demo)(\\.java)";
List<File> lists =new ArrayList<File>();
//递归生成
getLists(file,lists,fileName);
for(File files: lists){
String newFileName = files.getName().replaceAll(fileName, "$1$2$1$3");
File dJavaFile =new File(file1, newFileName);
System.out.println("原文件名为："+files.toString()+"-----新文件名："+ dJavaFile);
copyFile(files, dJavaFile);
}
}
//递归生成
private static void getLists(File file,
List<File> FileList, String fileName) {
File[] files =file.listFiles();
for(int x =0; x <files.length; x++){
if(files[x].isDirectory())
getLists(files[x], FileList, fileName);
else{
String oldName =files[x].getName();
if(oldName.matches(fileName)){
FileList.add(files[x]);
}
}
}
}
private static void copyFile(File sourceFile, File dJavaFile) {
BufferedReader bufr =null;
BufferedWriter bufw =null;
try {
bufr =new BufferedReader(new FileReader(sourceFile));
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
bufw =new BufferedWriter(new FileWriter(dJavaFile));
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
String count =null;
System.out.println(sourceFile);
try {
while((count =bufr.readLine()) !=null){
bufw.write(count);
bufw.newLine();
bufw.flush();
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

复制代码

第一题：
package test;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Test_one {

public static void main(String[] args) {
Scanner in=new Scanner(System.in);
System.out.println("请输入一个正整数：");
int number=in.nextInt();

List<Integer> primes =new ArrayList<Integer>();
for(int i=2; i<=number; i++){
//如果是质数并且能被传入的整数number整除那么这个数i一定是number的一个质因数
if(isPrime(i)&&(number%i ==0))
primes.add(i);
}

List<Integer> pDetails =new ArrayList<Integer>();

for(int x =0; x <primes.size(); x++){
int pCount =0;
int f =primes.get(x);
int munTemp =number;
while(munTemp%f ==0){
pCount++;
munTemp =munTemp/f;
}
pDetails.add(pCount);
}

//分解结果
StringBuilder sBuilder =new StringBuilder();
sBuilder.append(number+"=");

int primeFactor =0;
int pCount =0;

for(int i =0; i<primes.size(); i++){
primeFactor =primes.get(i);
pCount =pDetails.get(i);

for(int j =0; j<pCount -1; j++)
sBuilder.append(primeFactor+"*");

if(i <pDetails.size()-1)
sBuilder.append(primeFactor+"*");
else
sBuilder.append(primeFactor);
}

System.out.println("质因数分解结果:"+ sBuilder.toString());
}

// 判断素数
private static boolean isPrime(int num) {
boolean flag = true;

for (int i = 2; i < num; i++) {
if (num % i == 0) {
flag = false;
break;
}
flag = true;
}
return flag;
}
}

第二题：package test;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.Set;
public class Test_two {
public static void main(String[] args) {
int sum = 100;
List<Integer> primes = new ArrayList<Integer>();
for (int i = 2; i <= 100; i++) {
if(isPrime(i))
primes.add(i);
}
System.out.println(primes);
//将重复数字插入指定位置
int[] primeArr =new int[primes.size() +1];
for(int i=0; i <primes.size(); i++){
primeArr[i] =primes.get(i);
}
int randomPrime =primeArr[new Random().nextInt(primes.size())];
int randomIndex =new Random().nextInt(primes.size());
for(int x= primeArr.length-2; x>= randomIndex; x--){
primeArr[x+1] =primeArr[x];
}
primeArr[randomIndex] =randomPrime;
int repeatedPrime =checkRepeat(primeArr);
System.out.println("重复的数字是:"+ repeatedPrime);
}
//判断素数
private static boolean isPrime(int num) {
boolean flag = true;
for (int i = 2; i < num; i++) {
if (num % i == 0) {
flag = false;
break;
}
flag = true;
}
return flag;
}
//检测重复加入的数字
private static int checkRepeat(int[] primesArr) {
Set<Integer> assistSet =new HashSet<Integer>();
int repeatedNum =0;
for(int element: primesArr){
boolean flag =assistSet.add(element);
if(flag)
System.out.print(element+" ");
else{
System.out.println(" ..."+ element+"重复...");
repeatedNum =element;
break;
}
}
return repeatedNum;
}
}

复制代码

李永康 · 李永康

看看看看看看看看看看看看看看

chslzj · chslzj

做完入学考试来看看

liguangcaiup · liguangcaiup

看看练习下

liguangcaiup · liguangcaiup

本帖最后由 liguangcaiup 于 2013-7-11 09:53 编辑

第一题

public class test1 {
// 1、键盘录入一个正整数，将其分解质因数。如：输入30，打印出30=2*3*5。
public static void main(String[] args) throws Exception {
// 接受一个正整数
Scanner in = new Scanner(System.in);
int num = in.nextInt();
if (isPrime(num)) { // 若num是素数直接输出结果
System.out.println(num + "=" + 1 + "*" + num);
return;
}
System.out.print(num + "=");
for (int i = 2; i <= num; i++) {
if (isPrime(i)) { // 是素数时继续
if (0 == num % i) {
while (true) { // 此循环处理连续质因数问题
System.out.print(i);
num /= i;
if (num != 1)
System.out.print("*");
if (num % i != 0) // 若不能被i整除是否有连续的质因数如：4=2*2
break;
}
}
}
}
}
public static boolean isPrime(int num) { // 判断是否素数
if (1 == num)
return false;
if (2 == num)
return true;
double n = Math.sqrt(num);
for (int i = 2; i <= n; i++) {
if (0 == num % i)
return false;
}
return true;
}
}

复制代码

运行结果：
1000
1000=2*2*2*5*5*5
30
30=2*3*5

第二题：

import java.util.ArrayList;
import java.util.Random;
public class test2 {
/*
* 求出1-100之间的素数，假设有n个，将这些素数存入a[n+1]的数组中。（其中n个是求出的各个素数，还有一个是随机添加其中的一个素数）
* 这样数组中就有相同的两个素数，写一个搜索算法，找出数组中相同的那个素数。（随机添加的素数，可手动指定，也可利用随机方法产生）
* (注：存入数组后，数组中的所有元素理论上是无序的，相同的那个素数不一定就等于a[n]，而是被存入了数组中的某个角标上)
*/
public static void main(String[] args) {
ArrayList<Integer> arrayList = new ArrayList<Integer>();
Random r = new Random();
for (int i = 1; i <= 100; i++) { // 记录100以内的素数
if (isPrime(i))
arrayList.add(i);
}
//输出arrayList 中记录的素数
System.out.println("arrayList 中记录的素数：：");
for (int i = 0,flag=0; i < arrayList.size(); i++) {
System.out.print(arrayList.get(i)+" ");
flag++;
if(flag==10){
System.out.println();
flag=0;
}
}
// 把记录无序的存入数组中
int length = arrayList.size();
int[] nums = new int[length+1];
int n,index;
for (int i = 0; i < length; i++) {
n = arrayList.size();
if(0==n) //数据已经全部随机加入int[]
break;
index = r.nextInt(n);
nums[i] = arrayList.get(index);
arrayList.remove(index);
}
//产生一个随机素数，并加入最后位置
int randomNum = r.nextInt(length);
nums[length] = nums[randomNum];
//输出"无序存入int[],并加入最后一个随机素数后的数据
System.out.println();
System.out.println("无序存入int[],并加入最后一个素数后的数据：：");
for (int i = 0,flag=0; i <length+1; i++) {
System.out.print(nums[i]+" ");
flag++;
if(flag==10){
System.out.println();
flag=0;
}
}
//找出与最后一个素数相同的元素下标
for (int i = 0; i < length; i++) {
if(nums[length]==nums[i]){
System.out.println();
System.out.println("与最后一个素数位置相同的元素下标：："+i);
}
}
}
public static boolean isPrime(int num) { // 判断是否素数
if (1 == num)
return false;
if (2 == num)
return true;
double n = Math.sqrt(num);
for (int i = 2; i <= n; i++) {
if (0 == num % i)
return false;
}
return true;
}
}

复制代码

运行结果：
arrayList 中记录的素数：：
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
无序存入int[],并加入最后一个随机素数后的数据：：
11  37  3  2  23  31  7  61  79  13
89  17  73  19  71  53  67  59  41  5
97  83  29  43  47  31
与最后一个素数位置相同的元素下标：：5

第三题：

复制代码

package test;
import java.io.*;
import java.util.ArrayList;
public class test3 {
/*
* 3、在一个文件夹内有文件夹和文件，文件名的格式为：数字+名称.java。
* 要求：把所有的.java文件复制一份，变为文件名格式为：数字+名称+数字.java。
* （其中数字是相对应的，名称由字母组成。如：01Demo.java——>01Demo01.java)
*/
public static void main(String[] args) throws IOException {
File file = new File("f://day24");
File file2 = new File("e:");
copyDir(file, file2);
}
// 复制文件夹
static void copyDir(File srcDir, File desDir) throws IOException {
File dir = new File(desDir, srcDir.getName()); // 先创建文件夹
System.out.println(dir + " 复制结果::" + dir.mkdir()); //输出文件夹拷贝成功与否
File[] files = srcDir.listFiles();
for (int i = 0; i < files.length; i++) {
if (files[i].isDirectory()) //如果是文件夹递归调用copyDir
copyDir(files[i], dir);
else {
if (files[i].getName().endsWith(".java")) { //如果是.java文件调用copyFile
File tfile = new File(dir,setFileName(files[i].getName()));
copyFile(files[i], tfile);
}
}
}
}
//处理文件名 01Demo.java——>01Demo01.java
public static String setFileName(String oldName){
ArrayList<Character> num = new ArrayList<Character>();
String[] str = oldName.split("\\.");
char[] name = str[0].toCharArray();
for (int i = 0; i < name.length; i++) { //得到名字中的前导数字
if(name[i]>='0'&&name[i]<='9')
num.add(name[i]);
else
break;
}
String strNum="";
for(char ch: num) //前导数字存入strNum
strNum+=ch;
return str[0]+strNum+".java";
}
// 复制文件
static void copyFile(File srcFile, File desFile) throws IOException {
BufferedInputStream bufis = null;
BufferedOutputStream bufos = null;
try {
//文件复制用到的流
bufis = new BufferedInputStream(new FileInputStream(srcFile));
bufos = new BufferedOutputStream(new FileOutputStream(desFile));
byte[] buf = new byte[1024 * 4];
int len;
//复制文件
while ((len = bufis.read(buf)) != -1) {
bufos.write(buf, 0, len);
bufos.flush();
}
//输出复制的成功与否
System.out.println(srcFile + " 复制结果::ture");
} catch (IOException e) {
throw e;
} finally {
bufos.close();
bufis.close();
}
}
}

复制代码

运行结果：
字数超过限制了, 控制台结果在第五张图片

yangchao313 · yangchao313

看看题自己会多少

一川 · 一川

来瞅瞅:)。。。。

chslzj · chslzj

第一次回复是7月10号18:05，第110楼
第一题答案

/**
*
*/
package com.itheima.test;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
/**
* @author Administrator
*
*/
public class Test1 {
//判断是否为素数
private static boolean isprime(int i) {
for(int j=2;j<=i/2;j++)
if(i%j==0)
return false;
return true;
}
public static void main(String[] args) throws Exception {
//从键盘中获取值
BufferedReader bReader=new BufferedReader(new InputStreamReader(System.in));
System.out.println("请输入正整数:");
int unknown=0;
try{
String str=bReader.readLine();
unknown=Integer.valueOf(str);
}catch (Exception e) {
//处理输入错误异常
System.out.println("输入的数未能辨识，程序退出");
System.exit(0);
}
resolve(unknown);
}
public static void resolve(int unknown){
if(isprime(unknown)){
//如果该数为素数，就没有质因分解
System.out.println("该数字为素数！");
}
else{
List<Integer> list=primes(unknown);
System.out.print(unknown+"=");
//循环素数表
for(int i=0;list.get(i)*list.get(i)<=unknown;i++)
{
//如果该数字能被一个素数整除
if(unknown%list.get(i)==0)
{
System.out.print(list.get(i)+"*");
//重新定义unknown
unknown=unknown/list.get(i);
//重新循环素数列表
i=-1;
}
//如果结果已经是素数了，说明运算完毕，打印最后一个素数，结束
if(isprime(unknown)){
System.out.println(unknown);
return;
}
}
}
}
//得到小于number的素数
public static List<Integer> primes(int number){
List<Integer> list=new ArrayList<Integer>();
if(number>2)
list.add(2);
for(int i=3;i<number;i+=2)
if(isprime(i))
list.add(i);
return list;
}
}

复制代码

第二题答案

/**
*
*/
package com.itheima.test;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.Set;
/**
* @author Administrator
*
*/
public class Test2 {
//得到小于number的素数
public static List<Integer> primes(int number){
List<Integer> list=new ArrayList<Integer>();
if(number>2)
list.add(2);
for(int i=3;i<number;i+=2)
if(isprime(i))
list.add(i);
return list;
}
//判断是否为素数
private static boolean isprime(int i) {
for(int j=2;j<=i/2;j++)
if(i%j==0)
return false;
return true;
}
//找到相同的元素
public static Integer findSamePrime(int[] primes){
//依次往Set里面加，因为set里面不能出现重复的元素，所以添加重复的元素会失败，根据这一特性，完成查找相同的元素
Set<Integer> set=new HashSet<Integer>();
for(int prime:primes)
if(!set.add(prime))
return prime;
return null;
}
public static void main(String[] args) {
//先找到100以内的素数
List<Integer> list=primes(100);
//随机找到一个位置，再随机找到一个元素，完成一个n+1 的list
int position =(new Random().nextInt(list.size()));
list.add(position, list.get(new Random().nextInt(list.size())));
myToString(list);
//将数据转移到array数组中
int[] primes=new int[list.size()];
for(int i=0;i<primes.length;i++)
primes[i]=list.get(i);
///通过findSamePrime方法找到相同的元素
System.out.println("重复的素数是"+findSamePrime(primes));
}
///打印找到的素数
public static void myToString(List<Integer> list)
{
StringBuffer stringBuffer=new StringBuffer();
stringBuffer.append("{");
for(Integer i:list)
stringBuffer.append(i+",");
stringBuffer.deleteCharAt(stringBuffer.length()-1);
stringBuffer.append("}");
System.out.println(stringBuffer.toString());
}
}

复制代码

第三题答案

/**
*
*/
package com.itheima.test;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* @author Administrator
*
*/
public class Test3 {
public static void main(String[] args) throws Exception {
File file=new File("D:/src");
copyAndRenameFile(file);
}
public static void copyAndRenameFile(File currentfile) throws Exception{
//判断是否为文件夹
if(currentfile.isDirectory())
{
//是文件夹则对里面的文件递归使用copyAndRenameFile方法
File[] files=currentfile.listFiles();
for(File file:files)
copyAndRenameFile(file);
}else if(currentfile.isFile())
{
//如果是文件，则对文件名进行判断
String filename=currentfile.getName();
//使用pattern和matcher进行文件名，如果匹配，就进行复制操作
Pattern pattern=Pattern.compile("^([0-9]{1,})([a-zA-Z]{1,}).(java)$");
Matcher matcher= pattern.matcher(filename);
if(matcher.matches()){
String filepath=currentfile.getPath();
filepath=filepath.substring(0, filepath.lastIndexOf("\\")+1);
//生成新的文件名
filepath=filepath+matcher.group(1)+matcher.group(2)+matcher.group(1)+".java";
//定义输入输出流
OutputStream ops=new FileOutputStream(filepath);
InputStream ips=new FileInputStream(currentfile);
byte[] datas=new byte[1024];
int b=-1;
while((b=ips.read(datas))!=-1){
ops.write(datas,0,b);
/* 如果使用下面的语句，文件里面就会出现很多null 因为datas没有填充完全
* ops.write(datas);
* */
}
//关闭流
ops.close();
ips.close();
}
}
}
}

复制代码

朱晓杰 · 朱晓杰

本帖最后由朱晓杰于 2013-7-12 17:15 编辑

/**
* 题目1、键盘录入一个正整数，将其分解质因数。如：输入30，打印出30=2*3*5。
*
* 分析：该题的目的是将任意一个正整数分解质因数，涉及到了数学知识，要想完全弄明白，必须清楚涉及到的几个知识
*
* 知识1、什么是分解质因数?
* 每个合数都可以写成几个质数相乘的形式，其中每个指数都是这个合数的因数，叫做这个合数的分解质因数。
* 注意：分解质因数只针对合数。
*
* 分解质因数的概念我们清楚了，那么什么是合数，什么是质数呢？
*
* 知识2、合数：自然数中除了能被1和本身整除外，还能被其他的数整除
*
* 质数：自然数中除了能被1和本身整除外，不能被其他的数整除
*
* 结果: 合数 = 质数 * 质数 * 质数 ...，这个过程就叫做分解质因数
*
* 那么如何在程序中体现呢？
*
* 根据以上概念，键盘录入的正整数 x 是有限制的，必须是大于1的合数，那么我们就需要进行判读，问题随之就来了
*
* 如何判断一个正整数是否为合数？
*
* 将该循环对处于 1~x 之间的正整数取余
*
* 如果是
* 若能被整除，则返回该被除数
*
* 如果不是
* 提示用户输入了非法值
* 思路：1.接收键盘录入的数据
*
* 2.判断接收的数据是否为合数
*
* 3.返回结果
*
*/
import static java.lang.System.*;
import java.util.Scanner;
public class PrimeFactors {
public static void main(String[] args) {
out.println("/********** 程序功能：分解质因数 **********/");
out.println("/********** 提示：请输入一个合数！ **********/");
//获取键盘录入的正整数
Scanner scan = new Scanner(in);
int receVal = scan.nextInt();
//判断该正整数是否为合数
boolean isComNum = isCompositeNum(receVal);
if(isComNum){
out.println(receVal + "=" + getPFRes(receVal) + ";");
}else
out.println(receVal + " 不是合数！");
}
/**
* @功能：获取一个合数分解质因数的结果
* @param:receVal
* @return:String,例如：30=2*3*5;
* */
public static String getPFRes(int receVal){
StringBuilder resStr = new StringBuilder();
for(int i = 2; i < receVal - 1; i++){
if(receVal % i == 0 && isPrimeNum(i)){
receVal = receVal / i;
//如果是resNum是素数，则直接返回 i * resNum,程序结束，否则继续循环，递归
resStr.append(i).append("*");
if(isPrimeNum(receVal)){
resStr.append(receVal);
}else{
resStr.append(getPFRes(receVal));
}
break;
}
}
return resStr.toString();
}
/**
* @功能：判断一个数是否为4数
* @param:receVal
* @return:boolean
* */
public static boolean isCompositeNum(int receVal){
boolean flag = false;
if(receVal < 1)
flag = false;
else{
for(int i = 2; i < receVal; i++){
if(receVal % i == 0){
flag = true;
break;
}
}
}
return flag;
}
/**
* @功能：判断一个正整数是否为质数(素数)
* @param:num
* @return:boolean
* */
public static boolean isPrimeNum(int num){
boolean flag = true;
for(int i = num - 1; i > 1; i--){
if(num % i == 0){
flag = false;
break;
}
}
return flag;
}
}

复制代码

/**
* 题目2、求出1-100之间的素数，假设有n个，将这些素数存入a[n+1]的数组中, 其中n个是求出的各个素数，还有一个是随机添加其中的一个素数
* 这样数组中就有相同的两个素数，写一个搜索算法，找出数组中相同的那个素数。（随机添加的素数，可手动指定，也可利用随机方法产生）
* (注：存入数组后，数组中的所有元素理论上是无序的，相同的那个素数不一定就等于a[n]，而是被存入了数组中的某个角标上)
*
* 分析： 1、找出1-100之间的素数，并存入数组；
* 2、产生你找出素数中随机的一个，也存入数组，位置不确定；
* 3、找出数组中相同的那个素数。
*
* 问题：1.什么是素数？由于1-100间的素数的个数不确定，所以数组如何定义?
*
* 2.随机素数如何产生？手动？随机数？
*
* 3.如何搜索相同的那个素数？且保证程序效率高
* 查找相同的那个素数，可以用遍历数组的方法，可是效率有点儿低，需要遍历所有数组，那么折半查找呢？
*
*/
import java.util.*;
public class SearchPrime {
public static void main(String[] args) {
int maxNum = 100,primeNum = 17;
Integer[] primeArrays = getPrimeArrays(maxNum,primeNum);
Arrays.sort(primeArrays);
int index = Arrays.binarySearch(primeArrays, primeNum);
System.out.println("数组中与 " + primeNum + " 相同的素数的位置是：primeArrays[" + index + "]=" + primeArrays[index]);
}
/**
* @功能：求出1-100间的素数,手动指定一个素数，并将求出的素数与指定的素数存入数组
* @params:maxNum,primeNum
* @return:Integer[]
* */
public static Integer[] getPrimeArrays(int maxNum,int primeNum){
Integer[] primeArrays = null;
int count = 0;
Collection<Integer> collect = new ArrayList<Integer>();
for(int i = 2; i < maxNum; i++){
//判断一个数是否为素数
if(isPrimeNum(i)){
collect.add(i);
count++;
}
}
collect.add(primeNum);
primeArrays = collect.toArray(new Integer[count+1]);
return primeArrays;
}
/**
* @功能：判断一个正整数是否为质数(素数)
* @param:num
* @return:boolean
* */
public static boolean isPrimeNum(int num){
boolean flag = true;
for(int i = num - 1; i > 1; i--){
if(num % i == 0){
flag = false;
break;
}
}
return flag;
}
}

复制代码

import static java.lang.System.out;
import java.io.*;
/**
* 题目3. 背景:在一个文件夹内有文件夹和文件，文件名的格式为：数字+名称.java。
*
* 要求:把所有的.java文件复制一份，变为文件名格式为：数字+名称+数字.java。
* 其中数字是相对应的，名称由字母组成。如：01Demo.java——>01Demo01.java
*
* 分析:1.在一个文件夹内有文件夹和文件, 需要遍历文件夹，用到了递归
*
* 2.更改文件名，需要对文件名进行操作，用到了字符串操作
*/
public class CopyFiles {
public static void main(String[] args) {
String path = "C://java//";
File rootPath = new File(path);
if(!rootPath.exists()){
out.println(rootPath + "目录或文件不存在!");
}else if(rootPath.isFile()){
out.println(rootPath + "是一个文件!");
}else if(rootPath.isDirectory()){
try {
FileUtils(rootPath);
} catch (Exception e) {
e.printStackTrace();
}
}
}
/**
* @功能：文件操作路
* @param:rootPath
* @return:void
* */
private static void FileUtils(File rootPath)throws Exception{
File[] files = rootPath.listFiles();
for(File file : files){
if(file.isFile()){
//重命名文件
renameFiles(file);
}else if(file.isDirectory()){
//递归继续遍历
FileUtils(file);
}
}
}
/**
* @功能：重命名文件
* @param:file
* @return:void
* */
private static void renameFiles(File file) throws Exception{
//获取上级根目录
String parentPath = file.getParent() + File.separator;
//文件名
String fileName = file.getName();
//重命名后的文件名
String newFileName = "";
//重命名后的文件
File destFile = null;
if(fileName.endsWith(".java")){
fileName = fileName.substring(0,fileName.indexOf(".java"));
newFileName = fileName + fileName.substring(0,fileName.indexOf("Demo")) + ".java";
destFile = new File(parentPath + newFileName);
//复制文件
copyFile(file, destFile);
}
}
/**
* @功能：复制文件
* @param:srcFile,destFile
* @return:void
* */
private static void copyFile(File srcFile, File destFile)
throws FileNotFoundException, IOException {
BufferedReader reader = new BufferedReader(new FileReader(srcFile));
BufferedWriter writer = new BufferedWriter(new FileWriter(destFile));
String content = "";
while((content = reader.readLine()) != null){
writer.write(content);
writer.newLine();
writer.flush();
}
if(writer != null){
writer.close();
}
if(reader != null){
reader.close();
}
}
}

复制代码

在乎.. · 在乎..

我要看题！

在乎.. · 在乎..

我要再次看题

在乎.. · 在乎..

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class Demo1 {
/**
* @param args
*/
public static void main(String[] args) {
// TODO 自动生成的方法存根
int number; //定义一个number数
System.out.println("请输入一个正整数:"); //下面用异常来使确定能够输入正整数的情况
try{
Scanner sc=new Scanner(System.in);
number=sc.nextInt();
System.out.println(number+"="+Diviedzs(number));}catch(Exception e)
{
System.out.println("出错，你输入的不是一个正整数");
}
}
public static String Diviedzs (int number) //分解质因数的方法，返回一个字符串
{
String result=""; //首先定义一个空字符串。
int divider=2; //定义一个除数为2，注意2是最小的质数
if(number==1) //当输入同样是正整数1是，报错
return "抱歉,1不能分解质因数";
while(number>1) //循环直到被除数除到1为止，则跳出循环
{
if(number % divider==0) //先整除质因数2
{
result +=divider+ "*"; //如能则添加到字符串中去
number=number/divider; //得到被除数整除后的数，使能继续被整除，直到1；
}else
{
divider++; //质数加1，不会出现4，6等合数被上面判断是否整除的情况，因为2已经被整除了
}
}
return result.substring(0, result.length()-1); //最后打印的字符串末尾会有"*"，所以取前length-1位
}
}

复制代码

第二题：

import java.util.*;
public class Prime {
public static List<Integer> receive(int num){
List<Integer> list = new ArrayList<Integer>(); //定义一个list集合
list.add(2); //添加素数2
for (int i = 3; i < num; i += 2) {
boolean flag = true;
for (int j = 3; j <= (int) Math.sqrt(i); j++) { //用n除以2至到sqrt(n),有一个能除尽就不是素数，否则是素数
if (i % j == 0) {
flag = false;
break;
}
} //不是素数跳出循环
if (flag) {
list.add(i); //添加素数
}
}
return list;
}
public static void main(String[] args) {
List<Integer> list1=receive(100); //添加100以内的素数
int number = list1.size(); //获取长度
int[] primes = new int[number + 1];
int random = (int) (Math.random() * number); //在list长度值内获取一个随机数
primes[random] = list1.get(random); //将要相同的数添加到相应的的随机坐标内
for (int i = 0; i < number + 1; i++) {
if (i != random) { //判断是否到了相同数的坐标，如不是则随机添加一个list集合的数
int index = (int) (Math.random() * list1.size());
primes[i] = list1.get(index);
list1.remove(index); //删除已经添加到数组的数
}
}
System.out.println("无序数组是");
for(int i=0;i<primes.length-1;i++)
{
System.out.print(primes[i]+" ");
}
System.out.println();
Set<Integer> set = new HashSet<Integer>();
for (int i = 0; i < primes.length; i++) {
if (!set.add(primes[i])) { //因为Set不能添加相同数
System.out.println("相同的值是" + primes[i]);
break;
}
}
}
}

复制代码

第三题:

import java.io.*;
public class ChangeName {
/**
* @param args
*/
public static String newName(String fileName)
{
return null;
}
public static void main(String[] args) {
// TODO 自动生成的方法存根
try {
String filePath = "e:/test/"; // 获取文件路径
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))) // 判断是否JAVA文件
{
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) + "."); // 将其"."改为"数字."
// 则01Demo.java——>01Demo01.java
// 复制旧文件到新文件中去
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();
}
}
}

复制代码

水。。。海 · 水。。。海

再抢几分

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

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

评分

评分

评分

点评

评分

点评

评分

评分

点评

评分

点评

评分