内部类正则表达式字符串

「爱情、让人受尽委屈。」 2021-10-30 01:24 334阅读 0赞

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

内部类的概述: 把类定义在类的内部  
几个需要区分的概念:  
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, '男', "打羽毛球");
    	}
    }