内部类 正则表达式 字符串

最新推荐文章于 2021-05-26 20:58:37 发布
最新推荐文章于 2021-05-26 20:58:37 发布
阅读量573 收藏
点赞数
分类专栏： java基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/red_eared_slider/article/details/99718212
版权

内部类?
提高了类成员的安全性

内部类的概述: 把类定义在类的内部
几个需要区分的概念:
       A 类中定义 B类, A类就是外部类,B类就是内部类, main就是外界

  • 根据定义的位置: 内部类分类
    1.成员内部类
    2.局部内部类
    3.静态内部类
    4.匿名内部类

  • 内部类的特点:
    1.内部类编译后生成class文件的格式: 外部类类名$内部类类名
    2.内部类可以访问外部类的所有成员,包括私有成员
    3.外部类访问内部类成员,必须创建内部类对象
    4.外界访问外部类成员,创建外部类对象,外界访问内部类成员
    5.内部类将类和类之间产生了关系,提高了耦合性,降低可读性,慎用

成员内部类:

  • 访问格式:

  •  外部类类名.内部类类名 对象名 = new 外部类对象().new 内部类对象();

    当外部类成员名字和内部类成员名字重名的时候: 外部类类名.this.成员

局部内部类

  • 访问局部内部类成员: 局部内部类只能够在局部创建对象访问
public class InnerClassDemo04 {
	public static void main(String[] args) {
		Outer3 outer3 = new Outer3();
		outer3.show();
	}
}

class Outer3 {
	
	
	public void show() {
		class InnerX {
			int num = 20;
			
			public void show() {
				System.out.println("Outer3.show().Inner.show()");
			}
		}
		
		InnerX innerX = new InnerX();
		System.out.println(innerX.num);
		innerX.show();
	}
	
	public void test() {
//		InnerX innerX = new InnerX();
	}
}

静态内部类

  • 访问格式: 外部类类名.内部类类名 对象名 = new 外部类类名.内部类类名();
  • 访问非静态成员: 创建静态内部类对象访问
  • 访问静态成员: 直接通过外部类类名.内部类类名.内部类静态成员

匿名内部类: 这个本质就是 一个 继承/实现了某个类(接口,普通类,抽象类)的子类匿名对象

  • 格式:
    new 类名() {
    [重写方法;]
    };
  • 特点:
    1.它是一个对象
    2.它是一个子类对象
    3.它是子类匿名对象
public class InnerClassDemo06 {
	public static void main(String[] args) {
		new Object(); // 匿名对象
		new Object() {}; // Object的子类(Object$1)匿名对象
		new Object() {
			@Override
		public boolean equals(Object obj) {
			// TODO Auto-generated method stub
			return super.equals(obj);
		}}; // Object的且重写了equals方法的子类匿名对象
		
		// 利用多态
		Object s = new Object() {
			@Override
			public String toString() {
				return "今晚打老虎";
			}
			
			@Override
			public boolean equals(Object obj) {
				// TODO Auto-generated method stub
				return false;
			}
		}.toString();
		
		// 通过父类引用变量名访问多个方法
	}
}
正则表达式

正则表达式概述:使用单个字符串来描述/匹配一系列符合某个语法规则的字符串

  •  正则表达式不属于Java的技术,是大部分语言都支持的技术,类似于json

  • 学习目的:
    在Java里面来学习正则表达式的目的主要就是使用正则表达式来处理字符串复杂的
    查找 find/替换replace/匹配matches/分割split工作

  • 使用步骤
    1.通过大量的字符串找规律定义规则
    2.使用这种规则去匹配新的字符串
    3.匹配成功作出相应的操作(匹配 查找 替换 分割)

  • 正则表达式的语法
    正则表达式由两种基本字符组成
    原义字符:字符本身就是一个正则表达式，例如 a, b, c ,\t ,\n ,\r ,\f等等
    元字符: * + ? $ ^ () [] {}等等 【有特殊含义的字符】

  • 对正则表达式进行分类
    字符类: [abc] 将字符进行归类，可以出现[]中的其中一个 对abc其中一个进行匹配
    [^abc] 对不是abc的字符进行匹配
    范围类:
    [a-z] 表示代表a-z中的一个字符

    预定义类:
    \d == [0-9] 数字 digit

    \D == [^0-9] 非数字

