大数据预科班11

向右看齐 2022-06-08 05:42 134阅读 0赞

# 大数据预科班11 #

### 复习 ###

*  String--代表字符串，最终类；String是一个常量，不可被重写；String可以被共享；不同方式下，String对象的个数不同；
 *  String s =new String("a");//创建了两个对象
 *  字符串不可变

#  #

String s="a";
    change(s);
    
    //两个函数注意对象地址改没

*  indexOf返回指定字符串第一次出现的下标【从0开始】（string/int s,int fromIndex）从下标为fromIndex（包括）开始，找不到返回-1

### 练习 ###

*  输入一个字符串和一个位置，获取这个字符在字符串中的所有位置

#  #

package com.peng.demo;
    
    import java.io.UnsupportedEncodingException;
    import java.util.Scanner;
    
    //输入一个字符串和一个位置，获取这个字符在字符串中的所有位置
    public class TestDemo {
        public static void main(String[] args) throws UnsupportedEncodingException {
            System.out.println("请输入一个字符串：");
            Scanner s = new Scanner(System.in);
            String ss = s.nextLine();
            System.out.println("请输入字符：");
            String sss = s.nextLine();
            s.close();
            char[] arr = ss.toCharArray();
            for (int i = 0; i < arr.length; i++) {
                if (sss.equals(Character.toString(arr[i]))) {
                    System.out.println("位置：" + i);
                }
            }
        }
    }

#  #

//方法二
        package com.peng.demo;
    
        import java.io.UnsupportedEncodingException;
        import java.util.Scanner;
    
        //输入一个字符串和一个位置，获取这个字符在字符串中的所有位置
        public class TestDemo {
            public static void main(String[] args) throws UnsupportedEncodingException {
                System.out.println("请输入一个字符串：");
                Scanner s = new Scanner(System.in);
                String ss = s.nextLine();
                System.out.println("请输入字符：");
                String sss = s.nextLine();
                s.close();
    
                int index = 0;
    
                while (index < ss.length()) {
                    index = ss.indexOf(sss, index);
                    if (index != -1) {
                        System.out.println("出现的位置" + index);
                        index++;
                    } else {
                        break;
                    }
                }
    
            }
        }

*  lastIndexOf（String/int s,int index）获取index之前的字符串，包含下标
 *  replace（char old,char new）替换old为new，全部改变
 *  startsWith（char start）判断以start开头，分门别类；筛选，划归
 *  substring（int start,int end）截取子字符串；\[start,end)包含起始下标，不包含结束下标

包含左，不含右；有头无尾；有前无后

*  trim（）把字符串的前后前后空白字符去掉；中间的空白不会被替换；掐头去尾
 *  valueOf（）将参数转化为字符串

#  #

println->valueOf->toString

char\[\]字符数组--除了字符数组可以打印字符串，其他引用数据类型都打印地址

### StringBuilder ###

*  append追加
 *  reverse反转字符串

#  #

回文字符串：
        return new StringBuilder(str).equals(new StringBuilder(str).reverse().toString())//效率为O(n)
    
        前后对比为O（n/2）

### 练习 ###

*  1；21；213；4213；42135；

#  #

package com.peng.demo;
    
    import java.util.Scanner;
    
    //输入一个字符串和一个位置，获取这个字符在字符串中的所有位置
    public class TestDemo {
        public static void main(String[] args) {
            System.out.println("输入数组大小：");
            Scanner s = new Scanner(System.in);
            int arr_length = s.nextInt();
            // 输入arr_length个数存入数组
            int[] arr = new int[arr_length];
            StringBuilder str = new StringBuilder();
            for (int i = 0; i < arr_length; i++) {
                System.out.println("输入第" + (i + 1) + "个数：");
                arr[i] = s.nextInt();
                str = str.append(arr[i]);
                str.reverse();
            }
            System.out.println(str.reverse());
            s.close();
    
        }
    }
    
    结果：
    输入数组大小：
    7
    输入第1个数：
    1
    输入第2个数：
    2
    输入第3个数：
    3
    输入第4个数：
    4
    输入第5个数：
    5
    输入第6个数：
    6
    输入第7个数：
    7
    6421357

*  疯狂值，相邻元素的差的绝对值和最大

#  #

