长文慎点，Java学习笔记（三）

这只是一篇我自己学习java的流水账笔记，包含了以下内容，全是基础代码示例，希望对正在学习java的小伙伴有帮助

• java线程：Thread pool
• java GUI编程：Graphical User Interface programming
• java简单爬虫：Web Email Spider & Magnet Spider

Thread pool

Extends class Thread for a thread

Extends class Thread for a thread or implements interface Runnable

import java.io.*;
import java.security.*;
import javax.xml.bind.*;
public class ExtendsThread{
    public static void main(String[] args){
        for(String filename : args){
            DigestThread dt = 
                    new DigestThread(filename);
            Thread t = new Thread(dt);
            t.start();
        }
    }
}
 
class DigestThread extends Thread{
    private String filename;
     
    DigestThread(String filename){
        this.filename = filename;
    }
     
    public void run(){
        try{
            FileInputStream fis = 
                    new FileInputStream(filename);
            MessageDigest sha = 
                    MessageDigest.getInstance("SHA-256");
            DigestInputStream dis = 
                    new DigestInputStream(fis,sha);
            while(dis.read() != -1);
            dis.close();
            byte[] digest = sha.digest();
            for(int i=0;i<digest.length;i++){
System.out.println(digest[i]);             
            }
 
            StringBuilder result = 
                    new StringBuilder(filename);
System.out.println(result);
            result.append(":");
System.out.println(result);
            result.append  
            (DatatypeConverter.printHexBinary(digest));
            System.out.println(result);
        }catch(IOException | NoSuchAlgorithmException  e){
             
        }
         
    }
     
}

Call back functions for a thread including static call back and instance call back

import java.io.*;
import java.security.*;
import javax.xml.bind.*;
public class CallbackDigestUserInterface{
    public static void main(String[] args){
        for(String filename : args){
            CallbackDigest cb = 
                    new CallbackDigest(filename);
            Thread t = new Thread(cb);
            t.start();
        }
         
    }
     
    public static void receiveDigest
    (byte[] digest,String name){
        StringBuilder result = 
                new StringBuilder(name);
        result.append(":");
        result.append
        (DatatypeConverter.printHexBinary());
        System.out.println(result);
    }
}
 
class CallbackDigest implements Runnable{
    private String filename;
     
    CallbackDigest(String filename){
        this.filename = filename;
    }
     
    public void run(){
        try {
            FileInputStream fis =
                    new FileInputStream(filename);
            MessageDigest sha = 
                    MessageDigest.getInstance("SHA-256");
            DigestInputStream dt = 
                    new DigestInputStream(fis,sha);
            while(dt.read != -1);
            dt.close();
            byte[] digest = sha.digest();
            CallbackDigestUserInterface.receiveDigest
            (digest,filename);
        }catch(IOException | NoSuchAlgorithmException e){
            System.err.printlln(e);
        }
    }
}

Instance call back

import java.io.*;
import java.security.*;
import javax.xml.bind.*;
public class InstanceCallbackDigestUserInterface{
    private String filename;
    private byte[] digest;
     
    InstanceCallbackDigestUserInterface(String filename){
        this.filename = filename;
    }
     
    public static void main(String[] args){
        for(String filename : args){
            InstanceCallbackDigestUserInterface d =
                new InstanceCallbackDigestUserInterface(filename);
            d.calculateDigest();
        }
    }
     
    public void calculateDigest(){
        InstanceCallbackDigest icd = 
                new InstanceCallbackDigest(filename,this);
        Thread t = new Thread(icd);
        t.start();
    }
     
    void receiveDigest(byte[] digest){
        this.digest = digest;
        System.out.println(this);
    }
     
    public String toString(){
        String result = filename + ":";
        if(digest != null){
            result += DatatypeConverter.printHexBinary(digest);
        }else{
            result += "digest not available!";
        }
        return result;
    }
     
     
}
 
class InstanceCallbackDigest implements Runnable{
    private String filename;
    private InstanceCallbackDigestUserInterface callback;
     