空白字符：[ \t\n\x0B\f\r] == \s

[^ \t\n\x0B\f\r] == \S  space
[a-zA-Z0-9_] \w word
[^a-zA-Z0-9] \W
. 任何字符（与行结束符可能匹配也可能不匹配） 

边界字符
^:以XXX开头 
例如以a开头 ^a

$:以XXX结尾
例如以b结尾 b$

\b:单词边界
\B:非单词边界

正则表达式在Java中的应用总结
1.字符串查找操作 Pattern和Matcher
2.字符串匹配操作 字符串的matches()方法
3.字符串替换操作 字符串的replaceAll()和replaceFirst()方法
4.字符串分割 split() 方法

public class RegexDemo03 {
	public static void main(String[] args) {
		// 2.字符串匹配操作 字符串的matches()方法
		// 注意: 字符串的匹配操作必须是完全匹配
		String src = "aaaxyz123aaa";
		String regex = "a{3}\\w{3}\\d{3}a{3}";
		System.out.println(src.matches(regex)); // true

		// 3.字符串替换操作 字符串的replaceAll()和replaceFirst()方法
		// 注意: 只要字符串中有部分匹配成功即可执行替换操作
		regex = "a{3}";
		System.out.println(src.replaceAll(regex, "X"));
		System.out.println(src.replaceFirst(regex, "X"));
		
		// 4.字符串分割 split() 方法
		src = "aaa253xyz123aaa";
		regex = "\\d{3}";
		String[] strs = src.split(regex);
		System.out.println(Arrays.toString(strs));
		
	}
}

字符串查找操作 Pattern和Matcher

  • Pattern: 正则表达式对象
  • Matcher: 匹配器对象
public class RegexDemo04 {
	public static void main(String[] args) {
		// 没有是正则表达式的情况
		// 定义正则表达式字符串
		String regex = "x?yz";
		String src = "xyz";
		boolean matches = src.matches(regex);
		System.out.println(matches);
		
		// 将正则表达式字符串编译成正则表达式对象
		Pattern p = Pattern.compile(regex);
		// 通过正则表达式对象获取匹配器对象
		Matcher m = p.matcher(src);
		boolean matches2 = m.matches();
		System.out.println(matches2);
	}
}

案例

/*
On Friendship And a youth said, “Speak to us of Friendship.”
Your friend is your needs answered. He is your field which
获取两个字符组成的单词并且输出

On
to
us
of
is
He
is

\b[a-zA-z]{2}\b
*/

public class RegexDemo05 {
	public static void main(String[] args) {
		String src = "On Friendship And a youth said, \"Speak to us of Friendship.\"  Your friend is your needs answered. He is your field which";
		// 通过正则表达式字符串创建正则表达式对象
		Pattern pattern = Pattern.compile("\\b[a-zA-z]{2}\\b");
		Matcher matcher = pattern.matcher(src);
		/*boolean isFind = matcher.find();
		System.out.println(isFind);
		System.out.println(matcher.start());
		System.out.println(matcher.end());
		System.out.println(src.substring(matcher.start(),matcher.end()));
		
		isFind = matcher.find();
		System.out.println(isFind);
		System.out.println(matcher.start());
		System.out.println(matcher.end());
		System.out.println(src.substring(matcher.start(),matcher.end()));
		
		isFind = matcher.find();
		System.out.println(isFind);
		System.out.println(matcher.start());
		System.out.println(matcher.end());
		System.out.println(src.substring(matcher.start(),matcher.end()));*/
		
		while (matcher.find()) {
			// System.out.println(src.substring(matcher.start(),matcher.end()));
			System.out.println(matcher.group()); // 第0组
		}
	}
}

正则表达式的子表达式: 正则表达式的嵌套

