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

liujkh123 · liujkh123

开始挑战

杨晓燕 · 杨晓燕

杨晓燕发表于 2013-7-7 20:49
oooo，有道理，收了，哈哈

:lol你苗，你太好了，怎么发现的

教皇 · 教皇

要积分，来答题，要回复。

张歆明 · 张歆明

本帖最后由张歆明于 2013-7-8 14:50 编辑

版主第二题我已经重新做了第一题和第三题没问题吧
第二题的代码：

package test2;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.Set;
/*
2、求出1-100之间的素数，假设有n个，将这些素数存入a[n+1]的数组中。
（其中n个是求出的各个素数，还有一个是随机添加其中的一个素数）
这样数组中就有相同的两个素数，写一个搜索算法，找出数组中相同的那个素数。
（随机添加的素数，可手动指定，也可利用随机方法产生）
*/
/*
* 思路：
* (1). 循环判断1-100之间哪些数是素数
* (2). 将产生的素数存入一个数组，这时候随机产生一个素数并随机产生一个索引位置通过插入的方式将这个
* 素数存入相应的随机的位置
* (3). 上面的数组除最后一个要查找的元素以外，前面所有的元素顺从大到小排过顺序的。采用折半查找即可
* */
public class Test2 {
public static void main(String[] args) {
int upBound =100;
//1.获取1-100的所有的质数
List<Integer> primes =getPrimes(upBound);
System.out.println("1-100以内的素数是："+ primes);
//2.将产生的素数存入一个数组，这时候随机产生一个素数
//并随机产生一个索引位置通过插入的方式将这个
//素数存入相应的随机的位置
int[] primesArr =toArray(primes);
System.out.println("产生的数组是: "+ Arrays.toString(primesArr));
//3.由于随机生成的数字插入的位置未知，现在要找出这个数，可以利用Set集合的属性将数组中的元素逐次添加到
//Set集合中一旦添加失败说明这个元素是重复的这样就找出了重复加入的那个素数
int repeatedPrime =detectRepeatedPrime(primesArr);
System.out.println("重复的数字是:"+ repeatedPrime);
}
//检测重复加入的数字
private static int detectRepeatedPrime(int[] primesArr) {
Set<Integer> assistSet =new HashSet<Integer>();
int repeatedNum =0;
for(int element: primesArr){
boolean flag =assistSet.add(element);
if(flag)
System.out.println(element+"添加成功...");
else{
System.out.println("**"+ element+"重复...");
//找到重复的元素就达到了目的立刻结束添加操作
repeatedNum =element;
break;
}
}
return repeatedNum;
}
//将产生的素数列表存入数组并随机重复产生一个素数存入一个随机的位置
private static int[] toArray(List<Integer> primes) {
int[] primeArr =new int[primes.size() +1]; //题目要求多一个元素
for(int x=0; x <primes.size(); x++){
primeArr[x] =primes.get(x);
}
//随机产生一个素数
int randomPrime =primeArr[new Random().nextInt(primes.size())];
System.out.println("随机产生的重复的素数是: "+ randomPrime);
//再次随机产生一个索引位置并将这个随机产生的素数存入这个随机产生的索引位置
int randomIndex =new Random().nextInt(primes.size());
System.out.println("这个随机产生的素数存放到原数组的随机位置是: "+ randomIndex);
insertIntoArray(randomPrime, randomIndex, primeArr);
return primeArr;
}
//将指定的数字存入指定的位置
private static void insertIntoArray(int num, int index,
int[] primeArr) {
//向指定数组的指定位置插入一个数字现将数组中此位置以后的数字依次向后进行移位
for(int i= primeArr.length-2; i>= index; i--){
primeArr[i+1] =primeArr[i];
}
//将指定的数字插入到指定的位置
primeArr[index] =num;
}
//获取指定范围的素数
private static List<Integer> getPrimes(int upBound) {
List<Integer> primes =new ArrayList<Integer>();
for(int i=2; i<=100; i++){
if(isPrime(i))
primes.add(i);
}
return primes;
}
//判断一个数是否为素数
private static boolean isPrime(int num){
boolean isPrime =true;
//--根据素数的定义：在一个大于1的自然数中，除了1和此整数自身外，不能被其他自然数整除的数
//--要对给定的数 i 判定除了1和自身(num)以外的整数是不是有能被i整除的
for(int i=2; i<num; i++){
if(num%i==0){ //如果能被整除整除标记isPrime标记为false 表示不是素数
isPrime =false;
//开区间(1, i)之间一旦有一个数能整除i
//--就表示i不是素数直接跳出不用继续进行判断节省计算量
break;
}
//如果(1, i)之间都没有能整出i的数出现，就表示这个数i是素数要更新isPrime
isPrime =true;
}
return isPrime;
}
}

