Java day13——API(2)正则表达式、StringBuilder、包装类、Collection集合

public final class String extends Object
implements Serializable, Comparable, CharSequence
可序列化的 可比较的 字符序列

正则表达式

字符串的一些排列规则 -> String

定义

格式的校验: 邮箱格式/身份证格式/电话号码格式
长短的判断: 至少多少个字符, 最长多少个字符
内容的限定: 只能有字母\数字\下划线

常用标识

开始符号: ^
结束符号: $
[]: 一个字符的位置
例如: [abc] -> 这个字符的位置内容只能是a或者b或者c
[a-z] -> 这个字符的位置内容可以是所有的小写字母
[0-9] [A-Z] [a-zA-Z0-9_ ]

数量词

+: 出现一次或多次
?: 一次或者0次
*: 0次或者多次
{n}: 刚好n次
{n,m}: n~m次
{n,}: 至少n次
例如: a+ -> “aa” “aaa” “b”(×)
[a-z]{3} -> “ef”(×) “abc” “ztf”
[a-z0-9]{4,} -> “1234” “1a4f”
[a-zA-Z][a-zA-Z0-9_]{5,17} -> 简化: [a-zA-Z]\w{5,17}

预定义字符类:

. : 所有字符
\d : 数字 [0-9]
\s : 空白字符:[ \t\n\x0B\f\r]
\w : 单词字符:[a-zA-Z_0-9]
\D : 非数字 [^0-9]

字符本身和转义

表示字符本身, 需要 \字符

  \. \\  \+ \? \* \-
  例:
  163邮箱地址正则表达式: ^[a-zA-Z]\w{5,17}@163\.com$
 [a-zA-Z0-9_.-]: []中出现的特殊字符, 不需要转移, 就代表字符本身

相关的API

boolean matches(String regex)

告知此字符串是否匹配给定的正则表达式。

		String str = "ssseeeww@xxx.com.cn.edu.cc";
        // \w{6,18}@\w{3,8}(\.\w{2,6})+
        String regex = "^\\w{6,18}@\\w{3,8}(\\.\\w{2,6})+$";
        boolean m = str.matches(regex);
        System.out.println(m);

String replaceAll(String regex, String newStr)

使⽤给定的
newStr 替换此字符串所有匹配给定的正则表达式的⼦字符串

		// (sb|nc|qnm|qnmlgb|nmb)+
        String regex = "(sb|nc|qnm|qnmlgb|nmb)+";
        String word = "你怎么回事, 真是个sb, 你这个nc, qnm, 会不会玩!";
        word = word.replaceAll(regex, "**");
        System.out.println(word);

String[] split(String regex)

根据给定正则表达式的匹配拆分此字符串。

	    String str = "string123date14hello4word34234";
        // 需求: string  date  hello  word
        String regex = "[0-9]+";
        String[] words = str.split(regex);
        System.out.println(Arrays.toString(words));

StringBuilder

String 是不可变的, 所以频繁的字符串拼接非常消耗时间/内存
解决方案: 提供了新的类, 可变字符串
StringBuffer : 线程安全的
StringBuilder: 效率高
StringBuilder sb = new StringBuilder() -> ""空的字符串

与String类的相互转换

String转换成Stringbuilder

  		String s = "hello";
        StringBuilder sb = new StringBuilder(s);
        System.out.println(sb);

Stringbuilder转换成String

 		StringBuilder sb = new StringBuilder();
        sb.append("abc").append("efg");
        String s = sb.toString();
        System.out.println(s);

常用API

返回值都是this, 在对象本身进行修改

append(Object o)

字符串拼接 - 末尾追加

		StringBuilder sb = new StringBuilder();
        // 字符串拼接 - 末尾追加
        sb.append("haha");
        sb.append("heihei");
        System.out.println(sb); // hahaheihei

insert(int index, String str)

在指定位置插入字符串

		sb.insert(4, "xixi");
        System.out.println(sb); // hahaxixiheihei

replace(int start, int end, String replacement)

将start 和end 中间的字符串替换成指定字符串

		sb.replace(0, 4, "hehe");
        System.out.println(sb); // hehexixiheihei

delete(int start, int end)

删除start 到 end之间的字符串内容

		sb.delete(0, 4);
        System.out.println(sb); // xixiheihei

reverse()

字符串反转

		sb.reverse();
        System.out.println(sb);//iehiehixix

包装类

  • 将基本数据类型做了封装,每一种基本数据类型都对应一种包装类型
  • 一切皆对象 - 引用, 基本数据类型不属于对象
  • 所有的数值的包装类都拥有统一的父类: Number
  • 所有的包装类, 都是 final 类

