疯狂Java学习笔记(015)

一、正则表达式

1.含义：有特定规则的字符串

2.字符：

• 　　　　a　　  :匹配字符本身
• 　　　　 　　:回车符
• 　　　　 　　:换行符
• 　　　　 　　:tab键

3.一个范围内取一个字符

• [abc]　　:abc中任意匹配一个
• [a-z]　　 :匹配小写字符
• [A-Z]　　:匹配大写字符
• [0-9]　　:匹配数字字符-简写为：d:
• [a-zA-Z_0-9]　　:单词字符- 简写为：w:　　

4.单词边界

　　　　　　:非单词字符的任意一个

5.数量匹配

• X{n}:指定出现n次  如：a{4}:aaaa
• X{n,}:至少出现n次 如：[abc]{3}:aaa bbb ccc aab
• X{n,m}:至少n次，至多m次
• X?:0次或1次
• X+：至少1次
• X*：任意次

6.regex传参，查看jdk的帮助文档，凡是参数是String类型，参数名是regex，基本都可以传递正则表达式。

7.正则表达式的替换

           

　　replaceAll(String regex,String replacement);

　　replaceFirst(String regex,String replacement);

8.正则表达式切割

         

　　split(String regex)

9.Pattern和Matcher类

　　正则表达式应用：获取匹配内容

　　Pat

　　作用：Pattern和Matcher类主要是用来提取符合正则表达式规则的字符串的。

　　　　String s = "abc aac adcd bom";//编译正则表达式

       　　Pattern p = Pattern.compile("a\w*"); //获取匹配器对象

      　　 Matcher m = p.matcher(s);//使用匹配器获取符合条件的内容

      　　 while(m.find()){

         　　  String res = m.group();

        　　   System.out.println(res);

  　　     }

 　　主要用的是Matcher类的两个方法：

①boolean  find( ) :该方法判断是否有下一个符合条件的字符串

②String group( ) :该方法获取上一个匹配的字符串

 10.正则表达式的特殊匹配

　　路径的分隔符：

• 例如：c:\code14\day15
• 路径中的本身需要转义，这样在路径中就出现了\表示一个
• 在正则表达式中需要使用\\才能匹配\

　　字符串中的点号：

例如：abc.def.ghi,路径分隔符必须是左斜线\

使用：\.才能匹配.本身

二、System类

1.常用方法：基本都是静态的！

2.构造方法私有化，就是不能new

3.三种：

• void gc():
• void array(Object src,int startPos,Object dest,int startPos,length); 
• long currentTimeMillis():返回当前系统时间的毫秒值表示形式，即从1970-01-01午夜0点开始的毫秒值，但需要注意本机的时区。
• void exit(int status):退出虚拟机。底层调用的是Runtime类的exit（int status）方法。

4.Runtime类是典型的单例设计模式

• 私有化构造方法
• 成员位置保持一个本类的实例对象
• 提供一个获取该成员变量的方法。

三、java.util.Date日期类：

1.构造方法：

• Date():使用当前系统时间构建一个Date对象！
• Date(long time):使用指定的毫秒值构建一个Date对象！

2.常用方法：

• long getTime():获取当前对象表示的时间点和时间原点之间的毫秒之差，1000毫秒等于1秒，时间原点是1970年1月1日。
• void setTime(long time):用指定的参数设置当前对象表示的毫秒值。

3.直接打印Date对象的格式如下：

　　Tue Nov 06 11 15:14:33   CST  2018

　　说明Date类已经重写了toString方法，但是依然不符合阅读习惯。

　　可以使用SimpleDateFormat类对Date对象进行格式化。　　

四、简单日期格式化类：SimpleDateFormat

1.构造方法：

　　SimpleDateFormat（String pattern）:　通过格式字符串创建一个SimpleDateFormat对象。

2.常用方法：

　　①格式化：将Date对象格式化成指定格式的字符串！String format(Date date)：

　　②解析：将字符串用指定格式解析成Date对象！Date parse(String format):

3.日期工具类的封装：

　　日期对象和字符串之间的转换时比较常用的操作，通常会把常用的操作封装成工具类供使用。

4.封装工具类如果遇到有异常：

　　推荐用将异常暴露给调用者，让调用者字节决定如何处理。当然也可以try catch。

五、Canlendar日历类

• 1.不能new,Canlendar本身是一个抽象类，不能直接new对象。
• 2.但提供了一个getInstance()方法，用于获取一个子类的对象。
• 3.最大的好处：方便操作日历的字段！
• 4.语句：　　

