黑马程序员——算法与编程

---------------------- <a href="http://edu.csdn.net/heima" target="blank">android培训</a>、<a href="http://edu.csdn.net/heima" target="blank">java培训</a>、期待与您交流！ ----------------------

1.判断身份证：要么是15位，要么是18位，最后一位可以为字母，并写程序提出其中的年月日。

package cn.kang;

import java.util.regex.Matcher;
import java.util.regex.Pattern;


public class RegexTest {
 
    /**
     * @param args
     * 
     * 
     * 1.判断身份证：要么是15位，要么是18位，最后一位可以为字母，并写程序提出其中的年月日。


         答：我们可以用正则表达式来定义复杂的字符串格式，(\d{17}[0-9a-zA-Z]|\d{14}[0-9a-zA-Z])可以用来判断是否为合法的15位或18位身份证号码。
         因为15位和18位的身份证号码都是从7位到第12位为身份证为日期类型。这样我们可以设计出更精确的正则模式，使身份证号的日期合法，这样我们的正则模式可以进一步将日期部分的正则修改为[12][0-9]{3}[01][0-9][123][0-9]，当然可以更精确的设置日期。
         在jdk的java.util.Regex包中有实现正则的类,Pattern和Matcher。以下是实现代码：
     * 
     */
    public static void main(String[] args) {
         
          // 测试是否为合法的身份证号码
          String[] strs = { "130681198712092019", "13068119871209201x",
                      "13068119871209201", "123456789012345", "12345678901234x",
                      "1234567890123" };
          Pattern p1 = Pattern.compile("(\\d{17}[0-9a-zA-Z]|\\d{14}[0-9a-zA-Z])");
          for (int i = 0; i < strs.length; i++) {
                Matcher matcher = p1.matcher(strs[i]);
                System.out.println(strs[i] + ":" + matcher.matches());
          }


          Pattern p2 = Pattern.compile("\\d{6}(\\d{8}).*"); // 用于提取出生日字符串
          Pattern p3 = Pattern.compile("(\\d{4})(\\d{2})(\\d{2})");// 用于将生日字符串进行分解为年月日
          for (int i = 0; i < strs.length; i++) {
                Matcher matcher = p2.matcher(strs[i]);
                boolean b = matcher.find();
                if (b) {
                      String s = matcher.group(1);
                      Matcher matcher2 = p3.matcher(s);
                      if (matcher2.find()) {
                            System.out.println("生日为" + matcher2.group(1) + "年"
                                               + matcher2.group(2) + "月"
                                          + matcher2.group(3) + "日");
                      }
                }
          }
    }

}

 2、编写一个程序，将a.txt文件中的单词与b.txt文件中的单词交替合并到c.txt文件中，  a.txt文件中的单词用回车符分隔，b.txt文件中用回车或空格进行分隔。

package cn.kang;


import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;




/*
 * 
 * 2、编写一个程序，将a.txt文件中的单词与b.txt文件中的单词交替合并到c.txt文件中，
 *    a.txt文件中的单词用回车符分隔，b.txt文件中用回车或空格进行分隔。
 * 
 * 
 */
public class MainClass{
    public static void main(String[] args) throws Exception{
          FileManager a = new FileManager("a.txt",new char[]{'\n'});
          FileManager b = new FileManager("b.txt",new char[]{'\n',' '});         
          FileWriter c = new FileWriter("c.txt");
          String aWord = null;
          String bWord = null;
          while((aWord = a.nextWord()) !=null ){
                c.write(aWord + "\n");
                bWord = b.nextWord();
                if(bWord != null)
                      c.write(bWord + "\n");
          }
         
          while((bWord = b.nextWord()) != null){
                c.write(bWord + "\n");
          }    
          c.close();
    }
   
}


class FileManager{


    String[] words = null;
    int pos = 0;
    public FileManager(String filename,char[] seperators) throws Exception{
          File f = new File(filename);
          FileReader reader = new FileReader(f);
          char[] buf = new char[(int)f.length()];
          int len = reader.read(buf);
          String results = new String(buf,0,len);
          String regex = null;
          if(seperators.length >1 ){
                regex = "" + seperators[0] + "|" + seperators[1];
          }else{
                regex = "" + seperators[0];
          }
          words = results.split(regex);
    }
   
    public String nextWord(){
          if(pos == words.length)
                return null;
          return words[pos++];
    }


}

3、编写一个程序，将d:\java目录下的所有.java文件复制到d:\jad目录下， 并将原来文件的扩展名从.java改为.jad