    InstanceCallbackDigest(String filename,
    InstanceCallbackDigestUserInterface callback){
        this.filename = filename;
        this.callback = callback;
    }
     
    public void run(){
        try(FileInputStream fis = 
        new FileInputStream(filename);
        ){
            MessageDigest sha = 
                    MessageDigest.getInstance("SHA-256");
            DigestInputStream dis = 
                    new DigestInputStream(fis,sha);
            while(dis.read() != -1);
            dis.close();
            byte[] digest = sha.digest();
            callback.receiveDigest(digest);
        }catch(IOException | NoSuchAlgorithmException e){
            System.err.println(e);
        }
    }
}

A interesting instance

interface DoWork{
    void doHomeWork(String homework,String anwser);
}
public class StudentCallback implements DoWork{
     
    public void doHomeWork(String homework,String anwser){
        System.out.println
        (homework+" the anwser is "+anwser+" thread线程");
    }
     
    public void goHome(){
        System.out.println
        ("I go home:主线程,不等thread线程出结果,无阻塞");
    }
     
    public void ask(String homework,RoomMate roommate){
        new Thread(new Runnable(){
            public void run(){
                roommate.getAnwser
                (homework,StudentCallback.this);
            }
        }).start();
         
        goHome();
    }
     
    public static void main(String[] args){
        StudentCallback student = new StudentCallback();
        String homework = "1+1=?";
        student.ask(homework,new RoomMate());
    }
}
 
class RoomMate{
    public void getAnwser(String homework,DoWork dowork){
        try{
            Thread.sleep(3000);
        }catch(InterruptedException e){
            System.err.println(e);
        }
        if(homework.equals("1+1=?")){
            String anwser = "2";
            dowork.doHomeWork(homework,anwser);
        }else{
            System.out.println("I do not know");
        }
         
    }
}

Max finder

import java.util.concurrent.*;
//import java.util.concurrent.Callable;
public class MultithreadedMaxFinder{
    public static void main(String[] args){
        /*
        System.out.println(Integer.MIN_VALUE);
        int[] i = {1,2,3,4,5};
        FindMaxTask m = new FindMaxTask(i,0,5);
        System.out.println(m.call());*/
        int[] data = new int[101];
        for(int i=0; i<100; i++){
            data[i] = i;
        }
         
        try{
            System.out.println
            (max(data));
        }catch(Exception e){}
         
         
         
    }
     
    public static int max(int[] data) throws InterruptedException,
    ExecutionException{
         
        if(data.length == 1){
            return data[0];
        }else if(data.length == 0){
            System.err.println();
        }
         
        FindMaxTask task1 = 
                new FindMaxTask(data,0,data.length/2);
        FindMaxTask task2 = 
                new FindMaxTask(data,data.length/2,data.length);
                 
        ExecutorService service = 
                Executors.newFixedThreadPool(2);
        Future<Integer> future1 = service.submit(task1);
        Future<Integer> future2 = service.submit(task2);
         
        return Math.max(future1.get(),future2.get());
             
    }
}
 
class FindMaxTask implements Callable<Integer>{
    private int[] data;
    private int start;
    private int end;
     
    FindMaxTask(int[] data,int start,int end){
        this.data = data;
        this.start = start;
        this.end = end;
    }
     
    public Integer call(){
        int max = Integer.MIN_VALUE;
        for(int i=start; i<end; i++){
            if(data[i] > max) max = data[i];
        }
        return max;
    }
}

Gzip files

import java.io.*;
import java.util.zip.*;
import java.util.concurrent.*;
public class GzipAllfiles{
     
    public final static int THREAD_COUNT = 4;
     
    public static void main(String[] args){
         
        ExecutorService pool = 
                Executors.newFixedThreadPool(THREAD_COUNT);
         
        for(String filename : args){
            File f = new File(filename);
            if(f.exists()){
                if(f.isDirectory()){
                    File[] files = f.listFiles();
                    for(int i=0; i<files.length; i++){
                        if(!files[i].isDirectory()){
                            Runnable task = 
                                    new GzipRunnable(files[i]);
                            pool.submit(task);
                        }
                    }
                }else{
                    Runnable task = 
                            new GzipRunnable(f);
                    pool.submit(task);
                }
            }
        }
        pool.shutdown();
    }
}
 