package com.peng.demo;
    
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    import java.util.Scanner;
    
    public class TestDemo {
        public static void main(String[] args) {
            // 获取一个及一组数字
            Scanner s = new Scanner(System.in);
            System.out.println("请输入数组大小：");
            int number = s.nextInt();
            int[] arr = new int[number];
            for (int i = 0; i < arr.length; i++) {
                System.out.println("请输入第" + (i + 1) + "个数：");
                arr[i] = s.nextInt();
            }
            s.close();
            // 对数组进行正序排序
            Arrays.sort(arr);
            int crazy1 = getCrazy(arr);
            // 对数组进行倒叙序排序
            for (int start = 0, end = arr.length - 1; start < end; start++, end--) {
                arr[start] ^= arr[end];
                arr[end] ^= arr[start];
                arr[start] ^= arr[end];
            }
            int crazy2 = getCrazy(arr);
    
            System.out.println();
            System.out.println("疯狂数为：" + (crazy1 > crazy2 ? crazy1 : crazy2));
    
        }
    
        // 函数--获得相邻两个数之差的绝对值和最大
        public static int getCrazy(int[] arr) {
            List<Integer> list = new ArrayList<Integer>();
            // 放数组中的最大值
            list.add(arr[arr.length - 1]);
            // 定义一个变量来指挥放的位置
            int count = 0;
            for (int start = 0, end = arr.length - 2; start <= end;) {
                if (count == 0) {
                    list.add(0, arr[start]);
                    start++;
                } else if (count == 1) {
                    list.add(arr[start]);
                    start++;
                } else if (count == 2) {
                    list.add(0, arr[end]);
                    end--;
                } else {
                    list.add(arr[end]);
                    end--;
                }
                count++;
                if (count == 4) {
                    count = 0;
                }
            }
            System.out.println(list);
            int sum = 0;// 存放相邻里两数差的绝对值之和
            for (int j = 0; j < list.size() - 1; j++) {
                sum += Math.abs(list.get(j) - list.get(j + 1));
            }
            System.out.println("临时疯狂数："+sum);
            return sum;
        }
    
    }

### 正则表达式 ###

*  Pattern（模式）:指定规则的类
 *  str.equals("a")----str.maches("a")
 *  首字母为a或b或c，中间字母为d或e 或f，尾字母为h或i或j----\[abc\]\[def\]\[hij\]
 *  匹配两个小写字母组成的字符串-----\[a-zA-Z\]\[a-zA-Z\]
 *  任何一个小写字母------\[a-z\]
 *  除了字符之外的任意字符----\[^字符\]
 *  任意一个字符-------.(点)
 *  注意字符串的转义+正则转义

#  #

匹配一个点-------"\\." 
    匹配一个\----------"\\\\"
    匹配任意一个数字-----[0d]或者"\\d"

*  单词数字、字母、下划线\\w
 *  \+表示1或多
 *  \*表示0或多
 *  ？0或1（至多一次）
 *  限定字符

#  #

类似区间
    .{m}m个任意字符
    .{m,}至少m个任意字符
    .{m.n}m到n个字符

*  捕获组（。。。）

#  #

eg："(.*\$abc\$.*)"
    //正则表达式会自动对捕获组编号，编号从1开始\\n引用
    //捕获组的编号问题
    //从左半边第一次出现的(开始算起
    //ABAB:(..)\\1
    //叠字：（.）\\1+

### linux没回车，只有换行；Windows有换行和回车； ###

### 练习 ###

*  匹配小数字符串

#  #

注意：000.01
    
    package com.peng.demo;
    
    public class TestDemo {
        public static void main(String[] args) {
            String s = "012.110";
            if (s.matches("[1-9]\\d*\\.\\d+") || s.matches("0\\.\\d+")) {
                System.out.println(s + ":是小数！");
            } else {
                System.out.println(s + ":不是小数！");
            }
    
        }
    }

*  邮箱

#  #

（数字、字母、下划线、-）（@）（字母、数字）(.)（com/cn/com.cn）

*  密码

#  #

