Java进阶代码

　　本文重在温习……不过初学以及进阶高手不可错过

1.  public static void arraycopy(全小写)(object src,int srcPos,object dest,int destPos,int length)

 package b;
 /*
  * 使用java.lang.System类的静态方法，使用for循环一个一个拷贝会很慢，由于数组
  * 在内存里往往都是连续的区域，因此最有效率的往往是直接拷贝内存。
  * public static void arraycopy(全小写)(object src,int srcPos,object dest,int destPos,int length)
  * 如果超过目标数组的边界，则会抛出数组越界异常。
  */
 public class ArrayCopy {
     //没加上String args[]时运行的话还是前一个运行过的程序的结果。
     public static void main(String args[]) {
         String src[] = {"Microsoft","IBM","Sun","Oracle"};
         String dest[]= new String[6];
         System.arraycopy(src,0,dest,0,src.length);
         //拷贝是并不是真的真考，而是dest数组在堆里也指向那几个公司，那几个公司在堆内存里还是只有一份。
         for(int i=0; i<dest.length; i++) {
             System.out.println(dest[i]);//会打印null值

         }
         System.out.println("----------------");
         int a[][] = {{1,2},{1,2,3},{3,4}};//里面还是用大括号不是小括号
         int b[][] = new int[3][];//此时第一维里是null，第二维里才是0
         System.arraycopy(a,0,b,0,a.length);
         /*
          * 原数组的内容在堆内存里还是只有一份不是两份，由于指向的是同一块内存，
          * 因此对dest的操作相当于对src的操作。
          */
         b[2][1] = 100;
         for(int i=0; i<a.length; i++) {
             for(int j=0; j<a[i].length; j++) {
                 System.out.println(a[i][j]);
             }
         }
         System.out.println("---OK---");

     }
 }

2.二分查找

 /*
  * 二分查找某个数的位置
  */
 package b;

 public class BinaryFind {
     public static void main(String[] args) {
         int[] a = new int[100];
         //省去排序的步骤
         for(int i=0; i<a.length; i++) {
             a[i] = i*i;
         }
         int res = 64;//待查找的数
         int pos = search(a,res);
         System.out.println(pos);//返回的实际上是下标
     }
     public static int search(int[] a,int num) {
         if(a.length == 0) {
             return -1;
         }
         int start = 0;
         int end = a.length - 1;
         int mid = (start + end)/2;//和不能溢出
         while(start<end) {
             if(num == a[mid]) {
                 return mid;
             }else if(num>a[mid]) {
                 start = mid +1;
             }else {
                 end = mid -1;
             }
             mid = (start + end)/2;
         }
         return -1;
     }

 }

3.正则表达式

 package b;

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

 public class Calender {
     public static void main(String[] args) {
     Pattern p = Pattern.compile("(\\d\\d)\\1");
     /*
      * 输出true，\\1表示和第一个组的一样，若改成1213就不对了;
      * 若是Pattern.compile("(\\d(\\d))\\2")则需改成122才对
      *
      */

     String s = "1212";
     Matcher m = p.matcher(s);
     System.out.println(m.matches());

     }

 }