复制代码

不好意思版主一时疏忽没有贴完整额这回完整啦您看看对不对 :)

liujkh123 · liujkh123

第一题，

package test;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class TestFactorization {
public static void main(String[] args) {
BufferedReader bfbr = new BufferedReader(new InputStreamReader(System.in));
System.out.println("请输入要分解因数的数，按回车确认");//
try {
String line = bfbr.readLine();
int num = Integer.parseInt(line);//获得输入的数
showFactorization(num);
} catch (IOException e) {
e.printStackTrace();
}catch(Exception e){
e.printStackTrace();
throw new RuntimeException("输入非法，请输入数字");
}
}
/**
* 这个函数就是用来计算质因数了
* @param num
*/
private static void showFactorization(int num) {
int n = num;
StringBuilder sb = new StringBuilder();
for(int i=2; i<=num/2; i++){
while(n%i == 0){
sb.append(i + "*");
n = n/i;
}
if(n < i) //这个判断条件可以减少循环次数，节省资源
break;
}
if(sb.length() != 0){
sb.deleteCharAt(sb.length()-1);//如果不是素数，就把多余的*给去掉
}else{
sb.append(1 +"*" + num);//如果是素数，就这样输出
}
System.out.println(sb.toString());
}
}

复制代码

输出结果
请输入要分解因数的数，按回车确认
13
1*13

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

第二题

package test;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class TestPrime {
public static void main(String[] args) {
Integer[] arr = getPrimeArr();
System.out.println("数组中相同的两个元素角标为" + getSame(arr));
}
public static Integer[] getPrimeArr(){
List<Integer> arrList = new ArrayList<Integer>();
for(int i=1; i<=100; i++){
if(isPrime(i))
arrList.add(i);
}
//这段代码简化了，就是arrList.add(int, Integer)只不过两个参数都通过随机工具来确定
arrList.add(new Random().nextInt(arrList.size()),arrList.get(new Random().nextInt(arrList.size())));
System.out.println(arrList);
return arrList.toArray(new Integer[arrList.size()]);
}
//该方法判断一个数是否为素数
public static boolean isPrime(int i){
if(i == 1||i==2||i==3)
return true;
else{
for(int j=2; j<=i/2; j++){
if(i%j == 0 ){
return false;
}
}
}
return true;
}
//这个方法可以再优化，然后寻找到拥有三个以上的相同元素的数组中相同元素的角标，这里是根据题目写的简洁版
public static String getSame(Integer[] arr){
List<Integer> arrList = new ArrayList<Integer>();
String str = null;
for(int i=0; i<arr.length; i++){
if(!arrList.contains(arr[i])){
arrList.add(arr[i]);
}else
str = arrList.indexOf(arr[i]) + "," + i;
}
return str;
}
}

复制代码

