No1_6.字符串的基本操作2_Java学习笔记

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

public class HelloString2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        /*******************
         *一、正则表达式：对输入的数据格式进行检查
         *1.对输入的格式进行验证，页面上的一般用java 还是 js？
         *答：一般前端做做验证，后台稍作验证即可。
         *如果数据很关键，安全性很关键，那么后端就必须做非常完备的数据验证，而且还要采取其他一些防范措施来避免
         *（或者确切地说减少可能性）SQL注入、跨站脚本攻击、CSRF（跨站请求伪造）、缓冲区溢出等等攻击。
         *2.可以使用String类的matches()方法进行判断。boolean matches(String regex)
         *3.
         */
        
        //正则表达式中的元字符
                /*
                 .        代表任意一个字符
                \d     任何一个数字，等价于[0-9]或[0123456789]
                \D     任何一个非数字，等价于[^0-9]或[^0123456789]
                 \w    任何一个字母（不区分大小写）、数字、下划线，等价于[0-9a-zA-Z_]
                 \W    任何一个非字母数字和下划线，等价于[^0-9a-zA-Z_]
                    \s      任何一下空白字符，等价于[\f\n\r\t\v]
                 \S      任何一下空白字符，等价于[^\f\n\r\t\v]
                \p{Upper}          大写字母字符：[A-Z]
                \p{Lower}          小写字母字符：[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{Space}          空白字符：[ \t\n\x0B\f\r]
                \p{XDigit}          十六进制数字：[0-9a-fA-F]
                 */
                System.out.println("正则表达式 开始啦啦啦\n");
                //例一：判断指定字符是否合法，要求字符串由7个数字组成，并且第一位必须是大写字母，2~4位是小写字母，后3位是数字，输出结果。
                System.out.println("例一：判断指定字符是否合法，要求字符串由7个数字组成，并且第一位必须是大写字母，2~4位是小写字母，后3位是数字，输出结果。");
                String  s1="Lyqm887";
                String s2="hiGirl6";
                boolean bn1=s1.matches("\\p{Upper}\\p{Lower}\\p{Lower}\\p{Lower}\\d\\d\\d");
                boolean bn2=s2.matches("\\p{Upper}\\p{Lower}\\p{Lower}\\p{Lower}\\d\\d\\d");
                System.out.println(s1+"是合法数据吗？"+bn1);
                System.out.println(s2+"是合法数据吗？"+bn2);
            //正则表达式中的限定符
                /*
                ？     0次或1次
                *         0次或多次
                 +       0次或多次
                 {n}    正好出现n次
                    {n,}   至少出现n次
                 {n,m}   出现n~m次  
                 */    
                //例二：例一的正则表达式简化
                System.out.println("\n例二：例一的正则表达式简化");
                boolean bn3=s2.matches("\\p{Upper}\\p{Lower}{3}\\d{3}");
                System.out.println(s1+"是合法数据吗？"+bn3);
                
                //例三：判断变量是否是合法的email地址
                System.out.println("\n例三：判断变量是否是合法的email地址");
                String s3="yjgogjge@163.com";
                String s4="@163.com";
                String s5="yjgogjge@.";
                String regex="\\w{1,}\\@{1}\\w{0,}\\.{1}\\w{1,}";
                if(s3.matches(regex)){
                    System.out.println(s3+"是一个合法的Email地址~");
                }
                if(s4.matches(regex)){
                    System.out.println(s4+"是一个合法的Email地址~");
                }
                if(s5.matches(regex)){
                    System.out.println(s5+"是一个合法的Email地址~");
                }
            //方括号中元字符的含义
                /*
                [abc]                            a、b或者
                [^abc]                        a、b、c之外的任何字符
                 [a-zA-Z]                    a-z或A-Z的任何字符
                 [a-d[m-p]]                    a-d或m-p的任何字符
                    [a-z&&[def]]                d、e、f
                 [a-z&&[^bc]]            a-z之间不包含b、c的所有字符
                 [a-z&&[^m-p]]            a-z之间不包含m-p的所有字符
                 */    
                
                //例四：对手机号码的合法性进行验证
                System.out.println("\n例四：对手机号码的合法性进行验证");
                Scanner s= new Scanner(System.in);
                System.out.println("请输入手机号，验证一下你输入的是否合法？");
                //String tel1=s.nextLine();
                String tel1="15510168888";
                System.out.println(checkTel(tel1));
                
                //例五：验证ip地址的合法性
                System.out.println("\n例五：验证ip地址的合法性");
                System.out.println("请输入IP地址，验证一下是否合法？");
                //String ip1=s.nextLine();
                String ip1="1.1.1.1";
                System.out.println(checkIPAdress(ip1));
                
                //例六：计算文章中汉字的个数
                System.out.println("\n例六：计算文章中汉字的个数");
                String text="The secret of success is constancy to purpose.成功的秘诀在于对目标的忠实。不破不立，尝试改变一下自己~";
                int amount=0;
                
                for(int i=0;i<text.length();i++){
                    //System.out.println(text.charAt(i));可以获取每个字符
                    String chineseRegex="^[\u4e00-\u9fa5]{0,}$";
                    boolean matches=Pattern.matches(chineseRegex, ""+text.charAt(i));    //有时间可以查一下patter类的用法
                    if (matches){
                        amount++;
                    }
                }
                System.out.println(text+"\n上段话中中有几个汉字："+amount);
                
                /********************************
                 * 二、字符串生成器 
                 * StringBuilder类，是字符串一个重要的常用类，且节省程序运行时间；
                 * 初始容量是16个字符，可以自行指定初始长度
                 * 可以动态执行添加、删除、插入字符串                
                 * ******************************************/
                //例一：通过实例对比String和StringBuilder在对字符串做更新操作时所用的时间差别
                System.out.println("\n");
                System.out.println("例一：通过实例对比String和StringBuilder在对字符串做更新操作时所用的时间差别:");
                
                String str="";
                long startTime=System.currentTimeMillis();     //    定义执行操作的起始时间
                for(long m=0;m<10000;m++){
                    str=str+m;
                }
                long endTime=System.currentTimeMillis();
                long time=endTime-startTime;
                System.out.println("String消耗时间是："+time);
                
                
                StringBuilder builder=new StringBuilder("");
                startTime=System.currentTimeMillis();
                for(long n=0;n<10000;n++){
                    builder.append(n);
                }
                endTime=System.currentTimeMillis();
                time=endTime-startTime;
                System.out.println("StringBuilder消耗时间是："+time);
                
                //例二：将参数str指定的字符串追加到字符串生成器中，可以追加任何类型哟，包括sb类型： StringBuilder.append(String str)
                System.out.println("\n例二：将参数str指定的字符串追加到字符串生成器中");
                String myDream="可以做自己喜欢的做的事情~";
                boolean mySex=true;
                StringBuilder builder1=new StringBuilder("My dream is ");
                builder1.append(myDream);
                builder1.append(mySex);
                StringBuilder sb=new StringBuilder("\n不破不立~专心学习！！！");
                builder1.append(sb);
                System.out.println("追加后builder1的值是："+builder1);
                
                //例三：将参数指定的字符串str添加到offset指定的位置 StringBuilder insert(int offset,String str)
                System.out.println("\n例三：将参数指定的字符串str添加到offset指定的位置");
                StringBuilder sb1=new StringBuilder("I  you!");
                sb1.insert(2, "miss");
                System.out.println("我又想到你了..."+sb1);
                
                //例四：移除字符串生成器中的子字符串，从指定的start处开始，到指定的end处结束；
                //StringBuilder.delete(int start,String end)
                System.out.println("\n例四：移除字符串生成器中的子字符串");
                StringBuilder sb2=new StringBuilder("因为喜欢，你让我想成为更好的自己！");
                System.out.println("原字符串是："+sb2);
                sb2.delete(0, 5);
                System.out.println("移除字符串后是："+sb2);
                
                //例五：将字符串生成器转换为字符串，转换后值不变 StringBuilder.toString()
                System.out.println("\n例六：将字符串生成器转换为字符串");
                StringBuilder sb3=new StringBuilder("我们总是喜欢拿“顺其自然”来敷衍人生道路上的荆棘坎坷，"
                        + "\n却很少承认，真正的顺其自詹，其实是竭尽所能之后的不强求，而非两手一摊的不作为。 by瑞卡斯");
                String wordsLike=sb3.toString();
                System.out.println(wordsLike);
                
                //例七：将汉字和字母转换成Unicode码
                System.out.println("\n例七：将汉字和字母转换成Unicode码");
                String strUnicode="我想见你时，能不能不管你加不加班，想不想见我。。。好像不能呢~~~";
                char[] charArray=strUnicode.toCharArray();
                StringBuilder sb4=new StringBuilder();
                for(char c:charArray){
                    sb4.append((int)c+" ");
                }
                System.out.println(strUnicode+"\n的Unicode码是：\n"+sb4);
                
                
                //范例八：去掉字符串中重复的字符
                System.out.println("\n范例八：去掉字符串中重复的字符");
                String s8="再见了，互相嫌弃的老同学，再见了，来不及说出的谢谢。";
                StringBuilder sb5=new StringBuilder(s8);
                System.out.println("原来的字符串是："+sb5);
                System.out.println("原来的字符串长度是："+sb5.length());
                for(int j=0;j<sb5.length();j++){
                    for(int k=j+1;k<sb5.length();k++){
                        if(sb5.charAt(j)==sb5.charAt(k))
                            sb5.deleteCharAt(k);
                    }
                }
                System.out.println("现在的字符串是："+sb5);
                System.out.println("现在的字符串长度是："+sb5.length());
                
                
                //经典范例九：实现字符串加密
                //最常用的：获取字符串的字节数组，再对字节数组中的每个字符进行操作，加密；对字符串进行相反运算，解密。
                System.out.println("\n经典范例九：实现字符串加密");
                String value="就像我说大海很漂亮，你却说淹死过很多人";
                char secret='晴';
                System.out.println("原字符串是："+value);
                String encrypt=encryption(value,secret);
                System.out.println("加密后的字符串是："+encrypt);
                String uncrypt=encryption(encrypt,secret);
                System.out.println("解密后的字符串是："+uncrypt);
                
                
                //经典范例十：验证字符串是否是回文：即从前往后读和从后往前读一样；
                System.out.println("\n经典范例十：验证字符串是否是回文");
                //StringBuilder line=new StringBuilder("上海自来，水来自海上");
                String line="上海自来水来自海上";
                System.out.println("原始字符串是："+line);
                StringBuilder line2=new StringBuilder(line);
                line2 =line2.reverse();//字符串生成器中字符反转，如果直接用StringBuffer类型的line转换，line和line2的存储长度是一样的。。。
                /****************
                 * 备注一下原理：StringBuffer 和StringBuilder 节省内存的原理，在于拼接字符串的时候本身的对象不变，
                 * 一直在变的是数组对象，通过不断的复制生成新的数组对象，达到拼接字符串，
                 * 而StringBuffer和StringBuilder的代码逻辑一模一样，只是StringBuffer所有的方法都加了cynchronized，所以是线程安全的。
                 */
                //line2=line2.append("喂~");
                System.out.println("返转后的字符串是："+line2);
                int count=0;
                if( line.length() != line2.length()){
                    System.out.println(line+"：不是回文诗呵呵");
                }else{
                    for(int y=0;y<line2.length();y++){
                        
                        if(line.charAt(y)==line2.charAt(y)){
                            count++;                            
                        }
                        else{
                            System.out.println(line+"：不是回文诗");
                            break;
                        }//分支结束
                            
                    }//循环结束
                                            
                }//外层分支结束
            if(count==line.length()){
                System.out.println(line+"：是回文诗~~~~");
            }
                
                //实战开始
                /************************
                 * 1.创建Number类，判断字符串""中字符'i'出现了几次，并输出结果
                 * 2.去除字符串中的所有空格的方法，试着用for循环和if条件语句实现去除空格
                 * 3.在项目中创建DateAndTime类，将今天的全部信息格式化后输出，再将日期以“年-月-日”的格式输出
                 */
            //实战一
            System.out.println("1.创建Number类，判断字符串\"\"中字符'i'出现了几次，并输出结果");
            
                        
                
    }

    
            /***********************以下是函数********************************/
            // 例四：对手机号码的合法性进行验证（前两位是13、15、18，共11位）
            public static String checkTel(String str) {
                String telRegex = "1[5,3,8]\\d{9}$";
                if (str.matches(telRegex)) {
                    return str + "\t是合法的手机号。";
                } else {
                    return str + "\t是非法的手机号！";
                }
            }
            // 例五：验证ip地址的合法性
            public static String checkIPAdress(String str)
            {
            //    String ipRegex="\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}";//验证0~999之间的数字
                String ip = "^(1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|[1-9])\\."
                        +"(00?\\d|1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)\\."
                        +"(00?\\d|1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)\\."
                        +"(00?\\d|1\\d{2}|2[0-4]\\d|25[0-5]|[1-9]\\d|\\d)$";    //验证0~255之间的数字
                if (str.matches(ip)) {
                    return str + "\t 是合法的ip地址。";
                } else {
                    return str + "\t 是非法的ip地址！";        
                }
                
            }
            
            public static String encryption(String value,char secret){
                byte[] bt=value.getBytes();
                for(int x=0;x<bt.length;x++){
                    bt[x]=(byte)(bt[x]^(int)secret);
                    
                }
                return  new String(bt,0,bt.length);
            }

            
            
            
}