Calendar c = Calendar.getInstance();//获取一个当前系统时间对应的日历对象！

System.out.println(c.get(Calendar.YEAR));//获取年字段值

System.out.println(c.get(Calendar.MONTH));//获取月份字段值，月份是从0开始

System.out.println(c.get(Calendar.DAY_OF_MONTH));//获取月份中的天数字段值

System.out.println(c.get(Calendar.HOUR));//获取小时字段值

System.out.println(c.get(Calendar.MINUTE));//获取分种字段值

System.out.println(c.get(Calendar.SECOND));//获取秒字段值

　　　　　　　　　　　　　　（月份有点特别，因为最小值为0，最大值为11）

　　　　add:当前超出范围时，会引发上级字段发生变化。

　　　　roll:当值超出范围时，不会引发上级字段发生变化

六、数组的高级应用：排序！（重点哦）

　　选择排序（select sort）,也称比较排序（compare sort）　　

　　原理：依次把每个元素和其后所有的元素比较，发现比当前元素小的元素，就交换两个元素。从前往后，一次确定每个位置上的元素的值！

　　需要确定位置的元素个数和比较的趟数都是元素的个数-1；　　

     

 　　由于每次确定一个元素，有可能发生多次交换。

　　优化措施：每次遍历，先记录下当前元素的索引，然后遇到比当前元素小的元素，只记录元素的索引，在内层循环外部，判断是否需要交换！

       

 七、数组排序：冒泡排序：bubble sort

public static void bubbleSort(int[] arr){

　　for(int i = 0 ;i<arr.length-1;i++){

　　　　for(int j = 0;j<arr.length-1-i;j++){

　　　　　　if(arr[j]>arr[j+1]){

　　　　　　　　int temp = arr[j];

　　　　　　　　arr[j] = arr[j+1];

　　　　　　　　arr[j+1]= temp

　　　　　　}

　　　　}

　　}

}

优化算法加flag标志位

public static void bubbleSort(int[] arr){
    for(int i = 0;i<arr.length-1;i++){
        boolean flag = true;
        for(int j = 0;j<arr.length - 1 - i;j++){
            if(arr[j] > arr[j+1]){
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
                flag = false;
            }
        }
        if(flage){
            break;
        }
    }
}

八、二分查找

二分查找也称折半查找，binanary search 

前提：数组是从小到大排序好的！

注意：返回值不一定是第一次出现的所引值！！

public static int binarySearch(int[] arr,int value){
    int min = 0;
    int max = arr.length - 1;
    int mid = (max + min) / 2;
    while(true){
        if(arr[mid] > value){
            max = mid - 1;
        }else if(arr[mid] < value){
            min = mid + 1;
        }else{
            return mid;
        }
        //
        mid = (max + min) / 2;
        if(min > max){
            return -1;
        }
    }
}

九、数组工具类Arrays

常用方法：

toString（）：格式化数组里元素，数组前后加[ ],元素之间用逗号分隔

sort（XXX）:从小到大排序,若想实现由大到小排序，先调用sort方法，然后自己再逆序

binarySearch(XXX)：返回值不一定是元素第一次出现的索引，如果不存在返回值是负数。

代码部分：

1.设计一个方法,将一个字符串中的大小写字符进行反转:即:大写改小写,小写改大写!

package com.test1;
/*
 * 设计一个方法,将一个字符串中的大小写字符进行反转:即:大写改小写,小写改大写!
 */
public class Demo {

    public static void main(String[] args) {
        String s = "abcDEF中文+-*/";
        String res = change(s);
        System.out.println(res);
    }
    
    
    //自定义方法:
    //返回值类型:反转之后的字符串
    //形参列表:要操作的字符串
    public static String change(String s){
        //遍历字符串
        char[] chs = s.toCharArray();
        for (int i = 0; i < chs.length; i++) {
            if(Character.isUpperCase(chs[i])){
                chs[i] = Character.toLowerCase(chs[i]);
            }else if(Character.isLowerCase(chs[i])){
                chs[i] = Character.toUpperCase(chs[i]);
            }
        }
        return new String(chs);
    }

}

2.判断字符串是否符合规则:①判断手机号是否合格；②QQ号码是否合格。

package com.test1;
/*
 * 判断字符串是否符合规则:
 * 
 */
public class NumDemo2 {