public class RegexDemo06 {
	public static void main(String[] args) {
		String str = "Hello,World! in Andoid and java";
		
		Pattern p = Pattern.compile("W(or)(ld!)");
		Matcher matcher = p.matcher(str);
		
		while (matcher.find()) {
			System.out.println("Group 0: " + matcher.group()); // 默认以0组(整个字符串作为正则表达式)匹配
			System.out.println("Group 1: " + matcher.group(1)); // 使用第1组作为子正则表达式匹配
			System.out.println("Group 2: " + matcher.group(2)); // 使用第2组作为子正则表达式匹配
			
			System.out.println("Group 0: Start:" + matcher.start() + ",End: "+ matcher.end());
			System.out.println("Group 1: Start:" + matcher.start(1) + ",End: "+ matcher.end(1));
			System.out.println("Group 2: Start:" + matcher.start(2) + ",End: "+ matcher.end(2));
		}
	}
}
StringBuffer

之前我们学习过String类，每次拼接一个字符串，系统都为之开辟一个新的内存空间，这样既耗时又占用了大量的空间，

  • StringBuffer就可以处理这个问题，它是一个字符串缓冲区。
    可以把StringBuffer和StringBuilder理解为字符串的容器
    StringBuffer类概述
    线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，
    但通过某些方法调用可以改变该序列的长度和内容。

    StringBuffer() ：构造一个其中不带字符的字符串缓冲区，初始容量为 16 个字符。
    StringBuffer(CharSequence seq)：构造一个字符串缓冲区，它包含与指定CharSequence 相同的字符。
    StringBuffer(int capacity) ：构造一个不带字符，但具有指定初始容量的字符串缓冲区。
    StringBuffer(String str)：构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。

    增 ：
    StringBuffer append(String str)
    StringBuffer insert(int offset, String str)
    删 ：
    StringBuffer deleteCharAt(int index)
    StringBuffer delete(int start, int end)
    改：
    public StringBuffer replace(int start,int end,String str)
    其他：
    public StringBuffer reverse()
    public String substring(int start)
    public String substring(int start,int end)

public class StringBufferDemo01 {
	public static void main(String[] args) {
		StringBuffer sb = new StringBuffer();
		StringBuffer sb2 = sb.append("abc");
		
		System.out.println("sb: " + sb);
		System.out.println("sb2: " + sb2);
		
		sb.append("efg").append(false).append(20).append(new Object());
		System.out.println(sb);
		// abcefgfalse20java.lang.Object@7852e922
		sb.insert(sb.indexOf("j"), "Android");
		System.out.println(sb);
		// abcefgfalse20Androidjava.lang.Object@7852e922
		sb.deleteCharAt(sb.indexOf("2"));
		// abcefgfalse0Androidjava.lang.Object@7852e922
		System.out.println(sb);
		sb.delete(sb.lastIndexOf("f"), sb.indexOf("0"));
		System.out.println(sb);
		sb.replace(sb.indexOf("l"), sb.lastIndexOf("."), "util");
		System.out.println(sb);
		
		// sb.reverse();
		// System.out.println(sb);
		String str = sb.substring(sb.indexOf("7"));
		System.out.println(str);
		System.out.println(sb);
		
	}
}

一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。

  • 该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。

  • 如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。 用法完全和StringBuffer一样。

    经典面试题解析：
    String，StringBuffer，StringBuilder三者的区别。

    StringBuffer 线程安全 效率低 同步
    StringBuilder 线程不安全 效率高 不同步
    String 线程不安全 效率高 但是内容不可变

    1.访问百度网站 效率
    2.取钱 安全
    3.上厕所

    从代码中如何区分? - 在方法找一个关键字 synchronized

String

概述: 本质就是字符数组

  • 字符串的特点:
    1.字符串本质就是字符数组
    2.String 类代表字符串。Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。
    3.字符串常量存在于方法区的常量池中
    4.它们的值在创建之后不能更改
    5.字符串缓冲区支持可变的字符串 StringBuffer StringBuilder
    6.字符串的拼接在编译时期其实已经做了优化,使用的是StringBuilder
    s = (new StringBuilder(String.valueOf(s))).append(“World”).toString();
    System.out.println((new StringBuilder("s: ")).append(s).toString());
    7.因为 String 对象是不可变的，所以可以共享
    8.String s = “Hello”;和String s3 = new String(“Hello”);的区别
  •  前者在类加载的时候在方法区创建字符串对象,后者在new的时候在堆区中创建对象,在类加载的时候在方法区中创建对象

