String类
字符串是一个特殊的对象
字符串一旦初始化就不可以被改变
String str = "hello"; //a指向对象"hello"
str =str+ " world";
输出 str= hello world //a指向新对象"helloworld" 对象 hello"没被改变
int I = 5;
int I = 6; 空间I内的数据由5变成了6
String str = "cdf"; //str是一个类类型变量，”abc”是一个对象
String str1= newString("cdf");
Str 和 str1 的区别
1， str 在内存中只有一个对象。 2，str1 在内存中有两个对象
String复写了equal()方法 在字符串中比较的是内容是否相同
str==str1 返回false str.equals(str1) 返回true
str2 = "cdf"; str==str2 返回true str.equals(str2) 返回true
说明str和str2指向的是同一个对象
Java中的共享设计设计思路是：在Java中形成一个对象池，在这个对象池中保存多个对象，新实例化的对象如果已经在池中定义了，则不再重新定义，而从对象池中直接取出使用。String就是因为采用了这样的设计，所以当内容重复是，会指向已存在的实例空间。
String类的方法
1，获取
1.1 字符串的长度 int length();获取字符串长度
在数组中获取长度 arr.length
1.2 根据位置(下标)获取相应某字符 charcharAt(int index);
1.3 根据字符获取该字符在字符串中的位置 不存在则返回-1
int indexOf(intch); ch可以接收字符然后自动转变成int 返回ch第一次出现的位置
intindexOf(int ch, int fromIndex);从fromIndex指定位置开始查找
intindexOf(String str); int indexOf(Stringstr, int fromIndex); 同上
2，判断
2.1 字符串中是否包含某一子串
boolean contains(str) if(str.indexOf("cdf")==-1)也可判断 条件成立则否
2.2字符串是否有内容
booleanisEmpty(); 原理就是判断长度是否为0
2.3字符串是否以指定内容开头结尾
booleanstartsWith(str) booleanendsWith(str)
2.4判断字符串内容是否相等 复写了Object类中的equals()方法
booleanequals();
2.5判断字符串内容是否相等并忽略大小写
booleanequalsIgnoreCase();
3， 转换
3.1将字符数组转换成字符串
构造函数方法 将数组转换成字符串
String(char[] arr) byte[] int[] char[]
String(char[]arr, offset, count)将起始下标offset开始字符个数count 的部分字符 转成字符串
静态方法：
static String copyValueOf(char[] arr)
static String copyValueOf(char[] arr, offset, count)
static StringValueOf(char[] arr)
ValueOf(数组，基本数据类型，对象)
3.2 将字符串转成字符数组
char[] toCharArray(str);
3.3将字节数组转化成字符串 构造方法
newString(byte[])
newString(byte[], offset, count)
3.4将字符串转成字节数组
Byte[]getBytes();
3.5将基本数据类型转成字符串
static String ValueOf(int)
static StringValueOf(double)
4， 替换
String replace(char oldchar, char newchar);
例：String s3 = s.replace('a','s'); //把s字符串中所有的a替换为s
5， 切割
String[] split(String);
例：String[]s4=s.split("a"); //以a为分割号分割字符串s返回字符串数组
6， 子串 获取字符串的一部分
String substring(int begin); 获取从下标begin到结尾
String substring(int begin, int end); 含头begin不含尾end
7， 转换
7.1 将字符串转成大写或小写
String toUpperCase(); String toLowerCase();
7.2 去掉字符串两端的多个空格
String trim();
7.3 对两字符串进行自然顺序的比较
intcompareTo(str) 比较到第一个不同的字符相差多少返回多少
字符串使用正则表达式处理更方便
替换 StringreplaceAll(String regex, String replacement)
匹配 booleanmatches(String regex) 告知此字符串是否匹配给定的正则表达式。
切割 字符串中 String[] Split(String regex)方法 根据规则来切割字符串
将字符数组转成字符串
String中的valueOf()方法 String s = String.valueOf(char[]);无发转换字节数组
基本数据类型转字符串 1，String.valueOf(基本数据) 2，Integer.toString(92)
valueOf(数据) 能将除了字节数组之外的数据字符数组 基本数据类型 转成字符串
构造方法只能将字符数组和字节数组转成字符串
构造方法数组转成字符串 String s = new String(char[]); 字节数组可转
Strings = new String(byte[]); 字符数组可转
字符串 转 数组
转成字符数组 字符串.toCharArray()
转成字节数组 字符串.getBytes()
字符串转成基本数据类型
Integer.parseInt(字符串) xxx.parsexxx(Dtring)
基本数据类型转成字符串 4
I nteger.toString(55)new Integer(55).toString()
55+"";
String.valueOf(55);
StringBuffer
StringBuffer是字符串缓冲区。是一个容器
特点：
1， 长度是可以变化的可存任意多少 数组需要先分配容量
2， 可以操作多个数据类型
3，最终会通过toString()方法变成字符串。
C create U update R read D delete
1， 存储
StringBuffer append();将指定数据添加到结尾处 面盆理论返回的是容器本身
StringBuffer append(int index, 数据); append()被重载可存入多种数据
把整个数据存储到下标index处
2， 删除
StringBuffer delete(int start,int end);删除缓冲区总的部分数据含头不含尾
StringBufferdeleteCharAt(int index); 删除指定位置的字符
3， 获取
Char charAt(int index) 获取字符
int indexOf(Stringstr) 获取str第一次出现的下标位置
int lastIndexOf(String str) 反方向查找str第一次出现的下标位置
int length();
String substring(int start, int end) 获取子串包含start 不包含end
4， 修改
StringBuffer replace(start, end, String) 从头到end-1的位置全部换成str
Void setCharAt(intindex, char ch) 字符ch替换index处字符 原串被改变
5， 反转
StringBuffer reverse()
6， void getchars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
把字符串指定位置srcBegin到srcEnd-1所有字符存放到字符数组dst中从dstBegin下标开始存放字符
StringBulider
JDK1.5 版本之后出现了StringBuilder,,构造一个其中不带字符的字符串生成器，初始容量为 16 个字符。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。
以后开发，建议使用StringBuilder
equal()在包装类中比较的是数值 在字符串中比较的是内容 在对象中比较的是地址
StringBuffer 和StringBuilder的区别：
StringBuffer线程安全。
StringBuilder线程不安全。
单线程操作，使用StringBuilder 效率高。
多线程操作，使用StringBuffer 安全。
*****************************************************************************
包装类
基本数据类型对象包装类：是按照面向对象思想将基本数据类型封装成了对象。
好处：
1：可以通过对象中的属性和行为操作基本数据。
2：可以实现基本数据类型和字符串之间的转换。
int Integer
char Character
byte Byte
short Short
float Float
long Long
boolean Boolean
基本数据类型转换成字符串
1， 基本数据类型+字符串"cdf"
2， 基本数据类型.toString(对应的基本数据类型值)
String s=Integer.toString(34) 34整数变成"34"字符串
String s=Double.toString(34.45) 34.45整数变成"34.45"字符串
字符串转变成基本数据类型 可用于判断某字符串是否全是数字
xxx a = Xxx.parseXxx(string) 数据不对的话会抛异常格式异常
inta = Integer.parseInt ("345") "345"转变为345
doubled = Double.parseDouble("9598.124");
booleanb = Boolean.parseBoolean("true");
基本数据类型.valueOf(String) String 转成基本数据类型
十进制转化成其他进制
static StringtoBinaryString(int); Integer.toBinaryString(95);将95转为2进制数据
static StringtoHexString(int);
Integer.toHexString(int); 或Double.toHexString(double); Float
static StringtoOctalString(int); Integer.toOctalString(int);
其他进制转化成十进制
staticint parseInt(String str,int radix)将radix进制数str转为10进制数
Integer.parseInt("345",8) 把8进制数345转为转为10进制
Integer.parseInt("11011",2) 把2进制数11011转为转为10进制
自动装箱 自动拆箱
Integer x = 4; //自动装箱
x=x+2; //x自动拆箱。变成int类型和2进行加法运算 再将和进行装箱给x
Integer i1 =127； Integer i1 = new Integer(127); Integer i1=Integer.valueOf(127);
Integer i2 =127 Integer i1 = new Integer(127); Integer i1=Integer.valueOf(127);
i1 ==i2 true i1 ==i2 false i1==i2 true
因为i1和i2指向了同一个Integer对象
当数值在byte范围内时 把byte 封装成Integer对象时Integer会将其放入一个byte对象池因为byte数据使用频率很大当需要再次封装byte时 Integer会去byte对象池查找如果该数值已经存在 则不会再开辟新的空间
享元设计模式 有很多个小的对象 他们有很多属性相同 把他们封装成一个对象，那些不同的属性 把他们作为方法的参数称之为外部状态相同的属性称之为内部状态
Window中的所有文件夹 虽然文件夹名不同位置不同(外部状态) 但是他们共享文件夹对象
*************************************************************************************************************
正则表达式：符合一定规则的表达式
作用：用于专门操作字符串；
特点：用于一些特定的符号来表示一些代码操作。这样就简化书写
所以学习正在表达式 就是在学习一些特殊符号的使用
好处：可以简化对字符串的复杂操作
弊端：符号定义越多，正则越长 阅读性越差
具体操作功能：
1，匹配：字符串中Boolean matches(String regex)方法. 用规则匹配整个字符串，只要有一处不符合规则，就匹配结束，返回false
2，切割：字符串中 String[] Split(String regex)方法 根据规则来切割字符串
3，替换： 字符串中 String[] replaceAll(String regex,Stringnew)方法 根据新字符串来替换符合规则的字符串
4，获取，首先将正则规则封装成模式对象Pattern. Compile(正则)然后 创建通过方法matcher()创建匹配器对象Matcher然后通过匹配器的find()方法找到符合正则的字符串 然后通过group()方法 返回字符串
1，匹配
邮箱的验证
String mailreg ="\\w{6,12}@[a-z0-9]{3,5}(.[a-z])+";
mail.metches(mailreg)
2，切割
将字符串按照叠词切割
String s ="adjjagtrekkkaeewejaaw";
String[] res =s.split("(.)\\1+");
按.切割
String[] res = s.split("\\.+");
按\\切割
String[] res = s.split("\\\\");
3，替换
将字符串中的连续5个以上的数字（手机号）替换成#
s.replaceAll("\\d{5,}","#");
将叠词 1，替换成 &
s.replaceAll("(.)\\1+","&");
2，替换成单个字符
s.replaceAll("(.)\\1+","$1");
预定义字符类
. 任何字符（与行结束符可能匹配也可能不匹配）
\d 数字：[0-9]
\D 非数字： [^0-9]
\s 空白字符：[ \t\n\x0B\f\r]
\S 非空白字符：[^\s]
\w 单词字符：[a-zA-Z_0-9]
\W 非单词字符：[^\w]
字符类
[abc] a、b或 c（简单类）
[^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]（减去）
Greedy 数量词
X? X，一次或一次也没有
X* X，零次或多次
X+ X，一次或多次
X{n} X，恰好 n次
X{n,} X，至少 n次
X{n,m} X，至少 n 次，但是不超过 m 次
组和捕获
捕获组可以通过从左到右计算其开括号来编号。例如，在表达式((A)(B(C))) 中，存在四个这样的组：
1 ((A)(B(C)))
2 \A
3 (B(C))
4 (C)
组零始终代表整个表达式。
组的一些举例说明
(.)\\1{2}(.)将规则封组(并这位置需要符合这规则) \1组1(第一组) {2}后面跟上符合这个组的内容 也就是满足连续3个组1规则
s.replaceAll("(.)\\1{2}","$1")将yyy替换成y(匹配到1个组1) yyyy--->yy(匹配到1个组1) yyyyyy-->yy(匹配到2个组1)
s.replaceAll("(.)\\1{1}","$1")将yyy替换成yy(匹配到1个组1) yyyy--->yy(匹配到2个组1) yyyyyy-->yyy(匹配到3个组1)
注：只有一个组 可以不写组1
但是 (.){2} 2个叠词 2个组1 类似 [0-9]{2}两个数字（没封组）
(.)\\1{2}3个叠词 组1后面跟两个组1
练习题需求
将IP地址进行地址段顺序的排序
192.168.1.254 102.49.23.103 10.10.10.52.2.2.2 127.0.0.1
按字符串自然顺序排序，只要让它们每一段都是3位即可
1，按照每一段需要的最多的0进行补齐，那么每一段就会至少保证有3位
2，将每一段只保留3位 这样 所有的IP地址都是每一段3位
3，将排序好的IP地址输出 补的0去掉
需求
将下列字符串转成：我要学编程：
我我...我我...我要..要要...要要...学学学..学学...编编编编....编程..程....程程程程..程.
到底用四种功能的哪一种呢：
思路
1，如果只想知道该字符是否是错，使用匹配
2，想要将已有的字符串变成另一个字符串，替换
3，想要按照自定的方式将字符串变成多个字符串，切割，获取规则以外的字符串
4，想要拿到符合需求的字符串，获取。获取符合规则的字串
点击打开链接java.util.regex
类 Pattern 正则表达式的编译表示形式。
正则表达式必须首先被编译为此类的实例(static Pattern compile(Stringregex))。然后，可将得到的模式用于创建 Matcher 对象，依照正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一模式。
常用方法
static Pattern compile(String regex) 将给定的正则表达式编译到模式中。
Stringpattern() 返回在其中编译过此模式的正则表达式。
StringtoString() 返回此模式的字符串表示形式。
Matchermatcher(CharSequenceinput) 创建匹配给定输入与此模式的匹配器。
java.util.regex
类 Matcher
通过调用模式Pattern的 matcher(Matchermatcher(CharSequenceinput))方法从模式创建匹配器。创建匹配器后，可以使用它执行三种不同的匹配操作：
l matches 方法尝试将整个输入序列与该模式匹配。
l lookingAt 尝试将输入序列从头开始与该模式匹配。
l find 方法扫描输入序列以查找与该模式匹配的下一个子序列。
每个方法都返回一个表示成功或失败的布尔值。通过查询匹配器的状态可以获取关于成功匹配的更多信息。
常用方法
boolean find() 尝试查找与该模式匹配的输入序列的下一个子序列。
String group() 返回由以前匹配操作所匹配的输入子序列。
Stringgroup(int group) 返回在以前匹配操作期间由给定组捕获的输入子序列。
int groupCount() 返回此匹配器模式中的捕获组数。
Pattern中的方法Matchermatcher(CharSequence input) 将字符串 按照指定的正则表达式的规则Pattern模式转换到Matcher匹配器中
CharSequence输入序列 是String的父类
1， 将正则规则进行对象封装Pattern p = Pattern.comile(正则规则)；
2， 同正则对象的matcher()方法 获取要对字符串操作的匹配器对象Matcher
Matcher m = p.matcher();
3， 通过Matcher匹配器对象的方法对字符串进行操作
(1) 通过m.find()方法找到符合正则规则的字符串
(2) 通过m.group()方法返回该字符串
练习：
网页爬虫 将网页上符合需求的内容字符串取出