eclipse的使用和常用API-4

痛定思痛。 2022-07-29 10:51 274阅读 0赞

eclipse的使用和常用API-4

01_常见对象(正则表达式的概述和简单使用)
* A:正则表达式
* 是指一个用来描述或者匹配一系列符合某个语法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用。
* 作用:比如注册邮箱,邮箱有用户名和密码,一般会对其限制长度,这个限制长度的事情就是正则表达式做的
* B:案例演示
* 需求：校验qq号码.
* 1:要求必须是5-15位数字
* 2:0不能开头
* 3:必须都是数字
* a:非正则表达式实现:
public static boolean checkQQ(String qq) {
boolean flag = true; //如果校验qq不符合要求就把flag置为false,如果符合要求直接返回

  1. if(qq.length() >= 5 && qq.length() <= 15) {
  2.         if(!qq.startsWith("0")) {
  3.             char[] arr = qq.toCharArray();  //将字符串转换成字符数组
  4.             for (int i = 0; i < arr.length; i++) {
  5.                 char ch = arr[i];           //记录每一个字符
  6.                 if(!(ch >= '0' && ch <= '9')) {
  7.                     flag = false;           //不是数字
  8.                     break;
  9.                 }
  10.             }
  11.         }else {
  12.             flag = false;       //以0开头,不符合qq标准
  13.         }
  14.     }else {
  15.         flag = false;      //长度不符合
  16.     }
  17.     return flag;
  18. }

* b:正则表达式实现:
String regex = “[1-9]\d{4,14}”;
Scanner sc = new Scanner(System.in);
System.out.println(“请输入QQ号”);
String str = sc.nextLine();
System.out.println(str.matches(regex));
02_常见对象(字符类演示)
* A:字符类
* [abc] a、b 或 c（简单类） []代表单个字符a,b或c
String regex = “[abc]”; //[]代表单个字符a,b或c
System.out.println(“a”.matches(regex)); //true
System.out.println(“ab”.matches(regex)); //false
System.out.println(“2”.matches(regex)); //false
* [^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]（减去）
* [0-9] 0到9的字符都包括

03_常见对象(预定义字符类演示)
* A:预定义字符类
* . 任何字符。任意单个字符
String regex = “..”; //几个点代表任意几个字符
System.out.println(“a”.matches(regex)); //false
System.out.println(“ab”.matches(regex)); //true
* \d 数字：[0-9] ,\代表转义字符,如果想表示\d的话,需要\d,代表0-9中的任意单个字符
String regex = “\d”; //\代表转义字符,如果想表示\d的话,需要\d
System.out.println(“0”.matches(regex)); //true
System.out.println(“a”.matches(regex)); //false
* \D 非数字： [^0-9] 除了0-9
* \s 空白字符：[ \t\n\x0B\f\r]
* \S 非空白字符：[^\s]
* \w 单词字符：[a-zA-Z_0-9]

04_常见对象(数量词)
* A:Greedy 数量词
* X? X，一次或一次也没有
String regex = “[abc]?”;
System.out.println(“a”.matches(regex)); //true
System.out.println(“ac”.matches(regex)); //false
System.out.println(“d”.matches(regex)); //false
System.out.println(“”.matches(regex)); //true 一次也没有
* X* X，零次一直到多次
String regex = “[abc]*”;
System.out.println(“”.matches(regex)); //true
System.out.println(“aabc”.matches(regex)); //true
System.out.println(“a”.matches(regex)); //true
* X+ X，一次或多次
String regex = “[abc]+”;
System.out.println(“”.matches(regex)); //false
System.out.println(“a”.matches(regex)); //true
System.out.println(“aaaaabbbbccccc”.matches(regex)); //true
* X{n} X，恰好 n 次
String regex = “[abc]{5}”;
System.out.println(“abcba”.matches(regex)); //true
System.out.println(“abcb”.matches(regex)); //false
System.out.println(“abcbaaba”.matches(regex)); //false
* X{n,} X，至少 n 次
String regex = “[abc]{5,}”;
System.out.println(“abcba”.matches(regex)); //true
System.out.println(“abcbaabcabbabab”.matches(regex)); //true
System.out.println(“abcb”.matches(regex)); //false
* X{n,m} X，至少 n 次，但是不超过 m 次
String regex = “[abc]{5,15}”;
System.out.println(“abcba”.matches(regex)); //true
System.out.println(“abcbaabcabbabab”.matches(regex)); //true
System.out.println(“abcb”.matches(regex)); //false
System.out.println(“abcbaabaabcbaaba”.matches(regex)); //false