class GzipRunnable implements Runnable{
     
    private final File input;
     
    public GzipRunnable(File input){
        this.input = input;
    }
     
    public void run(){
        if(!input.getName().endsWith(".gz")){
            File output = new File
                (input.getParent(),input.getName() + ".gz");
            if(!output.exists()){
                try(InputStream in = 
                    new BufferedInputStream(
                    new FileInputStream(input));
                    OutputStream out = 
                    new BufferedOutputStream(
                    new GZIPOutputStream(
                    new FileOutputStream(output)))){
                        int b;
                        while( (b = in.read()) != -1 ){
                            out.write(b);
                        }
                        out.flush();
                }catch(IOException e){
                    System.out.println(e);
                }
            }
        }
    }
}

A simple instance

import java.util.concurrent.*;
import java.util.*;
public class ThreadPool{
    public static void main(String[] args){
        ExecutorService pool = 
                Executors.newFixedThreadPool(4);
         
        List<Future<String>> futures = 
                new ArrayList<Future<String>>(10);
        for(int i=0; i<10; i++){
            futures.add
            (pool.submit(new ThreadIns()));   
        }
        for(Future<String> future : futures){
            try{
                String result = future.get();
                System.out.println(result);
            }catch(InterruptedException | ExecutionException e){
                 
            }
             
        }
        pool.shutdown();
    }
}
 
class ThreadIns implements Callable<String>{
     
    public String call(){
        return "Run";
    }
}

Graphical User Interface programming

Frame and Panel

import java.awt.*;
public class TestFrame2{
    public static void main(String[] args){
        frame f1 = new frame
        (100,100,100,100,Color.blue);
        frame f2 = new frame
        (200,100,100,100,Color.black);
        frame f3 = new frame
        (100,200,100,100,Color.yellow);
        frame f4 = new frame
        (200,200,100,100,Color.green);
    }
}
 
class frame extends Frame{
    static int id = 0;
    frame(int x,int y,int w,int h,Color c){
        super("Tittle"+(++id));
        setBounds(x,y,w,h);
        setBackground(c);
        setVisible(true);
    }
}
import java.awt.*;
public class TestFrame3{
    public static void main(String[] args){
        Frame f = new Frame("Test");
        Panel p = new Panel(null);
        f.setLayout(null);
        f.setBounds(50,100,300,300);
        f.setBackground(Color.blue);
        p.setBounds(50,50,200,200);
        p.setBackground(Color.yellow);
        f.add(p);
        f.setVisible(true);
    }
}
import java.awt.*;
public class TestFrame4{
    public static void main(String[] args){
        MyPanel p = new MyPanel
        ("test",800,30,400,400);
    }
}
 
class MyPanel extends Frame{
    private Panel p1,p2,p3,p4;
    public MyPanel(String n,int x,int y,int w,int h){
        super(n);
        setLayout(null);
        setBounds(x,y,w,h);
        p1 = new Panel(null);
        p2 = new Panel(null);
        p3 = new Panel(null);
        p4 = new Panel(null);
        p1.setBounds(0,0,w/2,h/2);
        p1.setBackground(Color.red);
        p2.setBounds(w/2,0,w/2,h/2);
        p2.setBackground(Color.blue);
        p3.setBounds(0,h/2,w/2,h/2);
        p3.setBackground(Color.yellow);
        p4.setBounds(w/2,h/2,w/2,h/2);
        p4.setBackground(Color.black);
        add(p1);add(p2);add(p3);add(p4);
        setVisible(true);
    }
}
import java.awt.*;
public class TestFrame5{
    public static void main(String[] args){
        MyFrame f = new MyFrame
        ("my panel",800,50,400,400);
    }
}
 
