本文目录一览：

怎样用java的正则表达式匹配这样的网址
急急急，小弟急求一个用java编写的应用程序，求大神，重谢
java代码解析
[JAVA多线程编程题两个案例，不会写，求大神写出代码，万分感谢，多线程还没学。](#JAVA多线程编程题两个案例，不会写，求大神写出代码，万分感谢，多线程还没学。)
如何利用Java语言实现消息推送到手机app
[高分:求案例代码:java Socket 加请求参数,访问http服务端,并打印返回的数据!](#高分:求案例代码:java Socket 加请求参数,访问http服务端,并打印返回的数据!)

怎样用java的正则表达式匹配这样的网址

Java中正则表达式匹配的语法规则：以下是整理出来的Java下运用正则表达式实现匹配的程序案例，代码如下：

package org.luosijin.test;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
 * 正则表达式
 * @version V5.0
 * @author Admin
 * @date 2015-7-25
 */
public class Regex {
    /**
     * @param args
     * @author Admin
     * @date 2015-7-25
     */
    public static void main(String[] args) {
        Pattern pattern = Pattern.compile("b*g");
        Matcher matcher = pattern.matcher("bbg");
        System.out.println(matcher.matches());
        System.out.println(pattern.matches("b*g","bbg"));
        //验证邮政编码
        System.out.println(pattern.matches("[0-9]{6}", "200038"));
        System.out.println(pattern.matches("\\d{6}", "200038"));
        //验证电话号码
        System.out.println(pattern.matches("[0-9]{3,4}-?[0-9]+", "02178989799"));
        getDate("Nov 10,2009");
        charReplace();
        //验证身份证:判断一个字符串是不是身份证号码，即是否是15或18位数字。
        System.out.println(pattern.matches("^\\d{15}|\\d{18}$", "123456789009876"));
        getString("D:/dir1/test.txt");
        getChinese("welcome to china,江西奉新,welcome,你!");
        validateEmail("luosijin123@163.com");
    }
    /**
     * 日期提取:提取出月份来
     * @param str
     * @author Admin
     * @date 2015-7-25
     */
    public static void getDate(String str){
        String regEx="([a-zA-Z]+)|\\s+[0-9]{1,2},\\s*[0-9]{4}";
        Pattern pattern = Pattern.compile(regEx);
        Matcher matcher = pattern.matcher(str);
        if(!matcher.find()){
            System.out.println("日期格式错误!");
            return;
        }
        System.out.println(matcher.group(1)); //分组的索引值是从1开始的，所以取第一个分组的方法是m.group(1)而不是m.group(0)。
    }
    /**
     * 字符替换:本实例为将一个字符串中所有包含一个或多个连续的“a”的地方都替换成“A”。
     * 
     * @author Admin
     * @date 2015-7-25
     */
    public static void charReplace(){
        String regex = "a+";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher("okaaaa LetmeAseeaaa aa booa");
        String s = matcher.replaceAll("A");
        System.out.println(s);
    }
    /**
     * 字符串提取
     * @param str
     * @author Admin
     * @date 2015-7-25
     */
    public static void getString(String str){
        String regex = ".+/(.+)$";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);
        if(!matcher.find()){
            System.out.println("文件路径格式不正确！");
            return;
        }
        System.out.println(matcher.group(1));
    }
    /**
     * 中文提取
     * @param str
     * @author Admin
     * @date 2015-7-25
     */
    public static void getChinese(String str){
        String regex = "[\\u4E00-\\u9FFF]+";//[\\u4E00-\\u9FFF]为汉字
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);
        StringBuffer sb = new StringBuffer();
        while(matcher.find()){
            sb.append(matcher.group());
        }
        System.out.println(sb);
    }
    /**
     * 验证Email
     * @param email
     * @author Admin
     * @date 2015-7-25
     */
    public static void validateEmail(String email){
        String regex = "[0-9a-zA-Z]+@[0-9a-zA-Z]+\\.[0-9a-zA-Z]+";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(email);
        if(matcher.matches()){
            System.out.println("这是合法的Email");
        }else{
            System.out.println("这是非法的Email");
        }
    }
}

急急急，小弟急求一个用java编写的应用程序，求大神，重谢