05_常见对象(正则表达式的分割功能)
* A:正则表达式的分割功能
* String类的功能：public String[] split(String regex)
//String s = “金三胖.郭美美.李dayone”;
//String[] arr = s.split(“\.”); //通过正则表达式切割字符串,因为.代表任意字符,比较特殊所以要用\转译成正则中的.
String s = “金三胖 郭美美 李dayone”;
String[] arr = s.split(” “);
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
} //输出 金三胖 郭美美 李dayone

06_常见对象(把给定字符串中的数字排序)
* A:案例演示
* 需求：我有如下一个字符串:”91 27 46 38 50”，请写代码实现最终输出结果是：”27 38 46 50 91”
* 分析:
* 1,将字符串切割成字符串数组
* 2,将字符串转换成数字并将其存储在一个等长度的int数组中
* 3,排序
* 4,将排序后的结果遍历并拼接成一个字符串
public static void main(String[] args) {
String s = “91 27 46 38 50”;
//1,将字符串切割成字符串数组
String[] sArr = s.split(” “);
//2,将字符串转换成数字并将其存储在一个等长度的int数组中
int[] arr = new int[sArr.length];
for (int i = 0; i < arr.length; i++) {
arr[i] = Integer.parseInt(sArr[i]); //将数字字符串转换成数字!!!!!!
}

  1. //3,排序
  2.     Arrays.sort(arr);
  4.     //4,将排序后的结果遍历并拼接成一个字符串27 38 46 50 91
  5.     /*String str = "";
  6.     for (int i = 0; i < arr.length; i++) {          //通过字符串方式!!!
  7.         if(i == arr.length - 1) {
  8.             str = str + arr[i];     //27 38 46 50 91
  9.         }else {
  10.             str = str + arr[i] + " ";   //27 38 46 50 
  11.         }
  12.     }
  14.     System.out.println(str);*/
  16.     StringBuilder sb = new StringBuilder();           //通过StringBuilder方式!!!
  17.     for (int i = 0; i < arr.length; i++) {
  18.         if(i == arr.length - 1) {
  19.             sb.append(arr[i]);
  20.         }else {
  21.             sb.append(arr[i] + " ");
  22.         }
  23.     }       
  24.     System.out.println(sb);
  25. }

07_常见对象(正则表达式的替换功能)
* A:正则表达式的替换功能
* String类的功能：public String replaceAll(String regex,String replacement)
String s = “wo111ai222heima”;
String regex = “\d”; //\d代表的是任意数字

  1. String s2 = s.replaceAll(regex, "");  //用空串替代任意数字
  2.     System.out.println(s2);   //输出woaiheima