9.s3.intern();能够将指向堆区的指针指向方法区

字符串的构造方法

public String()

public String(String original)

public String(char[] value)  **** 将字符数组转换成字符串

public String(char[] value, int index, int count)

public String(byte[] bytes) **** 将字节数组转换成字符串

public String(byte[] bytes, int offset, int length) 

String(byte[] bytes, String charsetName)  处理字符串编码问题
什么是编码?
什么是解码?

public class StringDemo02 {
	public static void main(String[] args) throws UnsupportedEncodingException {
		String s = new String();
		System.out.println("s: " + s);
		
		s = new String("Hello");
		System.out.println("s: " + s);
		
		s = new String(new char[] {'a','b','c'});
		System.out.println("s: " + s);
		
		s = new String(new char[] {'a','b','c','d'} , 1, 2);
		System.out.println("s: " + s);
		
		s = new String(new byte[] {97, 98, 99, 100});
		System.out.println("s: " + s);
		
		s = new String(new byte[] {97, 98, 99, 100}, 1, 2);
		System.out.println("s: " + s);
		
		// 编码的操作
		String ss = "今晚攻打高老庄";
		byte[] bys = ss.getBytes("utf-8"); // 将字符串转换成字节数组  编码  默认是GBK GBK编码表 一个中文 两个数字 UTF-8一个中文三个数字
		// [-67, -15, -51, -19, -71, -91, -76, -14, -72, -33, -64, -49, -41, -81]
		// [-28, -69, -118, -26, -103, -102, -26, -108, -69, -26, -119, -109, -23, -85, -104, -24, -128, -127, -27, -70, -124]
		System.out.println(Arrays.toString(bys));
		
		// 解码的操作
		String result = new String(bys, "UTF-8");
		System.out.println(result);
		
		
	}
}

char charAt(int index)
int indexOf(int ch)
int indexOf(String str)
int indexOf(int ch,int fromIndex)
int indexOf(String str,int fromIndex)
int lastIndexOf(int ch) int lastIndexOf(int ch,int fromIndex)
int lastIndexOf(String str,int fromIndex)
String substring(int start)
String substring(int start,int end)
int length()

public class StringDemo03 {
	public static void main(String[] args) {
		String s = "HelloWorldorAndroid";
		/*System.out.println("charAt: " + s.charAt(0));
		System.out.println("charAt: " + s.charAt(1));
		System.out.println("charAt: " + s.charAt(2));
		System.out.println("charAt: " + s.charAt(3));
		System.out.println(s.length());*/
		for (int i = 0; i < s.length(); i++) {
			System.out.println("charAt: " + s.charAt(i));
		}
		System.out.println("===============");
		System.out.println("indexOf: " + s.indexOf('e'));
		System.out.println("int indexOf(String str) : " + s.indexOf("World"));
		// 从fromIndex索引处开始,从左往右找,返回某个字符ch在源字符串中出现的索引
		System.out.println("int indexOf(int ch,int fromIndex) :" + s.indexOf('l', 4));
		System.out.println("int indexOf(String str,int fromIndex): " + s.indexOf("or", 7));
		// 从fromIndex索引出开始,从右往左找,第一次出现字符串str在源字符串的索引
		System.out.println("int lastIndexOf(String str,int fromIndex): " + s.lastIndexOf("or", 15));
		
		System.out.println("String substring(int start): " + s.substring(s.indexOf('A')));
		System.out.println("String substring(int start,int end): " + s.substring(s.indexOf("W"), s.indexOf("A")-2));
	}
}