输出结果
[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

第三题

package test;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class CopyFileDemo {
public static void main(String[] args) {
File file = new File("E:\\cn");
overFile(file);
}
/**
* 遍历文件夹进行复制，题目指明了文件名称的格式，如果更严谨点还应该在方法中加入判断是否为java文件的语句
* @param file
*/
public static void overFile(File file){
if(!file.exists())
return ;
if(file.isDirectory()){
File[] files = file.listFiles();
for(File f: files){
if(f.isDirectory())
overFile(f);
else{
copyFile(f.getAbsoluteFile());
}
}
}else{
copyFile(file.getAbsoluteFile());
}
}
public static void copyFile(File file){
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
bis = new BufferedInputStream(new FileInputStream(file));
bos = new BufferedOutputStream(new FileOutputStream(changeName(file)));//调用变更名字的方法来创建复制的文件
byte[] buf = new byte[1024];
int len = 0;
while((len = bis.read(buf)) != -1){
bos.write(buf, 0, len);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally{
try {
if(bis != null){
bis.close();
bis = null;
}
} catch (IOException e) {
e.printStackTrace();
}
try {
if(bos != null){
bos.close();
bos = null;
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 变更文件名称，获得复制文件的目的文件名称
* @param file
* @return
*/
public static File changeName(File file){
String[] strs = file.getAbsolutePath().split("\\\\");
String str = strs[strs.length -1];
StringBuffer sb = new StringBuffer(str);
Pattern p = Pattern.compile("([0-9]+)[\\w]+");//正则表达式的应用
Matcher m = p.matcher(str);
if(m.find()){
sb.insert(sb.lastIndexOf(".java"), m.group(1));
}
//通过文件路径的父路径和改变好的目的文件名称创建新的文件路径
return new File(file.getParent() + File.separator + sb.toString());
}
}

复制代码

运行结果在我电脑上是成功的，不知道怎么上传图片所以就没截图了

Rainbow · Rainbow

看下啦，努力赚分

Rainbow · Rainbow

import java.util.Scanner;
public class Demo2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);//用户键盘输入数字
System.out.println("请输入你想分解的数字");
int number = sc.nextInt();//控制台获得想分解的数字
int z = 2;//2为最小质数
while (number> z) {
if (number % z== 0) {//但number能被k整除，则应打印出z的值
System.out.print(z+"x");
}
number = number / z;//并用number除以z的结果,作为新的数number,重复执行循环里的步骤
if (number % z != 0) {//(3)如果number不能被z整除，则用z+1作为k的值,重复执行循环里的步骤
z++;
}
}
System.out.println(z);
}
}

复制代码

longlangcx · longlangcx

第一次回复发表于31# 昨天 21:49~
该中饭了，先发前两道~

第一题：

import java.util.Scanner;
/*
* 题目1：键盘录入一个正整数，将其分解质因数。如：输入30，打印出30=2*3*5。
*
* 分析：应用递归的方法求解。
* 从2开始取模数对录入的正整数进行取模，如果模为零，则二者相除的结果作为被模数继续递归取模，
* 如果模不为0，则被模数不变，模数加1，继续递归，直到模数增加到被模数的1/2以上。
*
*/
public class Test1 {
public static void main(String[] args) {
//从控制台获取一个整数
Scanner in = new Scanner(System.in);
System.out.print("请输入一个正整数：");
int i = in.nextInt();
//调用递归方法获取结果
diGui(i,2,i);
}
/**
* 递归方法，将输入的正整数进行分解为质因数并输出
* @param a 被模数
* @param b 模数
* @param x 控制台输入的原值
*/
//只为完成题目要求，就private好了。
private static void diGui(int a, int b, final int x){
//结束条件：当b大于a的一半时输出最后一个被模数，如果被模数一直无变化，说明是质数。
if(a < b * 2){
if(a != x)
System.out.println(a);
else
System.out.println("您输入的是一个质数，无法分解");
return;
}
//如果可整除，则继续用此数进行递归，否则将被模数+1。
else if(a % b == 0){
if(a == x)
System.out.print(x + "= ");
System.out.print(b + "* ");
diGui(a / b, b, x);
}else
diGui(a, b + 1, x);
}
}/* Output:
请输入一个正整数：90
90= 2* 3* 3* 5
*///:~

复制代码

第二题：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Random;
/*
* 题目2：求出1-100之间的素数，假设有n个，将这些素数存入a[n+1]的数组中。
* （其中n个是求出的各个素数，还有一个是随机添加其中的一个素数）
* 这样数组中就有相同的两个素数，写一个搜索算法，找出数组中相同的那个素数。
* （随机添加的素数，可手动指定，也可利用随机方法产生）
* (注：存入数组后，数组中的所有元素理论上是无序的，相同的那个素数不一定就等于a[n]，
* 而是被存入了数组中的某个角标上)
*
* 分析：首先要找出1-100之间的素数。素数的判断可以用二重循环嵌套，也可以用递归，这里用
* for循环嵌套，外层枚举数，内层枚举2~sqrt(外层数字)之间的数对外层数取模。内层枚举结束
* 依然没找到模0的数则外层为素数。
*
* 因为找到的素数不是直接打印而是放在数组中，而查找过程结束前找到的素数个数未知，
* 因此使用ArrayList临时存放找到的素数，之后根据ArrayList中元素的个数确定数组大小，再
* 将其移动到数组内。
*
* 因为要在数组中添加一个重复的素数，所以数组大小可以定义为实际素数大小加1。再移入数组时，先
* 随机产生一个角标，移入时跳过此位置，之后再在素数中随机找一个放入此位，至此a[n+1]数组就搞定了。
*
* 之后要解决的就是如何在一个无序数组中找到重复元素，可以使用排序后临位比较的方法，但效率较低，
* 因此可以使用类似选择排序的方式查找重复，但不进行换位操作，这样效率较高。
*
*/
public class Test2 {
public static void main(String[] args) {
//定义一个ArrayList用于临时存储找到的素数
ArrayList<Integer> list = new ArrayList<Integer>();
//嵌套循环寻找素数，找到后插入到list中，模数限定不大于被模数的平方根，以提高效率
for(int i = 2; i <= 100; i++){
for(int j = 2;; j++){
if(j > (int)Math.sqrt(i)){
list.add(i);
break;
}
if(i % j == 0)
break;
}
}
//输出找到的list，这里直接调用了list的toString方法。
System.out.println("1-100之间的素数有:\n" + list);
//创建了一个int数组，大小为素数个数+1
int size = list.size();
int[] arr = new int[size + 1];
//生成随机数，randomNum为随机生成的1-100中的某素数，randomPos是插入数组中的位置
//这样可以让每次运行时插入的数和插入的位置都不同
Random rand = new Random();
int randomNum = list.get(rand.nextInt(size));
int randomPos = rand.nextInt(size);
//下面将ArrayList中的元素移动到数组中，在随机位插入随机素数，在尾位插入跳过的素数
for(int i = 0; i < arr.length - 1; i++){
if(i == randomPos){
arr[i] = randomNum;
continue;
}
arr[i] = list.get(i);
}
arr[arr.length - 1] = list.get(randomPos);
//输出完成插入后的数组
System.out.println("插入随机素数之后的数组为:\n" + Arrays.toString(arr));
//使用类似选择排序的方式进行多次比较，但不交换元素的位置，即实际不排序
for(int i = 0; i < arr.length -1; i++){
for(int j = i + 1; j < arr.length; j++){
if(arr[i] == arr[j])
System.out.println("重复元素为" + arr[i] + " ，出现位置为角标" + i + "和角标" + j);
}
}
}
}/* Output:
1-100之间的素数有:
[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]
插入随机素数之后的数组为:
[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]
重复元素为11 ，出现位置为角标4和角标14
*///:~

复制代码

王洪波 · 王洪波

本帖最后由王洪波于 2013-7-8 22:03 编辑

首先谢谢版主能够指出错误。
我重新改了下，如还有错，请再指出。

package com.itheima.bbs.c5a3;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
/**
* 2、求出1-100之间的素数，假设有n个，将这些素数存入a[n+1]的数组中。（其中n个是求出的各个素数，还有一个是随机添加其中的一个素数）
这样数组中就有相同的两个素数，写一个搜索算法，找出数组中相同的那个素数。（随机添加的素数，可手动指定，也可利用随机方法产生）
*/
public class CopyOftest2
{
public static void main(String[] args)
{
List<Integer> primes = new ArrayList<Integer>();
primes.add(2);//2 为素数先加进去
for(int i=3; i<=100; i+=2)
{
if(isPrime(i))
primes.add(i);
}
int size = primes.size();//原数组的大小
Random random = new Random();
//随机生成一个索引
int index = random.nextInt(size);
int s = primes.get(index);//额外添加的的素数
System.out.println("额外添加的的相同素数"+s);
//添加素数到随机位置
int pos = random.nextInt(size);
primes.add(pos, s);
//输出结果
printArray(primes);
//找数组中相同的两个素数
searchSame(primes);
}
/**
* 在集合list中查找元素i
*/
private static void searchSame(List<Integer> list)
{
int index = -1;
for(int i=1,size=list.size(); i<size; i++)
{
//改动点：这里用二分查找相同元素，前面的元素可能是无序的,考虑不周.这里改成了用indexOf()去前边元素中找
index = list.subList(0, i).indexOf(list.get(i));//从数组前边元素【0，i-1】中找
if(-1 != index)//包含当前元素
{
//找到了
System.out.println("位置"+i+"与位置"+index+"上的素数相同！都为:"+list.get(i));
return;
}
}
System.out.println("没有找到相同元素!");
}
private static void printArray(List<Integer> primes)
{
for(int i=1,size=primes.size(); i<=size; i++)
{
//十个一行输出
System.out.print((i-1)+":"+primes.get(i-1)+" ");
if(i%10 == 0)
System.out.println();
}
System.out.println();
}
/**
* 判断i是否为素数
*/
private static boolean isPrime(int i)
{
for(int j=2; j<i; j++)
{
if(i%j == 0)
return false;
}
return true;
}
}

复制代码

刘一军 · 刘一军

先看题目

万琪 · 万琪

水一下:lol

camml · camml

这个必须顶

刘张朋 · 刘张朋

抱着试试看的态度做了下，勉强做了第二、三题，不知道是否符合要求，但是对复习巩固确实很有效。第一题还是不会啊，还请多多指教哦。

      第二题：求出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");
}

}

camml · camml

本帖最后由 camml 于 2013-7-8 15:14 编辑

import java.util.*;
class Demo1{
public static void main(String[] args){
//输入一个正整数，并赋值给x
int x;
Scanner in = new Scanner(System.in);
System.out.print("请输入一个正整数:");
x = in.nextInt();
//匿名初始化一个对象
new PrimeSplit(x);
}
}
class PrimeSplit{
//将最小的质数赋值给k
int k = 2;
public PrimeSplit(int x){
//当输入的是1或2时特殊处理
if(x<=1){
System.out.println(x+"是无效的被分解数");
}
else if(x==2){
System.out.println(x+"分解后的质因数为: 1*"+x);
}else {
//1是所有的正整数的质数,后面和输出语句相连
System.out.print(x+"分解后的质因数为: 1");
while(k<=x){
//输入的数除以最小质数后重新循环
if(x%k==0){
System.out.print("*"+k);
x = x/k;
}
//如果k不能被x整除，就将k++
else{
k++;
}
}
}
}
}

复制代码

Rainbow · Rainbow

package day06静态;
import java.util.Scanner;
public class Demo2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);//用户键盘输入数字
System.out.println("请输入你想分解的数字");
int number = sc.nextInt();//控制台获得想分解的数字
int z = 2;//2为最小质数
while (number> z) {
if (number % z== 0) {//但number能被k整除，则应打印出z的值
System.out.print(z+"x");
number = number / z;//并用number除以z的结果,作为新的数number,重复执行循环里的步骤
}
if (number % z != 0) {//(3)如果number不能被z整除，则用z+1作为k的值,重复执行循环里的步骤
z++;
}
}
System.out.println(z);
}
}