class MyFrame extends Frame{
    private Panel p1;
    public MyFrame(String n,int x,int y,int w, int h){
        super(n);
        setBounds(x,y,w,h);
        setBackground(Color.red);
        setLayout(null);
        p1 = new Panel(null);
        p1.setBounds(w/4,h/4,w/2,h/2);
        p1.setBackground(Color.yellow);
        add(p1);
        setVisible(true);
    }
}

Layout Manager

import java.awt.*;
public class TestFlowLayout{
    public static void main(String[] args){
        new Myframe().launchFrame();
    }
}
 
class Myframe extends Frame{
    public void launchFrame(){
        Button b1 = new Button("OK"); 
        Button b2 = new Button("Yes"); 
        Button b3 = new Button("cancle");
        setLayout(new FlowLayout(FlowLayout.LEFT));
        add(b1);
        add(b2);
        add(b3);
        setBounds(300,200,300,300);
        setVisible(true);
    }
}
import java.awt.*;
public class TestFlowLayout1{
    public static void main(String[] args){
        new Myframe().launchFrame();
    }
}
 
class Myframe extends Frame{
    public void launchFrame(){
        setBounds(100,100,300,300);
        FlowLayout layout = new FlowLayout
        (FlowLayout.CENTER,20,40);
        setLayout(layout);
        for(int i=0; i<7; i++){
            add(new Button("button"+(i+1)));
        }
        setVisible(true);
    }
}
import java.awt.*;
public class TestBorderLayout{
    public static void main(String[] args){
        new MyFrame().launchFrame
        ("Border Layout");
    }
}
 
class MyFrame extends Frame{
 
    public void launchFrame(String name){
        this.setTitle(name);
        Button b1 = new Button("N");
        Button b2 = new Button("S");
        Button b3 = new Button("W");
        Button b4 = new Button("E");
        Button b5 = new Button("C");
        add(b1,BorderLayout.NORTH);
        add(b2,BorderLayout.SOUTH);
        add(b3,BorderLayout.WEST);
        add(b4,BorderLayout.EAST);
        add(b5,BorderLayout.CENTER);
        setBounds(100,200,400,400);
        setVisible(true);
    }
}
import java.awt.*;
public class TestGridLayout{
    public static void main(String[] args){
        new MyFrame().launchFrame
        ("Grid Layout");
    }
}
 
class MyFrame extends Frame{
    public void launchFrame(String name){
        setTitle(name);
        for(int i=0; i<6; i++){
            add(new Button("button"+(i+1)));
        }
        setLayout(new GridLayout(3,2));
        pack();
        setVisible(true);
    }
}
import java.awt.*;
public class PracticeLayout{
    public static void main(String[] args){
        new MyFrame().launchFrame
        ("Practice Layout");
    }
}
 
class MyFrame extends Frame{
    public void launchFrame(String name){
        setTitle(name);
        setLayout(new GridLayout(2,1));
        Panel p1 = new Panel(new BorderLayout());
        Panel p11 = new Panel(new GridLayout(2,1));
        add(p1);
        Button b1 = new Button("b1");
        Button b2 = new Button("b2");
        p1.add(b1,BorderLayout.WEST);
        p1.add(b2,BorderLayout.EAST);
        Button b3 = new Button("b3");
        Button b4 = new Button("b4");
        p11.add(b3);
        p11.add(b4);
        p1.add(p11,BorderLayout.CENTER);
         
        Panel p2 = new Panel(new BorderLayout());
        add(p2);
        Panel p22 = new Panel(new GridLayout(2,2));
        Button b5 = new Button("b5");
        Button b6 = new Button("b6");
        p2.add(b5,BorderLayout.WEST);
        p2.add(b6,BorderLayout.EAST);
        p2.add(p22,BorderLayout.CENTER);
        Button b7 = new Button("b7");
        Button b8 = new Button("b8");
        Button b9 = new Button("b9");
        Button b10 = new Button("b10");
        p22.add(b7);
        p22.add(b8);
        p22.add(b9);
        p22.add(b10);
        setBounds(0,0,500,500);
        //pack();
        setVisible(true);
    }
}