    public static void main(String[] args) {
        String num = "12a34567";
        //System.out.println(check(num));
        System.out.println(check2(num));
        
    }
    
    //判断手机号是否合格:
    /*
     * 1.以1开头
     * 2.11位
     * 3. 第二位是: 3 5 8 7 
     * 
     */

    
    //使用正则表达式判断字符串的格式
    public static boolean check2(String num){
//        boolean b = num.matches("[1][3587][0-9]{9}");
//        return b;
        return num.matches("[1-9][0-9]{5,9}");
    }
    
    //判断一个字符串是否符合QQ号码的规则:
    //1.都是数字字符
    //2.不能以0开头
    //3.长度6-10
    public static boolean check(String num){
        //判断长度
        if(num.length() >= 6 && num.length() <= 10){
            //判断是否以0开头
            if(!num.startsWith("0")){
                //判断是否都是数字!
                char[] chs = num.toCharArray();
                for (int i = 0; i < chs.length; i++) {
                    if(!Character.isDigit(chs[i])){
                        return false;
                    }
                }
                //
                return true;
            }
        }
        return false;
    }

}

3.使用正则表达式切分字符

package com.test1;
/*
 * 
 * 使用正则表达式切分字符串
 * 
 * String s = "hello?nihao+nice to meet you	 world";
 * 
 */
class Demo4 {
    public static void main(String[] args) {
        String s = "hello world    nihao nice to meet you";
        String[] words = s.split(" +");
        for (int i = 0; i < words.length; i++) {
            System.out.println(words[i]);
        }
    }
}

4.关于Matcher和Pattern方法的使用

package com.test1;

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

public class Demo5 {
    public static void main(String[] args) {
        /*
        //将正则表达式编译成Pattern对象
        Pattern p = Pattern.compile("a*b");
        //调用matcher方法区匹配字符串,返回值是一个匹配器
        Matcher m = p.matcher("aaaaab");
        //调用匹配器的matches方法,判断是否符合规则!
        boolean b = m.matches();
        System.out.println(b);
        
        //直接调用字符串的matches方法,也可以判断字符串是否匹配
        System.out.println("aaaaab".matches("a*b"));
        */
        /*
        //Pattern和Matcher类主要是用来提取符合正则表达式规则的字符串的!!!
        String s = "abc aac adcd bom";
        //编译正则表达式
        Pattern p = Pattern.compile("a\w*");
        //获取匹配器对象
        Matcher m = p.matcher(s);
        //使用匹配器获取符合条件的内容
        while(m.find()){
            String res = m.group();
            System.out.println(res);
        }
        */
        
        
        String s = "hello?nihao+abc,aac the  dog";
        
        
        
    }

}

 5.日期操作工具类：

/*
 * 日期操作的工具类:
 * 格式化一个日期对象:
 * 解析指定字符串成Date对象:
 */
public class DateTools {
    //私有化构造方法
    private DateTools(){}
    
    //格式化一个Date对象成指定格式的字符串
    public static String format(Date d,String pattern){
        //创建一个SimpleDateFormat对象,调用它的format方法,完成格式化!!
//        String format = new SimpleDateFormat(pattern).format(d);
//        return format;
        return new SimpleDateFormat(pattern).format(d);
    }
    
    //解析字符串成Date对象
    public static Date parse(String date,String pattern) throws Exception{
        return new SimpleDateFormat(pattern).parse(date);
    }
}

 6.选择排序

public static void selectSort(int[] arr){
    //外层循环控制比较的趟数
    for(int i = 0;i<arr.length - 1;i++){
        //内层循环控制的是两两比较
        for(int j = i + 1;j<arr.length;j++){
            //后面比前面小,需要交换
            if(arr[i] > arr[j]){
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
}

7.选择排序优化

public static void selectSort2(int[] arr){
    //外层循环控制比较的趟数
    for(int i = 0;i<arr.length - 1;i++){
        //保存当前元素的索引值
        int index = i;
        //内层循环控制的是两两比较
        for(int j = i + 1;j<arr.length;j++){
            //后面比前面小,先不需要交换,先记录下元素的索引!
            if(arr[index] > arr[j]){
                index = j;
            }
        }
        //判断index的值是否发生了变化:
        //如果发生了变化,说明遇到了比它还小的,需要交换
        //否则不需要交换
        if(index != i){
            int temp = arr[i];
            arr[i] = arr[index];
            arr[index] = temp;
        }
    }
}