//代码是楼上的，帮你排了一下版。
public class Account {
    private int id;
    private double balance;
    private double annuallnterestRate;
    private Date dateCreated;
    public Account() {
        this.id = 0;
        this.balance = 0;
        this.annuallnterestRate = 0;
        this.dateCreated = new Date();
    }
    public Account(int id, double balance) {
        this.id = id;
        this.balance = balance;
        this.dateCreated = new Date();
    }
    public int getId() {
        return this.id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public double getBalance() {
        return this.balance;
    }
    public void setBalance(double balance) {
        this.balance = balance;
    }
    public double getAnnuallnterestRate() {
        return this.annuallnterestRate;
    }
    public void setAnnuallnterestRate(double annuallnterestRate) {
        this.annuallnterestRate = annuallnterestRate;
    }
    public Date getDateCreated() {
        return this.dateCreated;
    }
    public double getMonthlyInterestRate() {
        double monthlyInterest = java.lang.StrictMath.pow(
            this.annuallnterestRate, 1.0 / 12) - 1;
        return monthlyInterest;
    }
    public String withdraw(double amount) {
        this.balance = this.balance - amount;
        return "withdraw success";
    }
    public String deposit(double amount) {
        this.balance = this.balance + amount;
        return "deposit success";
    }
    public static void main(String[] args) {
        Account account = new Account(1122, 20000.00);
        account.setAnnuallnterestRate(0.045);
        account.withdraw(2500.00);
        account.deposit(3000.00);
        System.out.println(account.getBalance());
        System.out.println(account.getMonthlyInterestRate());
        System.out.println(account.getDateCreated());
    }
}

java代码解析

一楼的说的够全面了,不过稍有误解. 再来表示抱歉,我对编程语言中的中文名词非常不了解,所以如果以下的回复对你的阅读或者理解造成困难,请见谅.

首先,要明白这个问题的答案,需要了解call (pass) by value 和 call (pass) by reference 的区别.简单来说:
- call by value通常是复制这个parameter的值去另外一块内存里,然后传给function,所以在method/function里边对这个变量的所有变更,实际上都是对复制过来的镜像进行操作,不会对原本的variable有任何影响.
- call by reference是将parameter的reference传给function,简单点理解就是直接把variable传给function.所以说这个variable的值是可以被function改变的.这个用法在c/c++中非常常见,用法是variable_name.
再来,在Java里边,你可以很简单的理解为: Java中只有call by value,也就是说,所以所有传给function的parameter本身都不会被改变. (这是最简单直白的理解,当然也有另一种常从sun的人那边听到的说法:Java是call by value + call by reference by value)
那么现在的问题就是为什么第二个结果是2了. 首先说一下sun官方的解释: 对于reference type在作为parameter/argument的时候,也是call by value,但是在你拥有足够权限时(比方说那个变量是public的,不是final的等等各种符合的情况),可以修改这个object中fields的值(也就是属于这个object(严谨点讲是an instance of the object) 内部的变量,在你的例子中, ko 里边的 a 就是一个field,所以update(ko)会使ko.a变成2)。
如果你是一个有过c/c学习经验的人或者你以上的解释很难理解,以下这种说法或许更适合你 (当然了,这只是大多包括我在内有c经验的人的一种理解方式) 这里可以引入一个新的概念,pointer.这是一种比较特殊的变量,它内部所储存的东西,其实只是另外一个变量的内存地址.如果对内存没有概念,你可以把它简单理解为是风筝的线轴,虽然看它本身看不出什么端倪,但是顺着摸过去总会找到风筝,看到它是什么样子.以pointer方式理解Java的人,通常会说: Type variable = new Type(); 这个过程中,最后生成的这个variable其实就是一个pointer,而不是instance本身. 在Java中,有c/c经验的人通常认为Java是call by value.同时,当一个变量用在储存reference type的时候,实际上储存的是它的pointer,这也一样可以解释为什么ko.a会有2这个结果,因为虽然pointer被传到function里边时,本身是call by value,无法被改变.但这并不影响function本身对这个pointer指向的object的内容做任何改变.当然,再次声明,这只是一种帮助有c/c++经验的人理解的方法.Sun本身严正声明Java里边没有pointer这个东西的存在.
再来解释一下为什么说楼上所说的(或者说楼上引用的)理解略有偏差. 引用"我们上面刚学习了JAVA的数据类型，则有：值类型就是按值传递的，而引用类型是按引用传递的"这句话很明显的有两点错误.第一点,如果我上面所说的,Java是没有call by reference的. 第二点,暂且假设Java里边是有call by reference的,这句话依然不成立. Java中的变量有两种类型: primitive types 和 reference type. primitive type包括byte, short, int, long, char, boolean, float和double. 而这8种之外的所有的,都是reference type. 下面是一段对你的贴上来的code的一点延伸,希望可以帮助你更好的理解Java中的argument / parameter到底是如何运作的.

public class Test {
    public static void main(String[] args) {
        int a = 1;
        Koo koo = new Koo();
        Object o = new Integer(1);
        Koo newKoo = new Koo();
        update(a);
        update(koo);
        update(o);
        update(newKoo);
        newUpdate(newKoo);
        System.out.println(a);
        System.out.println(koo.a);
        System.out.println(o);
        System.out.println(newKoo.a);
    }
    static void update(int a) {
        a++;
    }
    static void update(Koo koo) {
        koo.a++;
    }
    static void update(Object o) {
        o = (int)(Integer.parseInt(o.toString()) + 1);
    }
    static void newUpdate(Koo koo) {
        koo = new Koo();
    }
}
class Koo {
    int a = 1;
}

/* 
o = (int)(Integer.parseInt(o.toString()) + 1); 这一行中的(int)纯粹是多余的,是否有这个casting对code本身没有任何影响. 如果你高兴也可以用
o = new Integer(Integer.parseInt(o.toString()) + 1);
或者干脆
o = Integer.parseInt(o.toString()) + 1;
*/

以上这些code运行之后会得到1 2 1 2的结果. 后面两个结果可以很好的说明,即使对objects (reference type variables)来看,Java所应用的也并不是call by reference.否则的话,以上code运行结果应该是1 2 2 1 希望你可以真正理解这个新的例子中,产生1212这个结果的原因,从而对Java中的arguments有一个系统全面的认识. 图片是相关资料的链接,知道里貌似不能加网址

JAVA多线程编程题两个案例，不会写，求大神写出代码，万分感谢，多线程还没学。

class A extends Thread {
    public void run() {
        try {
            Thread.sleep(1000);
        } catch(Exception e) {
            System.out.println("A ERROR!");
        }
        System.out.println("AAAA");
    }
}
class B extends Thread {
    public void run() {
        try {
            Thread.sleep(2000);
        } catch(Exception e) {
            System.out.println("B ERROR!");
        }
        System.out.println("BBBB");
    }
}
class C extends Thread {
    public void run() {
        try {
            Thread.sleep(3000);
        } catch(Exception e) {
            System.out.println("C ERROR!");
        }
        System.out.println("CCCC");
    }
}
public class Test_1 {
    public static void main(String[] args) {
        A a = new A();
        B b = new B();
        C c = new C();
        a.start();
        b.start();
        c.start();
    }
}

public class Test_1 {
    public static void main(String[] args) {
        A a = new A();
        B b = new B();
        C c = new C();
        Thread ta = new Thread(a);
        Thread tb = new Thread(b);
        Thread tc = new Thread(c);
        ta.start();
        tb.start();
        tc.start();
    }
}
class A implements Runnable {
    public void run() {
        try {
            Thread.sleep(1000);
        } catch(Exception e) {
            System.out.println("A ERROR!");
        }
        System.out.println("AAAA");
    }
}
class B implements Runnable {
    public void run() {
        try {
            Thread.sleep(2000);
        } catch(Exception e) {
            System.out.println("B ERROR!");
        }
        System.out.println("BBBB");
    }
}
class C implements Runnable {
    public void run() {
        try {
            Thread.sleep(3000);
        } catch(Exception e) {
            System.out.println("C ERROR!");
        }
        System.out.println("CCCC");
    }
}

案例一的两种方法已经写好；现在有事，晚上再把案例二代码写一下，应该没关系吧！抱歉，是一个线程类，我看错了，晚上重发一下代码！

如何利用Java语言实现消息推送到手机app

首先APP后台就得有这样的轮询程序，比如每次打开app时触发，比如每隔10分钟触发，每次触发就调用下服务器端的服务，服务端去拉取要推送的信息，或者知道对方的手机号或微信号，那就直接调用短信接口或直接发送微信信息了。极光推送服务是一款免费的第三方推送消息的平台。极光推送从整体来说还不错，具有以下优势：

开放注册，免费向所有的开发者开放使用。
极光推送 - JPush SDK JPush 是经过考验的大规模 App 推送平台，每天推送消息量级为数百亿条。开发者集成 SDK 后，可以通过调用 API 推送消息。同时，JPush 提供可视化的 web 端控制台发送通知，统计分析推送效果。
开发者可以轻松地通过极光发送各个移动平台的系统通知，还可以在控制台编辑多种富文本展示模板；极光还提供自定义消息的透传，客户端接到消息内容后根据自己的逻辑自由处理。
7*24小时专人专线服务：专属安全团队支持，24 小时随时响应，免除后顾之忧。极光是一个不错的选择，深圳市和讯华谷信息技术有限公司（极光 Aurora Mobile，纳斯达克股票代码：JG）成立于2011年，是中国领先的开发者服务提供商，专注于为开发者提供稳定高效的消息推送、一键认证以及流量变现等服务，助力开发者的运营、增长与变现。同时，极光的行业应用已经拓展至市场洞察、金融风控与商业地理服务，助力各行各业优化决策、提升效率。

高分:求案例代码:java Socket 加请求参数,访问http服务端,并打印返回的数据!

import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
import java.net.*;
import java.io.*;
public class Client extends JFrame {
    private static final long serialVersionUID = -4733717749265129757L;
    Container con = null;
    JTextArea jta = null;
    JTextField jtf = null;
    Socket s = null;
    Client(String ip, int port) {
        try {
            s = new Socket(ip, port); // 创建一个流套接字并将其连接到指定 IP 地址的指定端口号。
            launchFrame();
        } catch (Exception e) {
            e.printStackTrace();
        }
        new Thread(new ClientR()).start();
    }
    public void sent(String str) { // 发送消息方法
        try {
            DataOutputStream dos = new DataOutputStream(s.getOutputStream()); // 创建一个新的数据输出流，将数据写入指定 返回s的套接字的输出流。
            dos.writeUTF(str);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public void disconnect() throws Exception {
        s.close(); // 失去连接，关闭线程s
    }
    class ClientR implements Runnable { // 客户端运行
        public void run() {
            try {
                DataInputStream dis = new DataInputStream(s.getInputStream()); // 使用指定的底层 s.getInputStream（s的套接字的输入流） 创建一个 DataInputStream(数据输入流）
                String str = dis.readUTF();
                while (true) {
                    jta.append(str + "\n");
                    str = dis.readUTF();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    public void startClient() { // 客户端启用
        try {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); // 读取数据流
            String str = br.readLine();
            System.out.println(str);
            while (true) {
                sent(str); // 发送数据
                if (str.equals("q")) { // 如果读取的字符为q
                    disconnect(); // 断开连接
                    return;
                }
                str = br.readLine();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public void launchFrame() throws IOException { // 客户端面板布局
        con = this.getContentPane();
        jta = new JTextArea();
        jtf = new JTextField();
        final JTextField jtf1 = new JTextField(10);
        final JButton jb = new JButton("确认");
        Panel p = new Panel();
        JLabel jl = new JLabel();
        jl.setText("your name:");
        jtf1.setBackground(Color.PINK);
        jtf1.setBounds(10, 10, 10, 10);
        p.add(jl);
        p.add(jtf1);
        p.add(jb);
        jb.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                e.getActionCommand();
                jtf.setText(jtf1.getText().toString() + "say:");
            }
        });
        jta.setBackground(Color.LIGHT_GRAY);
        jta.setEditable(false); // 不可编辑文本域
        JScrollPane jsp = new JScrollPane(jta, // jta上滚动条的创建
                JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,
                JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
        con.add(jsp, BorderLayout.CENTER);
        con.add(p, BorderLayout.NORTH);
        con.add(jtf, BorderLayout.SOUTH);
        jtf.addActionListener(new ActionListener() { /// 事件监听
            public void actionPerformed(ActionEvent e) {
                String str = jtf.getText().toString();
                Client.this.sent(str);
                jtf.setText(jtf1.getText().toString() + "say:");
            }
        });
        this.setTitle("聊天客户端，袭风版");
        this.setBounds(200, 200, 300, 400);
        this.setDefaultCloseOperation(EXIT_ON_CLOSE);
        this.setBackground(Color.blue);
        this.setVisible(true);
    }
    public static void main(String[] args) {
        System.out.println("===1");
        Client cli = new Client("127.168.1.1", 3456); // 创建一个客户端，并将其连接到指定 IP 地址的指定端口号，其端口号与服务器端一致。与服务器建立连接
        System.out.println("===2");
        cli.startClient(); // 127.0.0.1为本机端口
    }
}

import java.net.*;
import java.io.*;
import java.util.*;
import javax.swing.*;
import java.awt.*;
public class Server extends JFrame {
    private static final long serialVersionUID = 4130666237241201704L;
    Container con = null; // 容器
    JTextArea jta = null; // 文本区
    ServerSocket ss = null; // 初始化服务器套接字
    ArrayList al = new ArrayList(); // ArrayList容器
    Server(int port) { // 构造函数
        try {
            ss = new ServerSocket(port); // 创建绑定到特定端口的服务器套接字。
        } catch (Exception e) {
            e.printStackTrace();
        }
        launchFrame();
    }
    public void severStart() { // 线程开始
        while (true) {
            try {
                Socket s = ss.accept(); // 侦听并接受到此套接字(port)的连接。
                al.add(new ServerR(s));
                jta.append("New Client:" + "\n Ip: " + s.getInetAddress() + ":" + s.getPort() + "\n" // 得到客户端本地地址，端口和客户端数量
                        + "Clients count:" + al.size() + "\n");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    class ServerR implements Runnable {
        Socket s = null; // 创建新服务线程
        ServerR(Socket s) {
            this.s = s;
            new Thread(this).start(); // 启动新线程
        }
        public void sent(String str) { // 发送数据流方法
            try {
                DataOutputStream dos = new DataOutputStream(s.getOutputStream()); // 从s套接字中读出输出数据流
                dos.writeUTF(str); // 使用 UTF-8 修改版编码将一个字符串写入基础输出流。
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        public void run() {
            try {
                DataInputStream dis = new DataInputStream(s.getInputStream());
                String str = dis.readUTF(); // 读出输入的数据流
                while (true) {
                    Iterator ite = al.iterator(); // 生成list迭代器
                    while (ite.hasNext()) { // 如果仍有可迭代的元素，返回true
                        ((ServerR) ite.next()).sent(str); // 返回(ServerR)的下一个元素，并发送它
                        // 先遍历ServerR中的所有线程
                    }
                    str = dis.readUTF();
                }
            } catch (Exception e) {
                try { // 客户端关闭捕捉
                    s.close(); // 关闭一个相关客户端线程
                    al.remove(this); // 从迭代器指向的集合中移除迭代器返回的最后一个元素
                    jta.append("A client quit!\nClients count:" + al.size() + "\n"); // 统计客户端现有的数量
                } catch (Exception e2) {
                    e2.printStackTrace();
                }
                e.printStackTrace();
            }
        }
    }
    public void launchFrame() { // 服务器端面板布局
        con = this.getContentPane();
        jta = new JTextArea();
        jta.setEditable(false); // 不可编辑文本域
        JScrollPane jsp = new JScrollPane(jta,
                JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,
                JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
        con.add(jsp, BorderLayout.CENTER);
        this.setTitle("聊天服务端，袭风版");
        this.setBounds(200, 200, 300, 400);
        this.setDefaultCloseOperation(EXIT_ON_CLOSE);
        this.setVisible(true);
    }
    public static void main(String[] args) {
        Server s = new Server(3456); // 创建服务器S 端口为3456
        s.severStart();
    }
}

java透传案例代码,什么是源码透传