Some event and inner class

import java.awt.*;
import java.awt.event.*;
public class TestActionListener{
    public static void main(String[] args){
        new MyFrame().launchFrame
        ("Action Event");
    }
}
 
class MyFrame extends Frame{
    void launchFrame(String name){
        setTitle(name);
        Button b = new Button("press me!");
        add(b);
        Monitor m = new Monitor();
        b.addActionListener(m);
        pack();
        setVisible(true);
    }
     
    class Monitor implements ActionListener{
        public void actionPerformed(ActionEvent e){
            System.out.println("A button has pressed!");
        }
    }
}
import java.awt.*;
import java.awt.event.*;
public class TestActionListener1{
    public static void main(String[] args){
        new MyFrame().launchFrame
        ("Action Event");
    }
}
 
class MyFrame extends Frame{
    void launchFrame(String name){
        setTitle(name);
        Button b = new Button("press me!");
        add(b);
        b.addActionListener(new ActionListener(){
            public void actionPerformed(ActionEvent e){
                System.out.println("A button has pressed!");
            }
        });
        pack();
        setVisible(true);
    }
}
import java.awt.*;
import java.awt.event.*;
 
public class TestActionListener2{
    public static void main(String[] args){
        new MyFrame().launchFrame
        ("Test Action Listener");
    }
}
 
class MyFrame extends Frame{
    void launchFrame(String name){
        setTitle(name);
        Button b1 = new Button("start");
        Button b2 = new Button("stop");
 
        Monitor m = new Monitor();
        b1.addActionListener(m);
        b2.addActionListener(m);
        //b2.setActionCommand("game over");
        add(b1,BorderLayout.NORTH);
        add(b2,BorderLayout.SOUTH);
        pack();
        setVisible(true);
    }
     
    class Monitor implements ActionListener{
        public void actionPerformed(ActionEvent e){
            System.out.println
            ("info : " + e.getActionCommand());
        }
    }
}
import java.awt.*;
import java.awt.event.*;
 
public class TestActionListener3{
    public static void main(String[] args){
        new MyFrame().launchFrame
        ("Test Text Field");
    }
}
 
class MyFrame extends Frame{
    void launchFrame(String name){
        setTitle(name);
        TextField tf = new TextField();
        add(tf);
        Monitor m = new Monitor();
        tf.addActionListener(m);
        pack();
        setVisible(true);
    }
     
    class Monitor implements ActionListener{
        public void actionPerformed(ActionEvent e){
            TextField tf =(TextField)e.getSource();
            System.out.println
            (tf.getText());
            tf.setText(null);
        }
    }
}
import java.awt.*;
import java.awt.event.*;
 
public class TestActionListener4{
    public static void main(String[] args){
        new MyFrame().launchFrame
        ("Test Text Field");
    }
}
 
class MyFrame extends Frame{
    void launchFrame(String name){
        setTitle(name);
        TextField tf = new TextField();
        add(tf);
        tf.addActionListener(new ActionListener(){
            public void actionPerformed(ActionEvent e){
                TextField tf =(TextField)e.getSource();
                System.out.println
                (tf.getText());
                tf.setText(null);
            }
        });
        pack();
        setVisible(true);
    }
}
import java.awt.*;
import java.awt.event.*;
 
public class TestActionListener5{
    public static void main(String[] args){
        new MyFrame().launchFrame
        ("Test Text Field");
    }
}
 
class MyFrame extends Frame{
    void launchFrame(String name){
        setTitle(name);
        setLayout(new FlowLayout());
        TextField tf1 = new TextField();
        Label label = new Label("+");
        TextField tf2 = new TextField();
        Button b = new Button("=");
        TextField tf3 = new TextField();
        add(tf1);
        add(label);
        add(tf2);
        add(b);
        add(tf3);
        b.addActionListener(new ActionListener(){
            public void actionPerformed(ActionEvent e){
                int i1 = Integer.parseInt(tf1.getText());
                int i2 = Integer.parseInt(tf2.getText());
                tf3.setText(""+(i1+i2));
            }
        });
        pack();
        setVisible(true);
    }
}
import java.awt.*;
public class TestPaint{
    public static void main(String[] args){
        new MyFrame().launchFrame
        ("Test Paint");
    }
}
 