复制代码

刚刚看了一下，number = number / z; 应该放在if循环里面，保证可以整除最小质数。

蚂蚁搬家 · 蚂蚁搬家

哥们儿，我是39楼的，帖子地址：http://bbs.itheima.com/forum.php ... 9314&pid=399428
你说我的第三题测试时出现角标越界异常，我运行了几遍没问题啊，用Eclipse和直接用cmd运行都没问题啊，都可以正常复制文件，
不知道你运行时出问题的语句在哪一行？
我把第三题的代码再贴一次，你看一下

/*
在一个文件夹内有文件夹和文件，文件名的格式为：数字+daxiang.java。
要求：把所有的.java文件复制一份，变为文件名格式为：数字+daxiang+数字.java。
（其中数字是相对应的，名称由字母组成。在本例中,文件名应该由"数字+daxiang.java"变为"数字+daxiang+数字.java")
*/
/*
基本思路：1，用递归方法获取到源目录下的java文件；
2，用缓冲流将源文件复制到目的文件夹下的目的文件；
3，用字符串的split方法拆分并重新组合出目的文件的文件名；
@author：蚂蚁搬家；
*/
import java.io.*;
public class CopyFile
{
public static void main(String [] args)
{
File file = new File("F:\\答题有分"); //源文件夹封装为File对象；
get(file); //调用get方法实现题目要求；
}
/*用递归方法获取源目录下的每个java文件，然后调用copyFile方法，将源文件复制到另一个文件夹中，
并对文件按照题目要求进行更名；*/
public static void get(File srcFile)
{
File[] files = srcFile.listFiles(); //列出源目录下的所有文件和目录；
for(File file : files)
{
if(file.isDirectory()) //如果是目录，递归调用get方法；
{
get(file);
}
else
{
if(file.getName().endsWith(".java")) //如果是java文件，调用copyFile方法；
{
copyFile(file);
}
}
}
}
//将源文件复制到目的文件夹，并对源文件按照题目要求更名；
public static void copyFile(File file)
{
BufferedReader br = null;
BufferedWriter bw = null;
try
{
br = new BufferedReader(new FileReader(file));
String srcName = file.getName(); //获取源文件的文件名；
String[] tempName = srcName.split("daxiang"); //将源文件名用“daxiang”拆分，拆分出来的结果是“数字”和“.java”；
String lastedName = tempName[0] + "daxiang" + tempName[0] + tempName[1]; //重新组合出来的结果就是"数字+daxiang+数字.java"；
bw = new BufferedWriter(new FileWriter("F:\\目标文件夹\\" + lastedName));
String buf = null;
while((buf = br.readLine()) != null)
{
bw.write(buf);
bw.newLine();
bw.flush();
}
}
catch(IOException e)
{
System.out.println("文件复制失败！");
}
finally
{
try
{
if(br != null)
br.close();
}
catch(IOException e)
{
}
try
{
if(bw != null)
bw.close();
}
catch(IOException e)
{
}
}
}
}