boolean isEmpty()：判断字符串是否为空。
boolean equals(Object obj)：将此字符串的内容与指定的对象比较,区分大小写。
boolean equalsIgnoreCase(String str)：将此 String 与另一个 String 比较,忽略大小写。
boolean contains(String str)：判断字符串中是否包含方法传入的字符串。
boolean startsWith(String str)：判断字符串是否以某个指定的字符串开头。
boolean endsWith(String str)：判断字符串是否以某个指定的字符串结尾。

public class StringDemo04 {
	public static void main(String[] args) {
		String s = "";
		System.out.println(s.isEmpty());
		
		/*String s1 = "";
		String s2 = new String();
		String s3 = null;
		
		System.out.println(s1.isEmpty()); // true
		System.out.println(s2.isEmpty()); // true
		System.out.println(s3.isEmpty()); // false
		 */		
		
		System.out.println("abc".equalsIgnoreCase("Abc"));
		
		System.out.println("HelloWorld".contains("World"));
		// "" + H + "" + e + "" + l + "" + l + "" + o + ""
		System.out.println("HelloWorld".contains(""));
		System.out.println("http://www.baidu.com".startsWith("http"));
		System.out.println("http://www.baidu.com".startsWith(""));
		System.out.println("HelloWorld.java".endsWith("java"));
		System.out.println("HelloWorld.java".endsWith(""));
	}
}

byte[] getBytes() ：将字符串转化为字节数组。
char[] toCharArray()： 将字符串转化为字符数组。
static String valueOf(char[] chs)： 返回 char 数组参数的字符串表示形式。
static String valueOf(int i) ：返回 int 参数的字符串表示形式。
String toLowerCase() ：将此 String 中的所有字符都转换为小写。
String toUpperCase() ：将此 String 中的所有字符都转换为大写。
String concat(String str)： 将指定字符串连接到此字符串的结尾。

public class StringDemo05 {
	public static void main(String[] args) {
		String s = "HelloWorld";
		byte[] bys = s.getBytes();
		// [72, 101, 108, 108, 111, 87, 111, 114, 108, 100]
		System.out.println(Arrays.toString(bys));
		
		char[] chs = s.toCharArray();
		System.out.println(Arrays.toString(chs));
		
		// 将任意类型转换成字符串
		System.out.println(String.valueOf(false));
		System.out.println(String.valueOf(10));
		System.out.println(String.valueOf(2.5));
		System.out.println(String.valueOf(new Object())); // java.lang.Object@7852e922
		
		System.out.println("HelloWorld".toLowerCase());
		System.out.println("HelloWorld".toUpperCase());
		
		System.out.println("Hello".concat("World"));
	}
}

String replace(char old,char new) ：替换功能。
String replace(String old,String new) ：替换功能。
String trim()：去除字符串两空格。
int compareTo(String str) ：按字典顺序比较两个字符串。
int compareToIgnoreCase(String str)：按字典顺序比较两个字符串，忽略大小写。
public String[] split(String regex)：分隔字符串成字符数组。

public class StringDemo06 {
	public static void main(String[] args) {
		String s = "HelloWorld";
		System.out.println(s.replace('e', '*'));
		
		System.out.println(s.replace("Hello", "Good"));
		
		String s2 = "	 Hello	 World  ";
		System.out.println(s2.trim() + "======");
		
		// int compareTo(String str) ：按字典顺序比较两个字符串。
		/*
		 * 针对英文 和 中文
		 */
		String s3 = "abcd";
		String s4 = "abce";
		System.out.println(s3.compareTo(s4));
		/*
		 *  public int compareTo(String anotherString) {
		        int len1 = this.value.length; 4
		        int len2 = anotherString.value.length; 4
		        int lim = Math.min(len1, len2); 4
		        char v1[] = this.value; "abcd"
		        char v2[] = anotherString.value; "abce"
		
		        int k = 0;
		        while (k < lim) {
		            char c1 = v1[k];
		            char c2 = v2[k];
		            if (c1 != c2) {
		                return c1 - c2;
		            }
		            k++;
		        }
		        return len1 - len2;
		    }
		 */
		// 系统提供了一个类帮助我们处理不同国籍的字符比较问题
		Collator collator = Collator.getInstance(Locale.CHINESE);
		int compare = collator.compare("李四", "李四");
		System.out.println(compare);
		
		String[] strs = "Hello-Wor-ld".split("-");
		System.out.println(Arrays.toString(strs));
	}
}