08_常见对象(正则表达式的分组功能)
* A:正则表达式的分组功能
* 捕获组可以通过从左到右计算其开括号来编号。例如，在表达式 ((A)(B(C))) 中，存在四个这样的组：
1 ((A)(B(C)))
2 (A
3 (B(C))
4 (C)

  1. 组零始终代表整个表达式。

B:案例演示
*叠词 快快乐乐,高高兴兴
String regex = “(.)\1(.)\2”; //\1代表第一组又出现一次 \2代表第二组又出现一次
System.out.println(“快快乐乐”.matches(regex));

  1. *叠词 死啦死啦,高兴高兴
  2.     String regex2 = "(..)\\1";
  3.     System.out.println("死啦死啦".matches(regex2));
  4.     System.out.println("快快乐乐".matches(regex2));
  6. a:切割
  7.     需求：请按照叠词切割： "sdqqfgkkkhjppppkl";
  8.     String s = "sdqqfgkkkhjppppkl";
  9.     String regex = "(.)\\1+";   //+代表第一组出现一次到多次!!!!!!!!
  10.     String[] arr = s.split(regex);
  12.     for (int i = 0; i < arr.length; i++) {
  13.         System.out.print(arr[i]);  //sdfghjkl
  14.     }
  15. b:替换
  16.     需求：我我....我...我.要...要要...要学....学学..学.编..编编.编.程.程.程..程
  17.     将字符串还原成:“我要学编程”。
  18.     String s2 = s.replaceAll("\\.+", "");
  19.     String s3 = s2.replaceAll("(.)\\1+", "$1");    //$1代表第一组中的内容
  20.     System.out.println(s3);

09_常见对象(Pattern和Matcher的概述)
* A:Pattern和Matcher的概述
* B:模式和匹配器的典型调用顺序
* 通过JDK提供的API，查看Pattern类的说明

  1. * 典型的调用顺序是 
  2. * Pattern p = Pattern.compile("a*b");  //获取到正则表达式,a*b是a出现0-多次,最后跟个b
  3. * Matcher m = p.matcher("aaaaab");     //获取匹配器
  4. * boolean b = m.matches();      //看是否能匹配,匹配就返回true
  6. System.out.println(b);  
  7. System.out.println("aaaaab".matches("a*b"));    //与上面的结果一样,但上面可重复调用,此处的用于单次调用.

10_常见对象(正则表达式的获取功能)
* A:正则表达式的获取功能
* Pattern和Matcher的结合使用
* B:案例演示,需求：把一个字符串中的手机号码获取出来
public static void main(String[] args) {
String s = “我的手机是18988888888,我曾用过18987654321,还用过18812345678”;
String regex = “1[3578]\d{9}”;

  1. Pattern p = Pattern.compile(regex);
  2.     Matcher m = p.matcher(s);
  4.     while(m.find()){  //find中相当于有个指针,如果找到后它会到下个字符串去找
  5.         System.out.println(m.group());  //group把找到的东西获取出来
  6.     }
  7. }

11_常见对象(Math类概述和方法使用)
* A:Math类概述
* Math 类(里面方法都是静态的)包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
* B:成员方法
* public static int abs(int a) //取绝对值
int b=Math.abs(-10);
System.out.println(b); ; //输出10
* public static double ceil(double a)
System.out.println(Math.ceil(12.3)); //向上取整,但是结果是一个double 13.0
System.out.println(Math.ceil(12.99)); //输出13.0
* public static double floor(double a)
System.out.println(Math.floor(12.3)); //向下取整,但是结果是一个double 12.0
System.out.println(Math.floor(12.99)); //12.0
* public static int max(int a,int b) min自学
//获取两个值中的最大值
System.out.println(Math.max(20, 30)); // 30
* public static double pow(double a,double b)
//前面的数是底数,后面的数是指数
System.out.println(Math.pow(2, 3)); //2.0 ^ 3.0 = 8.0
* public static double random()
//生成0.0到1.0之间的所以小数,包括0.0,不包括1.0
System.out.println(Math.random()) //随机 0.1234456
* public static int round(float a) 参数为double的自学
//四舍五入
System.out.println(Math.round(12.3f)); //12
System.out.println(Math.round(12.9f)); //13
* public static double sqrt(double a)
//开平方
System.out.println(Math.sqrt(4)); //2.0
System.out.println(Math.sqrt(2)); //1.414
System.out.println(Math.sqrt(3)); //1.732

12_常见对象(Random类的概述和方法使用)
* A:Random类的概述
* 此类用于产生随机数如果用相同的种子创建两个 Random 实例，
* 则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。
* B:构造方法
* public Random()
* public Random(long seed) //给定种子多次输出结果是相同的,因为是根据同一个种子生成的

  1. [   Random r2 = new Random(1001);       
  2.     int a = r2.nextInt();
  3.     int b = r2.nextInt();
  4.                            //[]中的内容连续运行多次生成的结果是一样的,因为种子是给定的
  5.     System.out.println(a);
  6.     System.out.println(b);   ]

* C:成员方法
* public int nextInt() //伪随机地生成并返回一个 int 值
* public int nextInt(int n)(重点掌握),在 0（包括）和指定值（不包括）之间均匀分布的 int 值
//生成0-99之间的随机数
Random r = new Random();
System.out.println(r.nextInt(100));

13_常见对象(System类的概述和方法使用)
* A:System类的概述
* System 类包含一些有用的类字段和方法。它不能被实例化,它提供的设施中有标准输入输出流,错误输出流.
* B:成员方法
* public static void gc() //调用gc()方法是运行垃圾回收器
* public static void exit(int status)
System.exit(0); //非0状态是异常终止,退出jvm,所以建议给0
* public static long currentTimeMillis() //获取当前时间的毫秒值
long end = System.currentTimeMillis(); //获取当前时间的毫秒值
* pubiic static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
System.arraycopy(src, 0, dest, 0, src.length); //将src数组内容拷贝到dest数组

14_常见对象(BigInteger类的概述和方法使用)
* A:BigInteger的概述
* 可以让超过Integer范围内的数据进行运算
* B:构造方法
* public BigInteger(String val) //数字字符串!!!
* C:成员方法
* public BigInteger add(BigInteger val) //+
* public BigInteger subtract(BigInteger val) //_
* public BigInteger multiply(BigInteger val) //*
* public BigInteger divide(BigInteger val) // /
* public BigInteger[] divideAndRemainder(BigInteger val)
BigInteger bi1 = new BigInteger(“100”);
BigInteger bi2 = new BigInteger(“2”);

  1. System.out.println(bi1.add(bi2));               //+
  2.     System.out.println(bi1.subtract(bi2));          //-
  3.     System.out.println(bi1.multiply(bi2));          //*
  4.     System.out.println(bi1.divide(bi2));            ///(除)
  6.     BigInteger[] arr = bi1.divideAndRemainder(bi2); //取除数和余数        
  7.     for (int i = 0; i < arr.length; i++) {
  8.         System.out.println(arr[i]);         //索引为0的位置是商,索引1是余数!!!
  9.     }

15_常见对象(BigDecimal类的概述和方法使用)
* A:BigDecimal的概述
* 由于在运算的时候，float类型和double很容易丢失精度，演示案例。
* 所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal

  1. * 不可变的、任意精度的有符号十进制数。

* B:构造方法
* public BigDecimal(String val)
* C:成员方法
* public BigDecimal add(BigDecimal augend)
* public BigDecimal subtract(BigDecimal subtrahend)
* public BigDecimal multiply(BigDecimal multiplicand)
* public BigDecimal divide(BigDecimal divisor)
* D:案例演示
* BigDecimal类的构造方法和成员方法使用
//System.out.println(2.0 - 1.1); // 0.89999999999
BigDecimal bd1 = new BigDecimal(“2.0”); //通过构造中传入字符串的方式,开发时推荐
BigDecimal bd2 = new BigDecimal(“1.1”); //输出0.9,去掉引号输出不是0.9,只是更接近了
System.out.println(bd1.subtract(bd2));

  1. BigDecimal bd1 = BigDecimal.valueOf(2.0);   //这种方式在开发中也是推荐的
  2.     BigDecimal bd2 = BigDecimal.valueOf(1.1);       
  3.     System.out.println(bd1.subtract(bd2));   输出是0.9

16_常见对象(Date类的概述和方法使用)(掌握)
* A:Date类的概述
* 类 Date 表示特定的瞬间，精确到毫秒。
Date d1 = new Date(); //如果没有传参数代表的是当前时间
System.out.println(d1);

  1. Date d2 = new Date(0);  //如果构造方法中参数传为0代表的是1970年1月1日,传其他值也一样
  2.     System.out.println(d2); //通过毫秒值创建时间对象

* B:构造方法
* public Date()
* public Date(long date)
* C:成员方法
* public long getTime() //通过时间对象获取毫秒值
Date d1 = new Date();
System.out.println(d1.getTime()); //通过时间对象获取毫秒值
System.out.println(System.currentTimeMillis()); //通过系统类的方法获取当前时间毫秒值
* public void setTime(long time)
Date d1 = new Date();
d1.setTime(1000L); //设置毫秒值,改变时间对象,单位是毫秒,从1970…开始加上传入的long型毫秒值,就是它输出的时间!!!
System.out.println(d1);

17_常见对象(SimpleDateFormat类实现日期和字符串的相互转换)(掌握)
* A:DateFormat类的概述
* DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。是抽象类，所以使用其子类SimpleDateFormat
//DateFormat df = new DateFormat(); //DateFormat是抽象类,不允许实例化
DateFormat df1 = DateFormat.getDateInstance(); //相当于父类引用指向子类对象,右边的方法返回一个子类对象,其实在底层调用了SimpleDateFormat()
* B:SimpleDateFormat构造方法
* public SimpleDateFormat()
* public SimpleDateFormat(String pattern)
* C:成员方法
* public final String format(Date date)
Date d = new Date(); //获取当前时间对象
SimpleDateFormat sdf = new SimpleDateFormat(“yyyy/MM/dd HH:mm:ss”);//创建日期格式化类对象
String d = sdf.format(d); //将日期对象转换成时间字符串
System.out.println(d);//将日期对象转换为字符串2008年06月06日 21:23:45,2008/06/06/ 21:23:45
* public Date parse(String source)
String str = “2000年08月08日 08:08:08”;
SimpleDateFormat sdf = new SimpleDateFormat(“yyyy年MM月dd日 HH:mm:ss”);
Date d = sdf.parse(str); //将时间字符串转换成日期对象
System.out.println(d);

18_常见对象(你来到这个世界多少天案例)(掌握)
* A:案例演示,需求：算一下你来到这个世界多少天?
public static void main(String[] args) throws ParseException {
//1,将生日字符串和今天字符串存在String类型的变量中
String birthday = “1983年07月08日”;
String today = “2088年6月6日”;
//2,定义日期格式化对象
SimpleDateFormat sdf = new SimpleDateFormat(“yyyy年MM月dd日”);
//3,将日期字符串转换成日期对象
Date d1 = sdf.parse(birthday);
Date d2 = sdf.parse(today);
//4,通过日期对象后期时间毫秒值
long time = d2.getTime() - d1.getTime();
//5,将两个时间毫秒值相减除以1000,再除以60,再除以60,再除以24得到天
System.out.println(time / 1000 / 60 / 60 / 24 );
}

19_常见对象(Calendar类的概述和获取日期的方法)(掌握)
* A:Calendar类的概述
* Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。
* B:成员方法
* public static Calendar getInstance()
* public int get(int field)
Calendar c = Calendar.getInstance(); //父类引用指向子类对象
//System.out.println(c); //证明重写了toString方法打印了对象中所有的属性
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.DAY_OF_WEEK));//周日是第一天,周六是最后一天
System.out.println(c.get(Calendar.YEAR) + “年” + getNum((c.get(Calendar.MONTH)+1))
+ “月” + getNum(c.get(Calendar.DAY_OF_MONTH)) + “日” + getWeek(c.get(Calendar.DAY_OF_WEEK)));

  • 将星期存储表中进行查表:
    public static String getWeek(int week) {
    String[] arr = {“”,”星期日”,”星期一”,”星期二”,”星期三”,”星期四”,”星期五”,”星期六”};

    1. return arr[week];

    }

    • 如果是个数数字前面补0
    • 1,返回值类型String类型
    • 2,参数列表,int num
      public static String getNum(int num) {
      /*if(num > 9) {
      return “” + num;
      }else {
      return “0” + num;
      }*/
      return num > 9 ? “” + num : “0” + num;
      }
      20_常见对象(Calendar类的add()和set()方法)(掌握)
  • A:成员方法 
  1.  *  public void add(int field,int amount)
  2.  *  public final void set(int year,int month,int date)
  • B:案例演示 
  1.  *  Calendar类的成员方法使用  
  2.     public static void main(String\[\] args) \{  
  3.     Calendar c = Calendar.getInstance(); //父类引用指向子类对象  
  4.     //c.add(Calendar.MONTH, -1); //对指定的字段进行向前减或向后加  
  5.     //c.set(Calendar.YEAR, 2000); //修改指定字段  
  6.     c.set(2000, 7, 8);  
  7.     System.out.println(c.get(Calendar.YEAR) + “年” + getNum((c.get(Calendar.MONTH)+1))  
  8.     \+ “月” + getNum(c.get(Calendar.DAY\_OF\_MONTH)) + “日” + getWeek(c.get(Calendar.DAY\_OF\_WEEK)));  
  9.     \}  
  10.     21\_常见对象(如何获取任意年份是平年还是闰年)(掌握)

  • A:案例演示,需求：键盘录入任意一个年份，判断该年是闰年还是平年
    public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.println(“请输入年份,判断该年份是闰年还是平年:”);
    //int year = sc.nextInt();

    1. String line = sc.nextLine();                //录入数字字符串
    2. int year = Integer.parseInt(line);          //将数字字符串转换成数字
    3. boolean b = getYear(year);
    4. System.out.println(b);

    }

    private static boolean getYear(int year) {
    //2,创建Calendar c = Calendar.getInstance();
    Calendar c = Calendar.getInstance();
    //设置为那一年的3月1日
    c.set(year, 2, 1);
    //将日向前减去1
    c.add(Calendar.DAY_OF_MONTH, -1);
    //判断是否是29天
    return c.get(Calendar.DAY_OF_MONTH) == 29;
    }

附:常见正则表达式
*手机号码,后边五位必须是相同的:
String regex1 = “1[34578]\d{9}”;
String regex2 = “1[34578]\d{4}(\d)\1{4}”;

*分组,例如快快乐乐,乐呵乐呵:
String regex = “(.)\1+(.)\2+”;

密码. 任意字符, 6-16位:
String regex = “.{6,16}”;

*用户名. 字母数字下划线10位以内, 必须是字母开头:
String regex = “[a-zA-Z]\w{0,9}”;

*,Email fengjia@itcast.cn
// fengjia@itcast.com.cn
String regex = “[\w-\.]+@([\w-]+\.)+[a-z]{2,3}”;

*1-6位字母或数字：
String regex = “[\d[a-zA-Z]]{1,6}”;

*qq号码:
String regex = “[1-9]\d{4,10}”;

发表评论

表情：
评论列表 （有 0 条评论，274人围观）

还没有评论，来说两句吧...

相关阅读