复制代码

longlangcx · longlangcx

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

补发下第三题：

/*
* 题目：在一个文件夹内有文件夹和文件，文件名的格式为：数字+名称.java。
* 要求：把所有的.java文件复制一份，变为文件名格式为：数字+名称+数字.java。
* （其中数字是相对应的，名称由字母组成。如：01Demo.java——>01Demo01.java)
*
* 分析：首先要获取文件夹中文件名为数字+名称.java的所有文件列表。
* 要实现此目标可以使用File.list(过滤器)方法，将目标文件夹定义为一个File对象，然后
* 设置一个过滤器类FileFilter，过滤条件为.java结尾，并且文件名中含有数字。
* 由于过滤器类仅仅创建了一个对象，并且设定的是本类的特有处理方式，不具备复用性，因此
* 可以将这个FileFilter类设置为本类的匿名内部类。
*
* 获得了要复制的文件列表之后，使用循环复制列表中的所有文件，调用改名方法将复制的目标文件名
* 改为目标值，在改名方法中，可以使用正则表达式来获取文件名中的数字部分，将此数字部分与原文
* 件名进行连接之后，即可获得新文件名。
*
* 复制文件方法中，在这里使用了文件类型兼容型更强的文件输入输出流进行复制，复制的目标文件名
* 为新文件名。
*/
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文件的文件名存入一个字符串数组list中
String[] list = pathFile.list(new FilenameFilter(){
@Override
public boolean accept(File dir, String name) {
return (name.endsWith("java")) && (name.split("\\D+").length != 0);
}
});
//遍历java文件清单，将其中的所有.java文件改名复制到同一个文件夹中。
//copyFile为自定义的赋值单个文件的方法。
//改名过程调用了自定义的getNewName方法。
for(String s : list){
String fullPath = path + "/" + s;
copyFile(fullPath, path + "/" + getNewName(s));
}
}
/**
* 此方法用于将指定的字符串结尾处的数字连接到原文件名的开始，生成新的字符串
* @param name 要处理的原字符串
* @return 返回处理后的字符串
*/
private static String getNewName(String name){
String[] strArr = name.split("\\D+");
return strArr[1] + name;
}
/**
* 此方法用于复制单个文件
* @param oldPath 原文件路径
* @param newPath 复制后路径
*/
public static void copyFile(String oldPath, String newPath) {
try {
//设置文件输入输出流
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);
}
//关闭流
in.close();
}catch (Exception e) {
System.out.println("复制文件过程中出错");
e.printStackTrace();
}
}
}