static String format(Locale l, String format, Object… args)
使用指定的区域设置，格式字符串和参数返回格式化的字符串。
static String format(String format, Object… args)
使用指定的格式字符串和参数返回格式化的字符串。
static String join(CharSequence delimiter, CharSequence[] elements)

public class StringDemo07 {
	public static void main(String[] args) {
		String join = String.join("_", "Hello", "World", "Java");
		System.out.println(join);
		String[] strs = join.split("_");
		System.out.println(Arrays.toString(strs));
		
		// static String format(String format, Object[] args) 
//		Object[] objs = {"张三", 18, '男', "打羽毛球"};
		String format = String.format("大家好我叫做%s,我今年%d,我的性别是%c,我的爱好是%s", "张三", 18, '男', "打羽毛球");
		System.out.println(format);
		
		System.out.format("大家好我叫做%s,我今年%d,我的性别是%c,我的爱好是%s", "张三", 18, '男', "打羽毛球");
	}
}
花絮自来飞
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
PHP中用正则表达式清除字符串的空白
12-18
如果您想要去掉字符串开始和结束的空白可以使用PHP内部函数trim() 。但是, 我们经常想完全清除空白。需要把开始和结束的空白清除掉，将多个空白变为一个空白，使用一个规则来处理同样的类型的其它空白。 完成这些...
Java用正则表达式实现${name}形式的字符串模板实例
08-31
在给定的实例中，`renderString` 方法演示了如何使用正则表达式和Java的 `Pattern` 和 `Matcher` 类来完成字符串模板的替换。以下是对这个方法的详细解释： 1. 首先，`renderString` 方法接受两个参数：一个包含...
正则表达式5个内部类
wxt_wjc的博客
01-15 372
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <meta http-equiv="X-...
JavaScript 正则表达式,五大内部类
houyanhua1的专栏
03-18 217
/^ $/表示精确匹配,      / /只要存在一个匹配的就为true;/^abc/    只要以"abc"开头的就为true;/abc$/    只要以"abc"结尾的就为true;*  {0,}     0个或多个+  {1,}     至少1个?  {0,1}    最多1个|   表示或者(没有&amp;)demo.html：&lt;!DOCTYPE html&gt; &lt;html&...
内部类中变量的查找
fenglei12的博客
10-09 101
在非静态内部类的方法中访问某个变量时，系统优先在该方法内查找是否存在该名字的局部变量，如果存在则用此局部变量；若不存在，则到该方法的内部类查找是否存在该名字的属性，若存在则用此属性；若还不存在，则到此内部类所在的外部类中进行查找，若存在，则取用，否则，报异常。 [code="java"] public class InnerTest { private int i = 2; p...
js正则(五大内部类)
gyq04551的博客
11-20 482
Title //-------------------------正则定义------------------- //正则定义。（1.内置对象法。 2.字面量） //1.对象定义法 var reg1 = new RegExp(/abc/); //2.字面量[]{}/a/
话说内部类与匿名内部类、正则表达式检验计算器输入（00）处理方式、设置JRame背景颜色实例
Xiyuting的专栏
06-18 1685
package com.meteor.regx; import java.awt.FlowLayout; import java.awt.event.FocusAdapter; import java.awt.event.FocusEvent; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; impo
正则表达式去除中括号（符号）及里面包含的内容
10-16
正则表达式是一种强大的文本处理工具，常用于匹配、查找、替换和提取字符串中的特定模式。在本主题中，我们将探讨如何使用正则表达式去除中括号（包括方括号`[`和`]`）以及它们内部包含的内容。 首先，我们要解决的...
javascript的正则表达式
01-08
正则表达式就是专门为了校验数据而产生的一个语法，除了可以校验数据，还可以提取一些想要的固定模式数据，还可以替换数据 – 替换字符串（正则表达式主要用于字符串的处理 ） 正则表达式就是一个模式，可以用来校验...
vbs正则表达式代码
09-06
在提供的代码中，定义了一个名为`RegExpTest`的函数，它接受两个参数：一个正则表达式模式（patrn）和一个字符串（strng）。在函数内部，创建了一个`RegExp`对象实例`regEx`，并设置了它的`Pattern`属性为传入的正则...
正则表达式匹配类
qq_32329745的博客
06-13 318
public class RegularUtils { private RegularUtils() { throw new UnsupportedOperationException("u can't fuck me..."); } // 验证手机号（现在手机号码水太深，来个短小粗暴点了只能） private static final Stri...
如何用正则表达式匹配出变量
lylymb的专栏
08-09 3686
如果想匹配"y|abc|" 中的abc，如何匹配呢？下面就是方法： System.Text.RegularExpressions.Regex regex = new System.Text.RegularExpressions.Regex(@"^/|y/|(?/w+)/|$");            string str = "|y|abc|";            if (regex
python正则表达式： 区配括号内部的内容
风一样的少年
05-26 753
本文借助的文章 https://blog.csdn.net/jk775800/article/details/90236812 感谢这位大神 进入正题 需求 字符串 insert values (’(eee)’,’(halee)’,‘fff’,’(77777)’) , 我想取出values括号内部的东西 ！！！失败的尝试： pattern = r'values.*\((.*)\)' c = re.search(pattern, a) # 然而得到 "77777)'" 这是因为正则表达式默认是
利用正则表达式来查找成员字段的赋值
技术的学习与积累是个技术活
08-31 1379
处理变量没有提供set方法时查找赋值的代码 正则表达式如下： 变量名\s*=\s*\w
正则表达式中的匹配，替换，切割，获取，这四个使用时具体用哪一个，进行案例分析
zhyzh134的博客
03-30 296
import java.util.TreeSet; /*  *   * 匹配，替换，切割，获取，到底用四种功能中的哪一个呢？或者那几个呢？  * 思路方式：  * 1：如果只想知道该字符串是否对或错，使用匹配。  * 2：想要将已有的字符串变成另一个字符串，替换。  * 3：想要按照自定的方式将字符串变成多个字符串，切割。获取规则以外的子串  * 4:想要拿到符合需求的字符
LeetCode-10-正则表达式匹配
Neal_caffrey
12-14 73
正则表达式匹配题目个人解详解动态规划五行代码？？？？手画图解 2020年12月14日未解出改题 题目 个人解 # anaconda 运行代码，因为在LeetCode中未运行通过，就不放LeetCode的代码了 s='ab' p='.*c' def isMatch(s,p): Ssize,Psize=len(s),len(p) Shead,Phead=0,0 if Psize==0 or Ssize==0: return False while Shea
NIIT2--JAVA活动（一）制作内部类 正则内部类
ai516001066的博客
03-09 52
1 package details; 2 3 import java.util.Scanner; 4 5 public class Candidtates { 6 private String name,qualification ,status; 7 private int age; 8 9 public vo...
数据研发笔试Leetcode刷题笔记18：正则表达式匹配
weixin_41961559的博客
05-03 127
文章目录1 题目描述2 代码实现（Python3） 1 题目描述 来源：力扣（LeetCode） 请实现一个函数用来匹配包含’. ‘和’‘的正则表达式。模式中的字符’.‘表示任意一个字符，而’'表示它前面的字符可以出现任意次（含0次）。在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"abaca"匹配，但与"aa.a"和"ab*a"均不匹配。 2 代码实...
内部类、常用类、正则表达式、File类(2015/8/01)
liujiaoruiIT的博客
08-01 575
内部类局部类 内部类、局部类 public class Student { private String name; private int age; public String getName() { return name; } public void setName(String name) {
用Python正则表达式判断字符串中既有大写字母又有小写字母
最新发布
05-24
可以使用Python内置的re模块，利用正则表达式来判断字符串中是否既有大写字母又有小写字母。以下是一个示例代码： ```python import re def has_upper_and_lower(text): # 定义正则表达式，匹配至少一个大写字母...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值