1. 至少大写、小写、数字、空格中的三个组成 
    package com.peng.demo;
    
    import java.util.Scanner;
    
    public class TestDemo {
        public static void main(String[] args) {
            String s = new Scanner(System.in).nextLine();
            if (isPass(s)) {
                System.out.println(s + ":是！");
            } else {
                System.out.println(s + ":不是！");
            }
        }
    
        // 小数
        static boolean isSmallNumber(String temp) {
            if (null == temp) {
                return false;
            }
            if (temp.matches("[1-9]\\d*\\.\\d+") || temp.matches("0\\.\\d+")) {
                return true;
            } else {
                return false;
            }
        }
    
        // 邮箱
        // （数字、字母、下划线、-）（@）（字母、数字）(.)（com/cn/com.cn）
        static boolean isEmail(String temp) {
            // [a-zA-A0-9][\\w-]{5,}+@[\\da-zA-Z]+\\.(com|cn|com\\.cn)
            if (temp.matches("[\\w-]+@[\\da-zA-Z]+\\.(com|cn|com\\.cn)")) {
                return true;
            } else {
                return false;
            }
        }
    
        // 密码：至少大写、小写、数字、空格中的三个组成----空格正则直接写
        static boolean isPass(String temp) {
            if (temp == null) {
                return false;
            }
            if (!temp.matches("(.){6.12}")) {
                return false;
            }
            boolean b1, b2, b3, b4;
            b1 = temp.matches(".*[A-Z].*");
            b2 = temp.matches(".* .*");
            b3 = temp.matches(".*[a-z].*");
            b4 = temp.matches(".*[0-9].*");
            System.out.println("" + b1 + b2 + b3 + b4);
            return ((b1 && b2 && b3 || b4) && (b1 && b2 && b4 || b3)
                    && (b1 && b4 && b3 || b2) && (b4 && b2 && b3 || b1));
        }
    }
    
    //注：设置整数记录类型总数--更简单点

### 注： ###

*  （.）\{2,\}表示至少2个字符
 *  （.）\\1+表示同一个字符至少出现两次
 *  replaceAll（正则表达式，替换的字符串）

#  #

package com.peng.demo;
    
    import java.util.Scanner;
    
    public class TestDemo {
        public static void main(String[] args) {
            String s = new Scanner(System.in).nextLine();
            while (s.length() > 0) {
                int s_length = s.length();
                char temp = s.charAt(0);
                s = s.replaceAll(temp + "", "");
                System.out.println("" + temp + ":" + (s_length - s.length()));
            }
        }
    }

*  交换字符串str.replaceAll("()()()","$3$2$1")
 *  将叠字字符串转化为单字字符串

#  #

package com.peng.demo;
    
    public class TestDemo {
        public static void main(String[] args) {
    
            String s="aaaabbbbbcccc";
            System.out.println(s.replaceAll("(.)\\1+", "$1"));
        }
    }

*  split

#  #

切割完成之后就不存在了
    切割符在末尾--最后一个没有
    切割符在首部--最后一个没有
    相邻两个切割符会切割出空串，但是连续末尾不会切
    
    总结：除了切割符在末尾，其他地方都会切割成空串

#  #

字符 
    x 字符 x 
    \\ 反斜线字符 
    \0n 带有八进制值 0 的字符 n (0 <= n <= 7) 
    \0nn 带有八进制值 0 的字符 nn (0 <= n <= 7) 
    \0mnn 带有八进制值 0 的字符 mnn（0 <= m <= 3、0 <= n <= 7） 
    \xhh 带有十六进制值 0x 的字符 hh 
    \uhhhh 带有十六进制值 0x 的字符 hhhh 
    \t 制表符 ('\u0009') 
    \n 新行（换行）符 ('\u000A') 
    \r 回车符 ('\u000D') 
    \f 换页符 ('\u000C') 
    \a 报警 (bell) 符 ('\u0007') 
    \e 转义符 ('\u001B') 
    \cx 对应于 x 的控制符

#  #