复制代码

技术分马上要够了~~求助攻~~{:soso_e142:}

王楚鑫 · 王楚鑫

明早要考试啊、、、悲催、、我是看题呢还是看题呢还是看题呢还是看题呢

黄少海 · 黄少海

第二题

/**
* 2、求出1-100之间的素数，假设有n个，将这些素数存入a[n+1]的数组中。（其中n个是求出的各个素数，还有一个是随机添加其中的一个素数）
*这样数组中就有相同的两个素数，写一个搜索算法，找出数组中相同的那个素数。（随机添加的素数，可手动指定，也可利用随机方法产生）
*
*思路 :1先求出1-100中素数的个数n.建立长度为n+1的数组.
* 2循环判断1到100中的数,是素数就存入数组中.
* 3手动添加一个11的素数到数组a[n+1]中.
* 4输出相同数的角标.
*/
package a0703;
public class Exam2 {
public static void main(String[] args) {
int n= 0;//素数的个数
for (int i = 2; i <= 100; i++) {
if (isPrime(i)) {
n++; //计算数组长度;
}
}
int [] a= new int [n+1];//数组长度
a[n] = 11; //手动添加一个素数11到数组中.
n = 0;
for (int i = 2; i <= 100; i++) {
if (isPrime(i)) { //调用质数判断函数
a[n] = i; //i是质数存入数组中
n++; //
}
}
for (int x = 0; x < a.length-1; x++) {//每个元素分别和比他角标大的元素进行比较
for(int y = 1; y < a.length; y++) {
if (a[x] == a[y] && x != y) { //两个数相等并且角标不一样
System.out.println("在数组角标为:"+x+"和"+y+"的两个元素相等");
}
}
}
}
/**判定一个数是否是质数
* @param int n 接收一个int类型的变量。
* @return false 这个数不是质数
* true 这个数是质数
*/
private static boolean isPrime(int n) {//判定一个数是否是质数
for(int i=2; i<=Math.sqrt(n); i++){
if(n%i==0){
return false;
}
}
return true;
}
}