class MyFrame extends Frame{
    public void launchFrame(String name){
        setTitle(name);
        setBounds(100,200,200,200);
        setVisible(true);
    }
     
    public void paint(Graphics g){
        Color c = g.getColor();
        g.setColor(Color.red);
        g.fillOval(50,50,40,40);
        g.setColor(Color.yellow);
        g.fillRect(20,40,60,80);
        g.setColor(c);
    }
}
import java.awt.*;
import java.awt.event.*;
import java.util.*;
public class TestMouseEvent{
    public static void main(String[] args){
        new MyFrame().launchFrame
        ("Test Mouse Event");
    }
}
 
class MyFrame extends Frame{
    ArrayList<Point> points = null;
    public void launchFrame(String name){
        points = new ArrayList<Point>();
        setTitle(name);
        setBounds(100,200,400,400);
        setBackground(Color.blue);
        setVisible(true);
        addMouseListener(new Monitor());
    } 
     
    public void paint(Graphics g){
        g.setColor(Color.red);
        Iterator<Point> i = points.iterator();
        while(i.hasNext()){
            Point p = i.next();
            g.fillOval(p.x,p.y,10,10);
        }
    }
     
    public void addPoint(Point p){
        points.add(p);
    }
     
    class Monitor extends MouseAdapter{
        public void mousePressed(MouseEvent e){
            MyFrame f = (MyFrame)e.getSource();
            f.addPoint(new Point(e.getX(),e.getY()));
            f.repaint();
        }
    }
}
import java.awt.*;
import java.awt.event.*;
public class TestWindowEvent{
    public static void main(String[] args){
        new MyFrame().launchFrame
        ("Test Window Event");
    }
}
 
class MyFrame extends Frame{
    public void launchFrame(String name){
        setTitle(name);
        setLayout(new GridLayout(2,1));
        Panel p1 = new Panel(new BorderLayout());
        Button b1 = new Button("top");
        Button b2 = new Button("bottom");
        Panel p2 = new Panel(new BorderLayout());
        p1.add(b1,BorderLayout.CENTER);
        p2.add(b2,BorderLayout.CENTER);
        add(p1);
        add(p2);
        pack();
        setVisible(true);
        addWindowListener(new WindowAdapter(){
            public void windowClosing(WindowEvent e){
                System.exit(-1);
            }
        });
    }
}
import java.awt.*;
import java.awt.event.*;
public class TestWindowEvent1{
    public static void main(String[] args){
        new MyFrame().lauchFrame
        ("Test Window Event");
    }
}
 
class MyFrame extends Frame{
    public void lauchFrame(String name){
        setTitle(name);
        Button b = new Button("Start");
        TextField tf = new TextField();
        add(b,BorderLayout.NORTH);
        add(tf,BorderLayout.SOUTH);
        pack();
        setVisible(true);
        b.addActionListener(new ActionListener(){
            private int i;
            public void actionPerformed(ActionEvent e){
                tf.setText(e.getActionCommand()+ ++i);
            }
        });
        addWindowListener(new WindowAdapter(){
            public void windowClosing(WindowEvent e){
                System.exit(-1);
            }
        });
    }
}
import java.awt.*;
import java.awt.event.*;
public class TestKeyEvent{
    public static void main(String[] args){
        new MyFrame().launchFrame
        ("Test Key Event");
    }
}
 
class MyFrame extends Frame{
    public void launchFrame(String name){
        setTitle(name);
        Button b = new Button
        ("How many times you press any key");
        TextField t = new TextField();
        add(b,BorderLayout.NORTH);
        add(t,BorderLayout.SOUTH);
        b.addKeyListener(new KeyAdapter(){
            private int i;
            public void keyPressed(KeyEvent e){
                t.setText(""+(++i));
            }
        });
        addWindowListener(new WindowAdapter(){
            public void windowClosing(WindowEvent e){
                System.exit(-1);
            }
        });
        pack();
        setVisible(true);
    }
}

