java学习之java高级特性------正则表达式，File类，观察者模式，输入输出流（部分）

观察者模式：

   定义了一种一对多的依赖关系，让多个对象同时监听一个主题对象，当这个主题对象发生变化时，就会通知所有观察者对象，让他们自己发生更新。

import java.util.Observable;

public class House extends Observable {

    private float price;

    public House() {
    }

    public float getPrice() {
        return price;
    }

    public void setPrice(float price) {
        //调用父类 设置变化点
        super.setChanged();
        //价格变化，呈现给所有观察者
        super.notifyObservers(price);
        this.price = price;
    }

    @Override
    public String toString() {
        return "House{" +
                "price=" + price +
                '}';
    }

    public House(float price) {
        this.price = price;
    }
}

import java.util.Observable;
import java.util.Observer;

public class PersonObservable implements Observer {


   private String name;

    public PersonObservable() {
    }

    public PersonObservable(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void update(Observable o, Object arg) {
        //参数o：观察者对象   arg 修改的内容
        if(arg instanceof Float){
         //   System.out.println(this.name+"观察到的价格是："+(Float)((Float) arg).floatValue());
            System.out.println(this.name+"观察到的价格是："+arg);

        }
    }
}


public class test {

    public static void main(String[] args) {
        House house = new House(12000);
        PersonObservable po1 = new PersonObservable("1");
        PersonObservable po2 = new PersonObservable("2");
        PersonObservable po3 = new PersonObservable("3");

        house.addObserver(po1);
        house.addObserver(po2);
        house.addObserver(po3);
        System.out.println(house);
        house.setPrice(13500);

        System.out.println(house);



    }

}

正则表达式：

匹配数据，进行字符串验证、替换功能

 

^ : 匹配字符串的开始

$ ：匹配字符结束

*:  匹配一个字符0次或多次

+：一次或多次

？：匹配0次或一次

{n}:  负整数，匹配n次

{n,}:  负整数，匹配大于等于n次

{n,m}   至少匹配n次最多匹配m次

\d : 代表数字

\w: 代表字符

package c0801zhengze;

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

public class Test {


    public static void main(String[] args) {
        boolean flag = true;
        String str = "123456789";
        char c[] = str.toCharArray();
        for (int i =0;i<c.length;i++){
            if (!Character.isDigit(c[i])){
                flag = false;
                break;
            }
        }
        System.out.println(flag);


        /**
         * 正则表达式
         * 使用正则表达式  需要依赖 pattern类和matcher类
         * pattern：主要进行正则规范的编写
         * matcher：主要是执行规范
         */
        String Str1="1234567890";
        if(Pattern.compile("[0-9]+").matcher(Str1).matches()){
            System.out.println("数字构成");
        }
        else System.out.println("no");


        /**
         *
         * 验证日期格式  2019-08-01
         * \d{4}-\d{2}-\d{2}
         */
        String  a = "2019-08-01";

        String pat = "\\d{4}-\\d{2}-\\d{2}";
        //20[0,1]\d{1}-
        Pattern p = Pattern.compile(pat);
        Matcher m = p.matcher(a);

        if(m.matches()){
            System.out.println("正确");
        }
        else{
            System.out.println("不正确");
        }


        /**
         *
         * 拆分字符串（正则表达式）
         */
//        String u= "a1b2c33333d4444g5556";
//        String  patt = "\\d+";
//        p = Pattern.compile(patt);
//        String []s = p.split(u);
//        System.out.println(s.length);
//        for (String t:s
//             ) {
//            System.out.println(t);
//
//        }

        /*
         * 拆分字符串（正则表达式）
         */
//        String u= "a1b2c33333d4444g5556";
//        String  patt = "\\d";
//        p = Pattern.compile(patt);
//        Matcher matcher = p.matcher(u);
//        String newString = matcher.replaceAll("_");
//        System.out.println(newString);

        /**
         * 从键盘上输入一组小写字母，保存在str中
         * 将下标为奇数的小写字母转换为大写字母 输出结果
         */
        Scanner input  = new Scanner(System.in);
        System.out.println("输入字符串");
        String f = new String();
        f = input.next();
        char []chars = f.toCharArray();
        for(int i = 1;i<chars.length;i+=2){
            if(Character.isLowerCase(chars[i])){
                chars[i] = Character.toUpperCase(chars[i]);
            }
        }
           f = new String(chars);
        System.out.println(f);
        System.out.println(chars);

//        String  patt = "[a-z]  ";
//        p = Pattern.compile(patt);
//        Matcher matcher = p.matcher(f);
//        String newString = matcher.replaceAll("_");
//        System.out.println(newString);

    }
}

输入输出流:

为什么需要输入输出：

   现实中的交互发生在程序与硬件之间，或者程序与程序之间，他们之间需要信息传递就需要流

     常见的输入输出设备：键盘，打印机，屏幕

 

File 类：

   Java.io.File : 代表硬盘上的一个文件或目录

 

创建File 对象  有参构造（地址）

相对路径和绝对路径

package File_test;

import java.io.*;

public class Test_File {
    public static void main(String[] args) throws IOException {
        File file = new File("d:/text.txt");
        byte a[] = new byte[1024];
        InputStream in = new FileInputStream(file);

        a = in.readAllBytes();
      //  System.out.println('\n'+file.getAbsolutePath());
       // System.out.println(file.getPath());
        String s = new String(a);
        System.out.println(s);
        s = s + "00000000000000000000000000000000\n\n\n";

        byte f[] = s.getBytes();
        in.close();
        OutputStream out = new FileOutputStream(file);
        out.write(f);
        out.close();
    }


    }