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);
             }

 }