复制代码

肥猫 · 肥猫

本帖最后由肥猫于 2013-7-8 21:08 编辑

第二题上交...

/**
功能：求出1-100之间的素数，假设有n个，将这些素数存入a[n+1]的数组中。
（其中n个是求出的各个素数，还有一个是随机添加其中的一个素数）
这样数组中就有相同的两个素数，写一个搜索算法，找出数组中相同的那个素数。
（随机添加的素数，可手动指定，也可利用随机方法产生）
author:肥猫
*/
import java.util.*;
class Test333
{
public static void main(String[] args)
{
ArrayList<Integer> al = new ArrayList<Integer>();//先定义一个底层基于数组的容器来存储1-100的素数。
al.add(2);//由于素数本身的意义所以需要手动添加第一个元素2。
boolean b = false;
for(int i =2;i<=100;i++)//双重循环找出符合条件的素数并添加到容器中。
{
for(int j =2;j<i;j++)
{
if(i%j==0)
{
b=false;
break;
}
else
b=true;
}
if(b)
{
al.add(i);
}
}
int x=al.size()+1;
int[] a = new int[x];//根据容器的大小动态初始化数组。
for(int k=0;k<x-1;k++)
{
a[k]=al.get(k);//将集合容器的值赋到数组中。
}
System.out.println("数组的长度是:"+a.length);
int key =a[(int)(Math.random()*(x-2))];//利用角标,随即抽取前面的角标将获得的值置于最后一位。
a[x-1]=key;
System.out.println("随机到的质数为:"+key);
System.out.print("数组:");
for(int l=0;l<a.length;l++){//遍历数组并输出以便于用二分法对其查找。
if(a[l]==key&&l!=x-1)
{
System.out.print(a[l] +",");
}
else if(a[l]==a[x-1])
{
System.out.println(a[l]);
}
else
{
System.out.print(a[l]+",");
}
}
System.out.print("查找元素的索引是:");
System.out.println(Arrays.binarySearch(a,0,x-1,key));//二分法对数组查找其索引。
}
}

复制代码

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

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

评分

评分

评分

评分

评分

评分

评分

评分

点评

评分

评分

黑马骑士勋章