4.统计代码里多少空行，注释行，程序行

 package b;

 /*
  * 统计代码里多少空行，注释行，程序行
  * 实际上使用String里的startsWith和endsWith也行.
  * 若是项目经理用的话还要统计每行的字符数是否以{；结尾，防止偷懒
  */
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.IOException;

 public class CoderCount {

     static long normalLines = 0;
     static long commentLines = 0;
     static long whiteLines = 0;

     public static void main(String[] args) {
         File f = new File("D:\\share\\src");
         File[] codeFiles = f.listFiles();
         for(File child : codeFiles){
             //.java$表示以“.java”结尾
             if(child.getName().matches(".*\\.java$")) {
                 solve(child);
             }
         }

         System.out.println("normalLines:" + normalLines);
         System.out.println("commentLines:" + commentLines);
         System.out.println("whiteLines:" + whiteLines);

     }

     private static void solve(File f) {
         BufferedReader br = null;
         boolean comment = false;
         try {
             br = new BufferedReader(new FileReader(f));
             String line = "";
             while((line = br.readLine()) != null) {
                 /*
                  * //有的注释行前面有一个tab
                  * 不可写在readLine后
                  * 最后一行的话会空指针
                  */
                 line = line.trim();
                 //readLine读出字符串后就把后面的换行去掉啦
                 //     小写的s，\s表示空白字符，大写的表示非空白字符
                 if(line.matches("^[\\s&&[^\\n]]*$")) {//^表示行开头
                     whiteLines ++;
                 } else if (line.startsWith("/*") && !line.endsWith("*/")) {
                     commentLines ++;
                     comment = true;
                 } else if (line.startsWith("/*") && line.endsWith("*/")) {
                     commentLines ++;
                 } else if (true == comment) {
                     commentLines ++;
                     if(line.endsWith("*/")) {
                         comment = false;
                     }
                 } else if (line.startsWith("//")) {
                     commentLines ++;
                 } else {
                     normalLines ++;
                 }
             }
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         } finally {
             if(br != null) {
                 try {
                     br.close();
                     br = null;
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }
     }

 }

5.面向对象思路解决约瑟夫问题

 package b;

 /*面向对象的思路可以代替算法，先考虑有几个类，再考虑各个类的属性和方法，方法先考虑构造方法（考虑别人会怎么用就怎么设计）。
  * 实际上相当于链表
  */
 //有个小问题，马士兵的两个类都没有加static就行了，我的却必须加，否则CE
 public class Count3Quit1 {
     public static void main(String[] args) {
         KidCircle kc = new KidCircle(500);
         int num = 0;
         Kid k = kc.first;
         while(kc.count>1) {
             num++;
             if(num==3) {
                 num=0;
                 kc.delete(k);
             }
             k = k.right;
         }
         System.out.println(kc.first.id+1);
     }
 static class Kid {
     int id;
     Kid left;
     Kid right;

 }

 static class KidCircle {
     int count = 0;//刚开始是空圈
     Kid first, last;

     //表示几个人的圈，考虑别人怎么用，咱就怎么写
     KidCircle(int n) {
         for(int i=0; i<n; i++) {
             add();
         }
     }

     /*我们往圈里添加小孩，宾语就是往往就是参数，也可以不要参数
      * 在末尾添加小孩
      */
     void add() {
         Kid k = new Kid();
         k.id = count;
         if(count <=0) {
             first = k;
             last = first;
             k.left = k;
             k.right = k;
         }else {
             last.right = k;
             k.left = last;
             k.right = first;
             first.left = k;
             last = k;
         }
         count++;

     }

     //双向循环链表
     void delete(Kid k) {
         if(count <= 0) {
             return ;
         }else if(count == 1) {
             first = last = null;
         }else {
             k.left.right = k.right;
             /*
              * 垃圾收集器会回收k
              */
             k.right.left = k.left;
             if(k == first) {
                 first = k.right;
             }else if(k == last) {
                 last = k.left;
             }
         }
         count--;
     }
 }
 }

6.默认打印Date格式

 package b;

 import java.util.Date;

 public class Ke {

     public static void main(String[] args) {
         Date date = new Date();
         System.out.println(date);
     }
 }
 //结果：Thu Jul 11 23:56:07 CST 2013

7.new子类

 package b;

 import java.util.Scanner;

 /*
  * 由下面这个简短的程序可以看出，父类只要是无参构造方法，那么在new子类的时候就会自动调用
  */
 public class T {
     static String ch;
     public static void main(String[] args) {
         // TODO Auto-generated method stub
         //Scanner in = new Scanner(System.in);
         //String s  = in.next();
         String s = "a";
         new F();
         //若是直接把s赋值为a，那么下面为true，通过scanner读入的话为false
         System.out.println(s=="a");

     }
 }
 class F {
     F() {
         System.out.println("你好");
     }
 }

 class S extends F {

 }
 /*
  * 你好
     true
 */

8.正则表达式的知识都忘啦

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

 public class Te {

     public static void main(String[] args) {

         /*
          * 分别加上小括号，不算最外边的大括号，第一个左括号便是第一组
          */
         Pattern p = Pattern.compile("(\\d{3,5})([a-z]{2})");
         String s = "123aaa-77878bb-646dd-00";
         Matcher m = p.matcher(s);
         while(m.find()) {
             System.out.println(m.group());
             System.out.println(m.group(1));//输出每对符合的 数字
             System.out.println(m.group(2));//输出每对符合的 字母
         }
     }
 }

9.采用indexOf方法统计子串出现次数

 package b;

 /*
  * 统计子串出现次数
  */
 public class SubstrNum {
     public static void main(String[] args) {
         String str = "hajavakjhjdkjavakjhkjhkjavakajakajavakllk";
         String substr = "java";
         int index = -1;
         int num = 0;
         while((index=str.indexOf(substr))!=-1) {
             num++;
             //数组的length方法不加括号
             str = str.substring(index + substr.length());
         }
         System.out.println(num);
         System.out.println("----ok-----");
     }

 }

10.改进选择排序实现日期排序

 package b;

 /*
  * 就因为数组多分配了，就一直空指针异常
  */
 public class MyDate {
     public static void main(String[] args) {

         /*
          * 必须开辟四个空间，不能大于，否则空指针异常
          * 若是10，则array.length也为10，当然空指针异常
          */
         DateComp[] array = new DateComp[4];
         array[0] = new DateComp(2010,8,23);
         array[1] = new DateComp(2013,8,23);
         array[2] = new DateComp(2010,9,23);
         array[3] = new DateComp(2010,8,25);
         compare(array);//不用加类名就行
         for(int i=0; i<array.length; i++)
             System.out.println(array[i]);
     }
     public static void compare(DateComp[] a) {
             for(int i=0; i<a.length; i++) {
                 int k = i;
                 //比较次数不变，，每次最多交换一次
                 for(int j=k+1; j<a.length; j++) {
                     if(a[j].comp(a[k])==-1)//说明a[j]大，进行由大到小排序
                         k = j;
                 }
                 if(k!=i) {
                     DateComp temp = a[k];
                     a[k] = a[i];
                     a[i] = temp;
                 }
             }
     }
 }
 class DateComp {
     int year;
     int month;
     int day;
     DateComp(int y, int m, int d) {
         year = y; month = m; day = d;
     }
     public int comp(DateComp d) {
         if(d.year>year)
             return 1;
         else if(d.month >month)
             return 1;
         else if(d.day>day)
             return 1;
         else
             return -1;
     }
     public String toString() {
         return "Year:Month:Day --" + year + "-" +month+"-" + day;
     }
 }

11.HashMap

 package b;

 import java.util.HashMap;
 import java.util.Map;

 //需要命令行参数
 public class MapStatistics {
     private static final Integer ONE = new Integer(1);
     public static void main(String[] args) {
         Map m = new HashMap();
         for(int i=0; i<args.length; i++) {
             Integer freq = (Integer)m.get(args[i]);
             //freq肯定是null，因为4 5 6 都没有对应的value值，一直迷惑在这了
             if(freq == null) {
                 m.put(args[i],ONE);
             }else {
                 m.put(args[i],new Integer(freq.intValue() + 1));
             }
         }
         System.out.println(m.size() + " distinct words detected");
         System.out.println(m);
     }

 }

 /*
  * 输入 4 5 6
  * 输出
  * 3 distinct words detected
  * {6=1, 5=1, 4=1}
  */

12.事件监听

 package b;

 import javax.swing.*;
 import java.awt.*;
 import java.awt.event.*;
 public class FrameDemo
 {
     //定义该图形中所需的组件的引用
     private Frame f;
     private Button bt; 

     //方法
     FrameDemo()//构造方法
     {
         madeFrame();
     }

     public void madeFrame()
     {
         f = new Frame("My Frame");

         //对Frame进行基本设置。
         f.setBounds(300,100,600,500);//对框架的位置和大小进行设置
         f.setLayout(new FlowLayout(FlowLayout.CENTER,5,5));//设计布局

         bt = new Button("My Button");

         //将组件添加到Frame中
         f.add(bt);

         //加载一下窗体上的事件
         myEvent();

         //显示窗体
         f.setVisible(true);
     }

     private void myEvent()
     {
         f.addWindowListener(new WindowAdapter()//窗口监听
         {
             public void windowClosing(WindowEvent e)
             {
                 System.out.println("窗体执行关闭！");
                 System.exit(0);
             }
         });
         //让按钮具备关闭窗口的功能
         bt.addActionListener (new ActionListener()
         {
             public void actionPerformed(ActionEvent e)
             {
                  System.out.println("按钮执行关闭窗口的功能");
                  System.exit(0);
             }
         });
     }

     public static void main(String[] agrs)
     {
         new FrameDemo();
     }
 }

13.split

 package b;

 /*
  * 判断一个正整数是几位数在while循环里不断除以10，直到商为0
  * 或者转换为字符串只需求出长度即可。
  */
 public class TestSplit {
     public static void main(String[] args) {
         int j = 1234567;
         String strNum = String.valueOf(j);
         System.out.println("j是"+strNum.length()+"位数");

         String s = "Mary,F,1978";
         String[] str = s.split(",");//注意参数是String类型的正则表达式，所以是双引号
         for(int i=0; i<str.length; i++) {//length不带括号
             System.out.println(str[i]);
         }
         System.out.println("-------ok--------");
     }

 }

14. 多维数组

 package b;
 /*
  * Java中的多维数组和C/C++不同，不一定是每行长度一样，必须从左到右声明，
  *即int a[][] = new int[3][]可以，但是int a[][] = new int[][4]不行，
  *因为java中二维数组看成以数组为元素的数组，前一维不存在的话，没法分配下一维内存。
  * Int a[3][2] = {(1,2),(5,5),(6,8)}这样写非法，
  * 执行静态初始化时不该指定维度，防止出错。
  */
 public class TestString {
     public static void main(String args[]) {
         String s[][];//执行动态初始化时分为两步走，第一步时任何一维都不可指定
         s = new String[3][];
         s[0] = new String[2];
         s[1] = new String[3];
         s[2] = new String[2];
         for(int i=0; i<s.length; i++) {
             for(int j=0; j<s[i].length; j++) {
                 s[i][j] = new String("我的位置是："+i+","+j);//可以直接写常量字符串
             }
         }
         for(int i=0; i<s.length; i++) {
             for(int j=0; j<s[i].length; j++) {
                 System.out.println(s[i][j]);
             }
         }
     }
 }

15.equals

 package b;

 public class TestStringEqual {
     public static void main(String[] args) {
         /*
          * s1中的hello分配在data segement,s1在栈区，java虚拟机会对
          * data segement进行优化，所以s3指向的也是这个内存
          *
          */
         String s1 = "hello";
         String s2 = "world";
         String s3 = "hello";
         System.out.println(s1==s3);//true
         /*
          * s1中的hello分配在堆,s1在栈区，s2的也分配在堆区但是不同的内存
          * 引用不同，所以第一个是false。
          * equals是System类的静态方法，在Object类中。
          */
         s1 = new String("hello");
         s2 = new String("hello");
         System.out.println(s1==s2);//false
         System.out.println(s1.equals(s2));//true

         char c[] = {'s','u','n',' ','j','a','v','a'};
         String s4 = new String(c);
         String s5 = new String(c,4,4);//由结果可与看出第二个4是下标
         System.out.println(s4);//sun java
         System.out.println(s5);//java
         System.out.println("--------ok---------");
     }

 }

16.String内存解析和StringBuffer

 package b;

 /*
  *
 String是不可变的字符序列
 对于”String s1 = "123";String s2 = "456";s1 += s2;”s1.charAt(1)= '8'是错误的，
 但是s1 += s2是可以的（在内存里并不是把s2放于s1的内存后面（这样的话就违背了不可变的性质），
 而是开辟一个(s1 + s2)大小的内存再把s1和s2分别拷贝过去），
 也可以删除字符串（比如substring方法），
 删除中间的字符串的话也是分别把两头拷贝到新内存里再指向新内存，因此效率很低,就产生了StringBuffer
  */
 public class TestStringBuffer {
     public static void main(String[] args) {
         String s1 = "123";
         String s2 = "456";
         s1 += s2;
         System.out.println(s1);

         StringBuffer sb = new StringBuffer(s1);
         //由于append方法返回的仍然是StringBuffer，所以后面可以继续使用append方法
         sb.append("/").append("sun").append("/").append("Oracle");
         System.out.println(sb);

         StringBuffer sb1 = new StringBuffer("数字");
         for(int i=0; i<9; i++) {
             sb1.append(i);
         }
         System.out.println(sb1);

         //delete方法：起始和结束；
         sb1.delete(8, sb1.length()).insert(0,"abc");
         System.out.println(sb1);
         System.out.println(sb1.reverse());

         System.out.println("----ok-----");
     }

 }

17.Set

 package b;

 import java.util.*;

 /*
  * set包括hashset和treeset，其中元素无顺序和不重复
  * 和数学上的集合对应
  */
 public class TestSet {
     public static void main(String[] args) {
         Set<Object> s = new HashSet();//若是import java.util.Set就CE
         s.add("hello");
         s.add(new OtherName("f1","f2"));
         /*
          * 由于在OtherName里重写了equals方法，所以
          * 下面的这一对象相当于同一个元素，不会被加入
          */
         s.add(new OtherName("f1","f2"));
         System.out.println(s);

         Set s1 = new HashSet();
         Set s2 = new HashSet();
         s1.add("a"); s1.add("b"); s1.add("d");
         s2.add("a"); s2.add("c"); s2.add("d");
         Set sn = new HashSet(s1);
         sn.retainAll(s2);//求交集
         Set su = new HashSet(s1);//因为sn已经变化
         su.addAll(s2);//并集
         System.out.println(sn);
         System.out.println(su);
     }

 }

 class OtherName {
     private String firstName,lastName;
     public OtherName(String firstName,String lastName) {
         this.firstName = firstName;
         this.lastName = lastName;
     }
     public String getFirstName() {
         return firstName;
     }
     public void setFirstName(String firstName) {
         this.firstName = firstName;
     }
     public String getLastName() {
         return lastName;
     }
     public void setLastName(String lastName) {
         this.lastName = lastName;
     }

     //小马说的，这是最简单的
     public int hashCode() {
         return firstName.hashCode();
     }
     //这个是小马写的，以前没太懂，现在懂了
     public boolean equals(Object obj) {
         if(obj instanceof OtherName) {
             OtherName  other = (OtherName)obj;
             return firstName.equals(other.firstName)
             && lastName.equals(other.lastName);
         }
         return super.equals(obj);
     }
     public String toString() {
         return firstName + "    " + lastName;
     }

 }

18.内部类

 package b;

 public abstract class Week {
     private Week(){

     }

     //由于是abstract不可以直接new对象，但是可以经由子类，此处采用内部类
     public static final Week sun = new Week() {

         @Override
         public Week nextDay() {
             // TODO Auto-generated method stub
             return mon;
         }

     };//必须加分号

     public static final Week mon = new Week() {

         @Override
         public Week nextDay() {
             // TODO Auto-generated method stub
             return sun;
         }

     };

     public abstract Week nextDay();//必须加上abstract，否则总提示需要返回值

     //抽象类中可以有非抽象方法,子类实现该类的时候可以不重写该方法
     public String toString() {
         return this==sun?"Sunday":"Monday";
     }

 }

19.Map

 package b;

 import java.util.HashMap;
 import java.util.Map;
 import java.util.TreeMap;

 /*
  * Map有hashmap和treemap（红黑树），
  *  key不可重复（仍然是equals，一个一个比较又太麻烦，
  *  因此比较的是hashCode，需要重写hashCode方法），
  *  使用put（key，value）返回了Object是原来的
  *  value，get（key），size（），containsKey
  *  和containsValue，map里的key和value必须都是对象，
  *  至少要分配在堆，但是JDK1.5以后这样也是可以的map.put(“one”,1)而不必map.put(“one”,Integer(1))
  *  里面会自动打包（将基本类型转换为包装类）。
  */
 public class TestMap {
     public static void main(String[] args) {
         Map m1 = new HashMap();
         Map m2 = new TreeMap();
         m1.put("one", 1);
         m1.put("one", new Integer(1));//这两种写法等价，内存里实际上都是第二种
         m1.put("one", 1);
         m1.put("two", new Integer(2));//仍然要加上new
         m1.put("A", 1);
         m1.put("B", new Integer(2));
         System.out.println(m1.size());
         System.out.println(m1.containsKey("one"));
         System.out.println(m1.containsValue(2));

         if(m1.containsKey("two")) {
             //这两种写法等价
             //int i = m1.get("two").intValue();
             int i = (Integer)m1.get("two");//必须加上强转才可自动解包，否则鬼知道能否转为int类型
             System.out.println("在m1中two的value为:" + i);
         }

         Map m3 = new HashMap(m1);
         m3.putAll(m2);
         System.out.println(m3);
         System.out.println("----------ok----------");
     }

 }

20.Collections类

 package b;

 import java.util.*;

 /*
  * Collections是类，类方法有shuffle(容器)表示随机排序，
  * reverse表示逆序（ArrayLIst还是用数组实现的，
  * 需要拷贝，而LinkedList直接变换指针就好了），
  * sort排序，binarySearch（容器，元素）是折半查找。
  */
 public class TestList {
     public static void main(String[] args) {
         List a = new LinkedList();
         for(int i=0; i<9; i++) {
             a.add("a"+i);
         }
         System.out.println(a);
         Collections.shuffle(a);
         System.out.println(a);
         Collections.sort(a);
         System.out.println(a);
         Collections.reverse(a);
         System.out.println(a);
         Collections.sort(a);//折半查找的前提是有序，返回的是下标
         System.out.println(Collections.binarySearch(a, "a5"));
         System.out.println("\n");
     }
 }
 /*
  * 上面的算法如何确定“大小”顺序呢，所有可以排序的类都实现了
  * java.lang.Comparable接口，该接口中只有一个方法
  * public int compareTo(Object obj),该方法返回0表示this == obj,
  * 正数表示this>obj,里面是Object类型，现在是泛型，使用了泛型后
  * 比较的两者就肯定有意义，不会出来猫和超人比。
  */

21.Integer

 package b;
 /*
  * 基本数据类型包装类（包装成对象分配在堆内存）：在java.lang包，
  * 里面都有MAX_VALUE,MIN_VALUE,和SIZE，
  * 用于各种数之间的转换，查看API。
  */
 public class TestInteger {
     public static void main(String[] args) {
         Integer i = new Integer("100");//分配在堆上
         Double d = new Double("123.456");
         int j = i.intValue() + d.intValue();
         float f = i.floatValue() + d.floatValue();
         System.out.println(j);
         System.out.println(f);

         double pi = Double.parseDouble("3.1415926");
         double r = Double.valueOf("2.0").doubleValue();
         double s= pi*r*r;
         System.out.println(s);

         try {
             int k = Integer.parseInt("1.25");
             k += 1;
         }catch (NumberFormatException e) {
             System.out.println("数据格式不对");
             //e.printStackTrace();
         }

         System.out.println(Integer.toBinaryString(123)+"B");
         System.out.println(Integer.toHexString(123)+"H");
         System.out.println(Integer.toOctalString(123)+"O");//八进制
         System.out.println("---------ok------------");
     }

 }

22.iterator

 package b;

 import java.util.*;

 /*
  * Collections是类，包含shuffle，sort，binarySearch
  */
 public class TestIterator {
     public static void main(String[] args) {

         Collection c = new HashSet();
         c.add(new MyName("first","last"));
         c.add(new MyName("first1","last1"));
         c.add(new MyName("first2","last2"));
         //注意iterator在javax里也有，但此处需要用util包里的
         Iterator itr = c.iterator();
         ////打印出来的顺序不确定，因为set本身便是没有顺序
         while(itr.hasNext()) {
             MyName name = (MyName)itr.next();
             System.out.println(name.getFirstName());
         }
         /*
          * Iterator中的remove方法是遍历过程中的唯一删除元素的安全方法，
          * （因为iterator在遍历过程中执行了锁定（线程的东西）和数据库
          * 事务与锁里的类似）
          * 具体的容器set和list由于实现了collection接口所以也有remove方法，
          * 但是不安全。
          */
         for(Iterator i=c.iterator(); i.hasNext();) {
             MyName name = (MyName)i.next();
             if(name.getFirstName()=="first") {
                 i.remove();//使用c.remove(name)会产生例外
             }
         }
         System.out.println("------ok-------");
     }

 }

 class MyName {
     private String firstName,lastName;
     public MyName(String firstName,String lastName) {
         this.firstName = firstName;
         this.lastName = lastName;
     }
     public String getFirstName() {
         return firstName;
     }
     public void setFirstName(String firstName) {
         this.firstName = firstName;
     }
     public String getLastName() {
         return lastName;
     }
     public void setLastName(String lastName) {
         this.lastName = lastName;
     }

     //小马说的，这是最简单的
     public int hashCode() {
         return firstName.hashCode();
     }
     //这个是小马写的，没看太懂
     public boolean equals(Object obj) {
         if(obj instanceof MyName) {
             MyName  other = (MyName)obj;
             return firstName.equals(other.firstName)
             && lastName.equals(other.lastName);
         }
         return super.equals(obj);
     }

 }

23.HashSet

 package b;

 import java.util.*;
 /*
  * 相等的对象有相同的hash codes
  * 通过hash codes可以再内存里找对象，但不是具体的物理地址
  * 比如查字典时目录就是索引，通过目录找到值就是键，因此hash codes
  * 常用来做索引，比如在map里。涉及索引时需要重写equals和hashcode
  */
 public class TestHashSet {

     public static void main(String[] args) {
         Collection c = new HashSet();
         c.add("hello");
         c.add(new Name("first","last"));
         c.add(new Integer(100));
         /*
          * remove方法返回boolean值，既可以不
          * 赋值给一个boolean变量，也可以赋值给。比如下面的即可以直接调用
          * 也可以调用后打印出来，有点小迷惑。
          */
         c.remove("hello");//可以删除掉
         c.remove(new Integer(100));//也可以删除掉，因为Integer重写了equals方法
         System.out.println(c.remove(new Name("first","last")));
         System.out.println(c);
     }
 }
 class Name {

     private String firstName,lastName;
     public Name(String firstName,String lastName) {
         this.firstName = firstName;
         this.lastName = lastName;
     }
     public String getFirstName() {
         return firstName;
     }
     public void setFirstName(String firstName) {
         this.firstName = firstName;
     }
     public String getLastName() {
         return lastName;
     }
     public void setLastName(String lastName) {
         this.lastName = lastName;
     }
     /* (non-Javadoc)
      * @see java.lang.Object#hashCode()
      */
     @Override
     /*
     public int hashCode() {
         final int prime = 31;
         int result = 1;
         result = prime * result
                 + ((firstName == null) ? 0 : firstName.hashCode());
         result = prime * result
                 + ((lastName == null) ? 0 : lastName.hashCode());
         return result;
     }
     */
     //小马说的，这是最简单的
     public int hashCode() {
         return firstName.hashCode();
     }
     /* (non-Javadoc)
      * @see java.lang.Object#equals(java.lang.Object)
      */
     @Override
     /*这是java自动生成的，比较繁琐
     public boolean equals(Object obj) {
         if (this == obj) {
             return true;
         }
         if (obj == null) {
             return false;
         }
         if (!(obj instanceof Name)) {
             return false;
         }
         Name other = (Name) obj;
         if (firstName == null) {
             if (other.firstName != null) {
                 return false;
             }
         } else if (!firstName.equals(other.firstName)) {
             return false;
         }
         if (lastName == null) {
             if (other.lastName != null) {
                 return false;
             }
         } else if (!lastName.equals(other.lastName)) {
             return false;
         }
         return true;
     }
     */
     public boolean equals(Object obj) {
         if(obj instanceof Name) {
             Name  other = (Name)obj;
             return firstName.equals(other.firstName)
             && lastName.equals(other.lastName);
         }
         return super.equals(obj);
     }
 }

 package b;

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashSet;

 public class Reflect {

     public static void main(String[] args) {
         /*
          * new ArrayList()的话不论是否重写hashCode和equals都输出5；
          * new HashSet()重写前是4，后是3
          */
         //Collection coll = new ArrayList();
         Collection coll = new HashSet();
         Pointer p1 = new Pointer(1, 1);
         Pointer p2 = new Pointer(1, 1);
         Pointer p3 = new Pointer(3, 3);
         Pointer p4 = new Pointer(4, 4);

         coll.add(p1);
         coll.add(p2);
         coll.add(p3);
         coll.add(p4);
         coll.add(p4);
         /*
          * 参与hashCode运算的值，在加载后就不应该再改动，否则删除的话是删不掉的（不会报错），这就是内存泄露
          */
         System.out.println(coll.size());
     }
 }

 class Pointer {
     public int x = 0;
     public int y = 0;

     public Pointer(int x, int y) {
         super();
         this.x = x;
         this.y = y;
     }

     @Override
     public int hashCode() {
         final int prime = 31;
         int result = 1;
         result = prime * result + x;
         result = prime * result + y;
         return result;
     }

     @Override
     public boolean equals(Object obj) {
         if (this == obj)
             return true;
         if (obj == null)
             return false;
         if (getClass() != obj.getClass())
             return false;
         Pointer other = (Pointer) obj;
         if (x != other.x)
             return false;
         if (y != other.y)
             return false;
         return true;
     }
 }

24.创建File

 package b;

 import java.io.File;
 import java.io.IOException;
 /*
  * 若是class文件在包中，
  * 运行后其父路径（父路径是class文件的父路径）是包的父路径，
  * 创建的目录（目录也是一种文件）和包路径的上一个平级不和包平级，试试eclips就看出来了
  */
 public class TestFile {
     public static void main(String[] args) {
         String separator = File.separator;//不管在wins还是linux下都可以用正斜杠（反斜杠是转义字符）
         String filename = "myfile.txt";
         String directory = "mydir1" + separator + "myfile2";
         //下面这两种写法也行
         //String directory = "mydir1/myfile2";
         //String directory = "mydir1\\myfile2";//一个反斜杠是转义字符
         File f = new File(directory,filename);//现在只是内存里的一个对象
         if(f.exists()) {
             System.out.println("文件名：" + f.getAbsolutePath());
             System.out.println("文件大小：" + f.length());
         }else {
             //父路径是class文件的父路径
             f.getParentFile().mkdirs();//因为是两个"mydir1/myfile2"，所以加s了
             try {
                 f.createNewFile();
             }catch (IOException e) {
                 e.printStackTrace();
             }
         }

     }

 }

25.枚举+内部类实现交通灯

 package b;

 import java.util.Date;

 class TestEnum {
     public enum TraficLamp {
         //Red,Green,Yellow;
         Red(30) {//new子类的对象并调用父类的有参构造方法

             @Override
             public TraficLamp nextLamp() {
                 // TODO Auto-generated method stub
                 return Green;
             }
         },//必须加逗号

         Green(45) {

             @Override
             public TraficLamp nextLamp() {
                 // TODO Auto-generated method stub
                 return Yellow;
             }

         },//必须加逗号

         Yellow(5) {

             @Override
             public TraficLamp nextLamp() {
                 // TODO Auto-generated method stub
                 return Red;
             }

         };//必须加分号
         /*
          * 若是写下面的抽象方法，则必须让子类实现该方法,也就是上面的三个元素。
          */
         public abstract TraficLamp nextLamp();

         private int time;

         private TraficLamp(int time) {
             this.time = time;
         }
     }

     public static void main(String[] args) {
         TraficLamp m = TraficLamp.Red;
         System.out.println(m);
         System.out.println(m.name());
         System.out.println(m.ordinal());
         System.out.println(TraficLamp.valueOf("Red").toString());//是red的话CE
         System.out.println(TraficLamp.values().length);

         new Date(300) {//new子类的对象并调用父类的有参构造方法这样是可以的
         };
     }
 //如果枚举只有一个成员时就可以作为单例实现方式
 }

26.编写一个方法，返回一个double型二维数组，数组中的元素通过解析字符串获得

 package b;

 /*
  * 编写一个方法，返回一个double型二维数组，数组中的元素通过解析
  * 字符串货的。如：参数列表"1,2;3,4,5;6,7,8"
  */
 public class TestDouble {
     public static void main(String[] args) {
         double[][] d;
         String s = "1,2;3,4,5;6,7,8";
         String[] sFirst = s.split(";");
         d = new double[sFirst.length][];
         for(int i=0; i<sFirst.length; i++) {
             //System.out.println(sFirst[i]);////验证分的对否
             String[] sSecond = sFirst[i].split(",");
             d[i] = new double[sSecond.length];
             for(int j=0; j<sSecond.length; j++) {
                 d[i][j] = Double.parseDouble(sSecond[j]);
             }

         }
         for(int i=0; i<d.length; i++) {
             for(int j=0; j<d[i].length; j++) {
                 System.out.print(d[i][j]+" ");
             }
             System.out.println();
         }
         System.out.println("-----ok-------");
     }
 }

27.Enhanced

 package b;

 import java.util.*;
 /*
  * Enhanced for循环是在jdk1.5后才有的，
  * 与数组相比不能方便地访问下标值，
  * 与使用iterator的集合相比不能方便地删除集合中的内容。
  * 除了简单遍历并输出内容外比建议使用此法。
  */
 public class TestEnhancedFor {
     public static void main(String[] args) {
         int[] a = {1,3,5,6};
         for(int i : a) {
             System.out.println(i);
         }

         Collection c = new ArrayList();
         c.add(new String("aaa"));
         c.add(new String("bbb"));
         c.add(new String("ccc"));
         for(Object o : c) {//Object的第一个字母大写
             System.out.println(o);//调用Object的toString方法，
             //而在String里又重写了toString方法，所以实际上调用的是String里的
         }
     }
 }

28.Applet

 package b;

 import java.applet.Applet;
 import java.awt. *;

 public class TestApplet extends Applet
 {
   public void paint(Graphics gr)
   {
     setBackground ( Color.pink);
     gr.drawString ("          黄鹤楼              ", 25, 30);
     gr.drawString ("昔人已乘黄鹤去, 此地空余黄鹤楼。", 25, 50) ;
     gr.drawString ("黄鹤一去不复返, 白云千载空悠悠。", 25, 70) ;
     gr.drawString ("晴川历历汉阳树, 芳草萋萋鹦鹉洲。", 25, 90) ;
     gr.drawString ("日暮乡关何处是, 烟波江上使人愁。", 25, 110) ;
     gr.drawString ("---崔颢", 50, 150) ;
   }
 }

29.三种方法统计字母个数

 package b;
 /*
  * 统计字符串里大小写字母和非字母的个数
  */
 public class Statistics {
     public static void main(String[] args) {
         String str = "jkhshfs44__sjjkssfj jksn";
         int lowNum = 0,upperNum = 0,notNum = 0;
         System.out.println("第一种方法");
         for(int i=0; i<str.length(); i++) {
             char ch = str.charAt(i);
             if(ch>='a'&&ch<='z') {
                 lowNum++;
             }else if(ch>='A'&&ch<='Z') {
                 upperNum++;
             }else {
                 notNum++;//变量未初始化的话也会报错
             }
         }
         System.out.println("lowNum:"+lowNum+"upperNum:"+upperNum+"notNum:" + notNum);
         System.out.println("第二种方法");
         lowNum = 0;upperNum = 0;notNum = 0;
         for(int i=0; i<str.length(); i++) {
             char ch = str.charAt(i);
             String s1 = "abcdefghijklmnopqrstuvwxyz";
             String s2 = s1.toUpperCase();
             if(s1.indexOf(ch)!=-1) {//参数为int型但是字符类型是按ASCII码的
                 lowNum++;
             }else if(s2.indexOf(ch)!=-1) {
                 upperNum++;
             }else {
                 notNum++;
             }
         }
         System.out.println("lowNum:"+lowNum+"upperNum:"+upperNum+"notNum:" + notNum);
         System.out.println("第三种方法");
         lowNum = 0;upperNum = 0;notNum = 0;
         for(int i=0; i<str.length(); i++) {
             char ch = str.charAt(i);
             if(Character.isLowerCase(ch)) {//参数为int型但是字符类型是按ASCII码的
                 lowNum++;
             }else if(Character.isUpperCase(ch)) {
                 upperNum++;
             }else {
                 notNum++;
             }
         }
         System.out.println("lowNum:"+lowNum+"upperNum:"+upperNum+"notNum:" + notNum);
         System.out.println("------ok-----------");
     }

 }
 /*
  * 由于每次方法都需要重新初始化，只能“lowNum = 0;upperNum = 0;notNum = 0;”不能
  * lowNum = 0,upperNum = 0,notNum = 0;
  */

30.递归展示文件结构

 package b;

 import java.io.File;
 /*
  * 以树状形式展现所有的目录。子目录以及文件,
  * 实际就是递归输出目录结构
  */
 public class ShowDirectory {
     public static void main(String[] args) {
         File f = new File("e:/A");//这个是确实先在磁盘上建立好的
         System.out.println(f.getName());
         list(f,1);//从1开始是因为A父目录要和下一个区分开
         System.out.println("--------ok--------");
     }
     private static  void list(File f,int depth){
         /*第二个参数是为了凸显层次结构，每递归深入一次就缩进一次
          depth定义为成员变量的话，没上一次就减一，下一次就加一，很麻烦
          */
             String str = "";
             for(int i=0; i<depth; i++) {
                 str += "    ";
             }
             File[] childs = f.listFiles();
             for(int i=0; i<childs.length; i++) {
                 System.out.println(str + childs[i].getName());
                 if(childs[i].isDirectory()) {
                     list(childs[i],depth+1);
                 }
             }
     }
 }

31.Generic

 package b;

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Iterator;;
 /*
  * 泛型(generic):C/C++里也有泛型
  * （java的泛型底层实现比较麻烦），一般和
  * 自动打包解包一起用，以前装入的东西都
  * 作为Object还需要强转从而在编译时找不到错误，
  * 定义时就限制里面可以装入的对象类型,
  * 也可以在Collection和Iterator里指定,
  * 什么时间才可以使用泛型呢，查看API文档，
  * 只要后面有尖括号，那么就可以，程序的可读性就增强了，随之健壮性也增强啦。
  */
 public class TestGeneric {
     public static void main(String[] args) {
         List<String > ls = new ArrayList<String>();
         ls.add("aaa");
         ls.add("bbb");
         ls.add("ccc");
         ls.add("ddd");
         for(int i=0; i<ls.size(); i++) {
             String s = ls.get(i);//不需要强转了
             System.out.println(s);
         }

         Collection <String> str = new HashSet<String>();
         str.add("aaa");
         str.add("bbb");
         str.add("ccc");
         str.add("ddd");
         for(Iterator<String> ptr = str.iterator(); ptr.hasNext();) {
             String s = ptr.next();
             System.out.println(s);
         }
     }
 }

 class Another implements Comparable<Another> {
     int age;

     public int compareTo(Another other) {
         if(this.age>other.age) {
             return 1;
         }else if(this.age == other.age) {
             return 0;
         }else {
             return -1;
         }
     }

 }

32.Comparable接口

 package b;

 import java.util.Collections;
 import java.util.LinkedList;
 import java.util.List;

 public class TestComparable {
     public static void main(String[] args) {
         List a = new LinkedList();
         a.add(new AnotherName("a", "b"));
         a.add(new AnotherName("a", "d"));
         a.add(new AnotherName("c", "b"));
         Collections.sort(a);//重写了compareTo方法
         for(Object i : a) {//前面写成AnotherName就CE
             AnotherName b = (AnotherName)i;
             System.out.println(b);
         }
         System.out.println("----------ok----------");
     }
 }

 //原来忘了实现这个Comparable接口，一直提示ClassCastEXception
 class AnotherName implements Comparable {
     private String firstName,lastName;
     public AnotherName(String firstName,String lastName) {
         this.firstName = firstName;
         this.lastName = lastName;
     }
     public String getFirstName() {
         return firstName;
     }
     public void setFirstName(String firstName) {
         this.firstName = firstName;
     }
     public String getLastName() {
         return lastName;
     }
     public void setLastName(String lastName) {
         this.lastName = lastName;
     }

     //小马说的，这是最简单的
     public int hashCode() {
         return firstName.hashCode();
     }
     public boolean equals(Object obj) {
         if(obj instanceof AnotherName) {
             AnotherName  other = (AnotherName)obj;
             return firstName.equals(other.firstName)
             && lastName.equals(other.lastName);
         }
         return super.equals(obj);
     }
     //也是小马写的，先比较姓氏也就是lastName
     public int compareTo(Object o) {//最后一个o是小写，重写必copy
         AnotherName other = (AnotherName)o;
         int intCmp =  lastName.compareTo(other.lastName);
         if(intCmp==0) {
             return firstName.compareTo(other.firstName);
         }else {
             return intCmp;
         }
     }
     public String toString() {
         return firstName + "  " + lastName;
     }
 }

33.正则表达式做EmailSpider

 package b;

 import java.io.BufferedReader;
 import java.io.FileNotFoundException;
 import java.io.FileReader;
 import java.io.IOException;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

 /*
  * 需要什么样的方法的话先些方法名
  * 然后ctrl + 1列出推荐，系统创建该方法
  */
 public class EmailSpider {

     public static void main(String[] args) {
         try {
             BufferedReader br = new BufferedReader(new FileReader("F:\\regex.html"));
             String line = "";

             try {
                 while((line=br.readLine())!=null) {
                     solve(line);
                 }
             } catch (IOException e) {
                 // TODO Auto-generated catch block
                 e.printStackTrace();
             }
         } catch (FileNotFoundException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
     }

     private static void solve(String line) {
         //正则表达式要是不满足相应功能的话不会出错，因为他是字符串
         Pattern p = Pattern.compile("[\\w[.-]]+@[\\w[.-]]+\\.[\\w]+");
         Matcher m = p.matcher(line);

         while(m.find()) {
             System.out.println(m.group());
         }
     }
 }