byte -> Byte
short -> Short
int -> Integer
long -> Long
double -> Double
float -> Float
char -> Character
boolean -> Boolean

      // 1.基本数据类型和包装类型之间可以直接转换
      int i = 1;
      // 2.包装类型比基本数据类型多表示一个null值
      Integer i1 = 2; // null
      // 3.包装类型除了可以直接赋值, 还可以new对象
      i1 = new Integer(2);
      System.out.println(i++);
      System.out.println(i1++);
      // 1.1 int -> Integer 隐藏了自动装箱的操作
      i1 = i; // 等同于: i1 = Integer.valueOf(i);
      // 1.2 Integer -> int 隐藏了自动拆箱的操作
      i = i1; // 等同于: i = i1.intValue();
      // 4.字符串 可以转换成 包装类型
      Integer i3 = Integer.valueOf("12");//String转换成Integer型
      // 将字符串 转换成基本数据类型
      int i4 = Integer.parseInt("ff", 16);//String转换成int型
      System.out.println(i3 + 1);
      System.out.println(i4 + 2);

      double d = 3.14;
      Double d1 = 3.4;
      d = d1; // d1.doubleValue()
      d1 = d; // Double.valueOf(d)

      // 5.整数类型, 类中定义了最大值和最小值字段
      System.out.println("int的最大值:" + Integer.MAX_VALUE);
      System.out.println("byte的最小值:" + Byte.MIN_VALUE);
      System.out.println("long的最大值:" + Long.MAX_VALUE);

补充:
Integer有常量池

		Integer i1 = 100;
        Integer i2 = 100;
        Integer i3 = new Integer(100);
        // 结论1: Integer也有常量池
        System.out.println(i1 == i2); // true
        i1 = 128;
        i2 = 128;
        // 结论2: 常量池的范围: -128 ~ 127
        System.out.println(i1 == i2); // false

        Integer i4 = Integer.valueOf(127);
        Integer i5 = Integer.valueOf(127);
        System.out.println(i4 == i5);

Collection集合

Collection是所有单列集合的⽗接⼝

常用API

public boolean add(E e) : 把给定的对象添加到当前集合中 。
public void clear() :清空集合中所有的元素。
public boolean remove(E e) :把给定的对象在当前集合中删除。
public boolean contains(E e) :判断当前集合中是否包含给定的对象。
public boolean isEmpty() :判断当前集合是否为空。
public int size() :返回集合中元素的个数。
public Object[] toArray() :把集合中的元素,存储到数组中。

注意: 没有单独获得某个元素的方法, 只能迭代/遍历

        Collection<String> col = new ArrayList<>();
        col.add("haha");
        col.add("xixi");
        col.add("heihei");

        // 移除指定元素
        col.remove("xixi");

        // 是否包含指定元素
        boolean is = col.contains("hehe");
        System.out.println("isContains: " + is);

        // 是否为空 size() == 0
        System.out.println("isEmpty: " + col.isEmpty());

        // 清空集合
        col.clear();
        System.out.println(col);

c1.addAll(Collection c2): 将c2中所有的元素加到c1中
c1.containsAll(Collection c2): 问c1中是否包含c2中的所有元素
c1.retainAll(Collection c2): 将c1中元素仅保留c2中出现的元素
c1.removeAll(Collection c2): 将c2中出现过的元素从c1里面移除掉

 	 Collection<String> col1 = new ArrayList<>();
     col1.add("小李飞刀");
     col1.add("西门吹雪");

     Collection<String> col2 = new ArrayList<>();
     col2.add("令狐冲");
     col2.add("任盈盈");

     col1.addAll(col2);

     System.out.println(col1);
     System.out.println(col2);

     Collection<String> col3 = new ArrayList<>();
     col3.add("东方不败");
     col3.add("令狐冲");
     boolean b = col1.containsAll(col3);
     System.out.println(b); // false

     // col1: [小李飞刀, 西门吹雪, 令狐冲, 任盈盈]
     Collection<String> col4 = new ArrayList<>();
     col4.add("任我行");
     col4.add("任盈盈");
     col4.add("令狐冲");
     col1.retainAll(col4);
     System.out.println(col1);

     // col1: [令狐冲, 任盈盈]
     Collection<String> col5 = new ArrayList<>();
     col5.add("东方不败");
     col5.add("令狐冲");
     col1.removeAll(col5);
     System.out.println(col1);

Iterator迭代器

迭代:即Collection集合元素的通⽤获取⽅式。在取元素之前先要判断集合中有没有元素,如果有,就把这个元素取出来,继续在判断,如果还有就再取出出来。⼀直把集合中的所有元素全部取出。这种取出⽅式专业术语称为迭代

  • Iterable -> 可迭代的, iterator() -> 获得迭代器
  • 获得迭代器时, 游标指向集合中第一个元素之前
  • 遍历删除只能使用迭代器

next()和hasNext()

public E next() :返回迭代的下⼀个元素。
public boolean hasNext() :如果仍有元素可以迭代,则返回 true。

 		Collection<String> col = new ArrayList<>();
        col.add("lucy");
        col.add("tom");
        col.add("jack");
        col.add("jack");
        col.add("jack");
        col.add("jack");
		//创建该对象的迭代器
        Iterator<String> it = col.iterator();
        while (it.hasNext()) {
            String str = it.next();
            System.out.println(str);
        }
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值