Web Email Spider & Magnet Spider

EmailSpider

Run instance : java EmailSpider http://tieba.baidu.com/p/2314539885 D:\test.html

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;
import java.net.URL;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
public class EmailSpider {
     
    private static String emailR = 
            "\\w[-\\w.+]*@([A-Za-z0-9][-A-Za-z0-9]+\\.)+[A-Za-z]{2,14}";
    public static Pattern p = Pattern.compile(emailR);
 
    public static void main(String[] args) {
        String url = args[0];
        String pathname = args[1].replace(File.separatorChar,'/'); 
        WriteHtml(url,pathname);
        ReadEmail(pathname);
    }
     
    public static void WriteHtml(String url,String pathname){
        int c;
        try(Reader r = new InputStreamReader(
            new BufferedInputStream(
            new URL(url).openStream()));
                 
            Writer w = new OutputStreamWriter(
            new BufferedOutputStream(
            new FileOutputStream(
            new File(pathname))))
            ){
            while( (c = r.read()) != -1){
                //System.out.println(c);
                w.write(c);
                w.flush();
            }
             
        }catch(IOException e){
            //System.out.println("Connection error!");
            e.printStackTrace();
        }
    }
     
    public static void ReadEmail(String pathname){
        try(BufferedReader br = new BufferedReader(
            new InputStreamReader(
            new FileInputStream(new File(pathname))))
            ){
                String line = "";
                while( (line = br.readLine()) != null){
                    Matcher m = p.matcher(line);
                    while(m.find()){
                        System.out.println(m.group());
                    }
                }
                 
            }catch(IOException e){
                System.out.println("No such file!");
            }
        }
     
}

EmailSpiderModified

import java.io.*;
import java.util.regex.*;
import java.net.*;
public class EmailSpiderModified{
    private static String emailRegExp =
        "\\w[-\\w.+]*@([A-Za-z0-9][-A-Za-z0-9]+\\.)+[A-Za-z]{2,14}";
    private static Pattern p = Pattern.compile(emailRegExp);
    private static int counter;
     
    public static void main(String[] args){
         
        String url = args[0];
        emailFromRAM(url);
    }
     
    public static void emailFromRAM(String url){
        String line = null;
        try(BufferedReader br = new BufferedReader(
            new InputStreamReader(
            new URL(url).openStream()))
            ){
                while((line = br.readLine()) != null){
                     
                    //System.out.println(line);
                     
                    Matcher m =   p.matcher(line);
                    while(m.find()){
                        readEmail(m.group());
                        counter++;
                    }
                }
                System.out.println
                ( "本页面共计" + counter + "个Email!");
             
        }catch(IOException e){
            e.printStackTrace();
        }
    }
     
    public static void readEmail(String email){
        System.out.println(email);
    }
 
}

MagnetSpider

import java.io.*;
import java.util.regex.*;
import java.net.*;
public class MagnetSpider{
    private static String magnetRegExp =
        "magnet:\\?xt=urn:btih:[\\w]*";
    private static Pattern p = Pattern.compile(magnetRegExp);
    private static int counter;
     
    public static void main(String[] args){
         
        String url = args[0];
        emailFromRAM(url);
    }
     
    public static void emailFromRAM(String url){
        String line = null;
        try(BufferedReader br = new BufferedReader(
            new InputStreamReader(
            new URL(url).openStream()))
            ){
                while((line = br.readLine()) != null){
                     
                    //System.out.println(line);
                     
                    Matcher m =   p.matcher(line);
                    while(m.find()){
                        readEmail(m.group());
                        counter++;
                    }
                }
                System.out.println
                ( "本页面共计" + counter + "个磁链!");
             
        }catch(IOException e){
            e.printStackTrace();
        }
    }
     
    public static void readEmail(String email){
        System.out.println(email);
    }
 
}