字符类 
    [abc] a、b 或 c（简单类） 
    [^abc] 任何字符，除了 a、b 或 c（否定） 
    [a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围） 
    [a-d[m-p]] a 到 d 或 m 到 p：[a-dm-p]（并集） 
    [a-z&&[def]] d、e 或 f（交集） 
    [a-z&&[^bc]] a 到 z，除了 b 和 c：[ad-z]（减去） 
    [a-z&&[^m-p]] a 到 z，而非 m 到 p：[a-lq-z]（减去）

#  #

预定义字符类 
    . 任何字符（与行结束符可能匹配也可能不匹配） 
    \d 数字：[0-9] 
    \D 非数字： [^0-9] 
    \s 空白字符：[ \t\n\x0B\f\r] 
    \S 非空白字符：[^\s] 
    \w 单词字符：[a-zA-Z_0-9] 
    \W 非单词字符：[^\w]

#  #

POSIX 字符类（仅 US-ASCII） 
    \p{Lower} 小写字母字符：[a-z] 
    \p{Upper} 大写字母字符：[A-Z] 
    \p{ASCII} 所有 ASCII：[\x00-\x7F] 
    \p{Alpha} 字母字符：[\p{Lower}\p{Upper}] 
    \p{Digit} 十进制数字：[0-9] 
    \p{Alnum} 字母数字字符：[\p{Alpha}\p{Digit}] 
    \p{Punct} 标点符号：!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~ 
    \p{Graph} 可见字符：[\p{Alnum}\p{Punct}] 
    \p{Print} 可打印字符：[\p{Graph}\x20] 
    \p{Blank} 空格或制表符：[ \t] 
    \p{Cntrl} 控制字符：[\x00-\x1F\x7F] 
    \p{XDigit} 十六进制数字：[0-9a-fA-F] 
    \p{Space} 空白字符：[ \t\n\x0B\f\r]

#  #

java.lang.Character 类（简单的 java 字符类型） 
    \p{javaLowerCase} 等效于 java.lang.Character.isLowerCase() 
    \p{javaUpperCase} 等效于 java.lang.Character.isUpperCase() 
    \p{javaWhitespace} 等效于 java.lang.Character.isWhitespace() 
    \p{javaMirrored} 等效于 java.lang.Character.isMirrored()

#  #

Unicode 块和类别的类 
    \p{InGreek} Greek 块（简单块）中的字符 
    \p{Lu} 大写字母（简单类别） 
    \p{Sc} 货币符号 
    \P{InGreek} 所有字符，Greek 块中的除外（否定） 
    [\p{L}&&[^\p{Lu}]]  所有字母，大写字母除外（减去）

#  #

边界匹配器 
    ^ 行的开头 
    $ 行的结尾 
    \b 单词边界 
    \B 非单词边界 
    \A 输入的开头 
    \G 上一个匹配的结尾 
    \Z 输入的结尾，仅用于最后的结束符（如果有的话） 
    \z 输入的结尾

#  #

Greedy 数量词 
    X? X，一次或一次也没有 
    X* X，零次或多次 
    X+ X，一次或多次 
    X{n} X，恰好 n 次 
    X{n,} X，至少 n 次 
    X{n,m} X，至少 n 次，但是不超过 m 次

#  #

Reluctant 数量词 
    X?? X，一次或一次也没有 
    X*? X，零次或多次 
    X+? X，一次或多次 
    X{n}? X，恰好 n 次 
    X{n,}? X，至少 n 次 
    X{n,m}? X，至少 n 次，但是不超过 m 次

#  #

Possessive 数量词 
    X?+ X，一次或一次也没有 
    X*+ X，零次或多次 
    X++ X，一次或多次 
    X{n}+ X，恰好 n 次 
    X{n,}+ X，至少 n 次 
    X{n,m}+ X，至少 n 次，但是不超过 m 次

#  #

Logical 运算符 
    XY X 后跟 Y 
    X|Y X 或 Y 
    (X) X，作为捕获组

#  #

Back 引用 
    \n 任何匹配的 nth 捕获组

#  #

引用 
    \ Nothing，但是引用以下字符 
    \Q Nothing，但是引用所有字符，直到 \E 
    \E Nothing，但是结束从 \Q 开始的引用

#  #

特殊构造（非捕获） 
    (?:X) X，作为非捕获组 
    (?idmsux-idmsux)  Nothing，但是将匹配标志i d m s u x on - off 
    (?idmsux-idmsux:X)   X，作为带有给定标志 i d m s u x on - off 
    的非捕获组  (?=X) X，通过零宽度的正 lookahead 
    (?!X) X，通过零宽度的负 lookahead 
    (?<=X) X，通过零宽度的正 lookbehind 
    (?<!X) X，通过零宽度的负 lookbehind 
    (?>X) X，作为独立的非捕获组