package cn.kang;


import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
 


/*
 * 
 * 3、编写一个程序，将d:\java目录下的所有.java文件复制到d:\jad目录下，
 * 并将原来文件的扩展名从.java改为.jad
 */
public class Jad2Java {
 
      public static void main(String[] args) throws Exception {
            File srcDir = new File("java");
            if(!(srcDir.exists() && srcDir.isDirectory()))
                        throw new Exception("目录不存在");
            File[] files = srcDir.listFiles(
                  new FilenameFilter(){
 
                              public boolean accept(File dir, String name) {
                                    return name.endsWith(".java");
                              }
                             
                        }
            );
           
            System.out.println(files.length);
            File destDir = new File("jad");
            if(!destDir.exists()) destDir.mkdir();
            for(File f :files){
                  FileInputStream  fis = new FileInputStream(f);
                  String destFileName = f.getName().replaceAll("\\.java$", ".jad");
                 FileOutputStream fos = new FileOutputStream(new File(destDir,destFileName));
                  copy(fis,fos);
                  fis.close();
                  fos.close();
            }
      }
     
      private static void copy(InputStream ips,OutputStream ops) throws Exception{
            int len = 0;
            byte[] buf = new byte[1024];
            while((len = ips.read(buf)) != -1){
                  ops.write(buf,0,len);
            }
 
      }
}


/*
 * 由本题总结的思想及策略模式的解析：
1.
class jad2java{
      1. 得到某个目录下的所有的java文件集合
            1.1 得到目录 File srcDir = new File("d:\\java");
            1.2 得到目录下的所有java文件：File[] files = srcDir.listFiles(new MyFileFilter());
            1.3 只想得到.java的文件： class MyFileFilter implememyts FileFilter{
                  public boolean accept(File pathname){
                        return pathname.getName().endsWith(".java")
                  }
            }
           
      2.将每个文件复制到另外一个目录，并改扩展名
            2.1 得到目标目录，如果目标目录不存在，则创建之
            2.2 根据源文件名得到目标文件名，注意要用正则表达式，注意.的转义。
            2.3 根据表示目录的File和目标文件名的字符串，得到表示目标文件的File。
                  //要在硬盘中准确地创建出一个文件，需要知道文件名和文件的目录。
            2.4 将源文件的流拷贝成目标文件流，拷贝方法独立成为一个方法，方法的参数采用抽象流的形式。
                  //方法接受的参数类型尽量面向父类，越抽象越好，这样适应面更宽广。 
}
 
分析listFiles方法内部的策略模式实现原理
File[] listFiles(FileFilter filter){
      File[] files = listFiles();
      //Arraylist acceptedFilesList = new ArrayList();
      File[] acceptedFiles = new File[files.length];
      int pos = 0;
      for(File file: files){
            boolean accepted = filter.accept(file);
            if(accepted){
                  //acceptedFilesList.add(file);
                  acceptedFiles[pos++] = file;
            }          
      }
     
      Arrays.copyOf(acceptedFiles,pos);
      //return (File[])accpetedFilesList.toArray();
     
}
 * 
 * 
*/

4、编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串，但要保证汉字不被截取半个，

package cn.kang;


public class StringTest {


/**
* @param args
* 4、编写一个截取字符串的函数，输入为一个字符串和字节数，输出为按字节截取的字符串，但要保证汉字不被截取半个，
* 如“我ABC”，4，应该截取“我AB”，输入“我ABC汉DEF”，
* 6，应该输出“我ABC”，而不是“我ABC+汉的半个”。
*/
public static void main(String[] args) throws Exception{
         String str = "我a爱中华abc我爱传智def";
        //String str1 = "我ABC汉";
         int num = trimGBK(str.getBytes("GBK"),6);
         System.out.println(str.substring(0,num) );
   }
  
   public static int  trimGBK(byte[] buf,int n){
         int num = 0;
         boolean bChineseFirstHalf = false;
         for(int i=0;i<n;i++)
         {
               if(buf[i]<0 && !bChineseFirstHalf){
                     bChineseFirstHalf = true;
               }else{
                     num++;
                     bChineseFirstHalf = false;                     
               }
         }
         return num;
   }


}

---------------------- <a href="http://edu.csdn.net/heima" target="blank">android培训</a>、<a href="http://edu.csdn.net/heima" target="blank">java培训</a>、期待与您交流！ ----------------------


详细请查看：<a href="http://edu.csdn.net/heima" target="blank">http://edu.csdn.net/heima</a>