数组
格式：
元素类型[] 数组名 = new 元素类型[元素个数或数组长度]
ex: int[] x= new int[3]
注意：int是元素类型，x是数组类型，其实x里赋值的不是数字，而是地址
栈：是用完了之后就是放 。x
堆：new定义的都在堆里。 newint[3] 堆里不赋值的情况下都有默认值。类型不一样默认值也不一样。
ex:
int[ ] x= new int [ 3 ];
int[ ] y= x;
y[1]=89; //x[1]的值是89
总结：x和y使用一个new int[3]
int[ ] x=new int[3];
int[ ] y=new int[3];
y[1]=89; //x[1]的值是0
但是这个函数是使用各自各的new int[3]
定义数组方法：
int[ ] x=newint[3];
int x[ ]=new int[3];
int[ ] x=new int[]{4,2,3}; //注意不要指定数组
int[] arr={4,2,3}
String
字符串最大特点：一旦被初始化就不可以被改变。
String s1="abc" //s1是一个类类型变量，“abc"是一个对象。
String s2=new String("abc"); //new一个对象 abc又一个对象
Strings3="abc";
Q:s1和s2有什么区别？
A:s1代表一个对象。s2有两个对象。
s1.equals(s2) // true
s1==s2 //false
s1==s3 //true
String类使用与描述字符串事物。
A:1）获取：
1.1 字符串中的包含的字符数，也就是字符窜的长度。
intlength(); //获取长度 s.length()
1.2 根据位置获取位置上的某个字符。
char charAt(int index) s.charAt()
StringIndexOutOfBoundsException访问到字符串中不存在的角标是会发生的错误
1.3 根据字符获取字符在字符选中位置
int indexOf(int ch) //返回ch在字符窜中第一次出现的位置
int indexOf(int ch,intfromIndec); //从formIndex指定位置开始，获取ch在
字符串中出现的位置。
int indexOf(String str)；
int indexOf(String str,intfromIndec); //如果没有找到返回-1
int lastIndexOf(int ch,intfromIndec) //从右到左查找，但是角标不会变化
2）判断
2.1 字符串中是否包含某一个字符串
boolean contains(str);
特殊之处：IndexOf(str)：可以索引str第一个出现位置，如果返回-1，表示该str
不在字符串中存在。所以，也可以用于对指定字符串的判断是否包含
2.2 字符串是否有内容
boolean isEmpty(); //原理就是判断长度是否为0
2.3 字符串是否是以指定内容开头
boolean startsWith(str);
2.4 字符串是否是以指定内容结尾
boolean endsWith(str);
2.5 判断字符串内容是否相同
boolean equals(str);
2.6 判断内容是否相同，并忽略大小写
boolean equalsIgnoreCase();
3）转换
3.1 将字符数组转成字符串。
构造函数：String(char[])
String(char[],offset,count):将字符数组中德一部分转成字符串。
静态方法：
static String copyValueOf(char[]); //返回制定数组中表
示该字符序列的String
static String copyValueOf(char[] data,intoffset,int count);
static String valueOf(char[]);
3.2 将字符串转成字符数组。
char[] toCharArray();
3.3 将字节数组转成字符串。
String(byte[])
String(byte[],offset,count) //将字符数组中德一部分转成字符串。
3.4 将字符串转成字节数组。
byte[] getBytes();
3.5 将基本数据类型转成字符串。
static String valueOf(int)
static StringvalueOf(double)
特殊：字符串和字节数组在转换过程中，是可以指定编码表的。
4）替换
String replace(oldchar,newchar); //如果要替换的字符不存在，返回的还是原串。
例： String s1=s.replace('a','n');
sop(s1);
Strings2=s.replace("java","c++");;
5）切割
String[] split(regex);
6）子串,获取字符串中的一部分
String substring(开始数字); //从指定位置开始到结尾，如果角标不存在，会出现字符
串角标越界异常。
String substring(开始数字,结束数字);//包含头，不包含
尾。s.substring(0,s.lentgh());
7）转换，出去空格，比较。
7.1 将字符串转成大写或则小写。
String toUpperCase();
String toLowerCase();
7.2 将字符串两端的多个空格去除。
String trim();
7.3 对两个字符串进行自然顺序的比较。
int compareTo(string);
reverse(chs) //反转数组
StringBuffer
StrignBuffer是字符串缓冲区。是一个容器。 //数据不确定的时候使用
缓冲区的三个特点：
1）而且长度是可变化的。
2）可以直接操作多个数据类型。
3）最终可以用toString方法变成字符串
CURD:create update read delete
1）存储
StringBufferappend():指定的数据作为参数添加到已有数据结尾处。
StringBufferinsert(index,'数据')：可以将数据插入到指定Index index得从1数
2）删除
StringBufferdelete(start,end):删除缓冲区中德数据，包含start,不包含end//0开始
StringBufferdeleteCharAt(index):删除指定位置的字符
3）获取
charcharAt(int index)
int indexOf(String str)
intlastIndexOf(String str)
intlength()
Stringsubstring(int start,int end) //注意：他返回的不是StringBuffer
4）修改
voidsetCharAt(int index,char ch)
StringBuffer replay(int start,int end,String str)
5）反转
StringBufferreverse()；
6）将缓冲区中指定数据存储到指定字符数组中
voidgetChar（int srcBegin,int srcEnd,char[] dst,int destBegin)
JDK1.5版本之后出现了StringBuilder
StringBuffer是线程同步。 //多线程使用
StringBuilder是线程不同步。 //单线程使用
升级三个因素：
1）提高效率
2）简化书写
3）提高安全性
基本数据类型对象包装类
基本数据类型(前面字母小写) 引用数据类型(前面字母大写)
byte Byte
short Short
int Integer
long Long
boolean Boolean
float Float
double Double
char Character
基本数据类型对象包装类的最常见作用，就是用于基本数据类型和字符串类型之间做转换。
1）基本数据类型转成字符串
基本数据类型+""
基本数据类型.toString（基本数据类型值）；
如：Integer.toString(34);//将34整数变成“34”
2）字符串转成基本数据类型
xxx a=Xxx.parseXxx(String);
如：inta=Integer.parseInt("123");
doubleb=Double.parseDouble("12.23");
booleanc=Boolean.parseBoolean("true");
Integer i=newInteger("123"); //integer对象转换成int的值
int num=i.intValue();
3）十进制进制转成其他进制
Integer.toBinaryString(6);
Integer.toHexString(6);
4）其他进制转成十进制
Integer.parseInt(string,radix);
如：intx=Integer.parseInt("110",2);
intx=Integer.parseInt("3c",16 );
JDK1.5版本以后出现的新特性。
Integer x=new Integer(4); Integer x=4; //这两个一样
Integer x=4; //自动装箱
x=x+2; //x+2:x进行自动拆箱。变成了Int类型，和2进行加法运算。
再将和进行装箱赋给x
Integer a=128:
Integer b=128:
sop(a==b); //false
Integer a=127:
Integer b=127:
sop(a==b); //true 结果为true。因为a和b指向了同一个Integer对象。
注意：因为当数值在byte范围内容，不对新特性，如果该数值已经存在，则不会再开辟新的空间 -128~127
正则表达式 regex
符合一定规则的表达式
作用：用于专门操作字符串
好处：可以简化对字符串的复杂操作
特点：用一些特定的符号来表示一些代码操作，这样就简化书写。
所以学习正则表达式，就是在学习一些特殊符号的使用
弊端：符号定义越多，正则越长，阅读性越差
具体操作功能：
1.匹配：String matches（String regex） //告知此字符串是否匹配给定的正规表达式
用规则匹配整个字符串，只要有一处不符合规则，就匹配结束，返回false
2.切割：String split();
3.替换：String replaceAll（）;
4.获取：将字符串中的符合规则的子串取出
Pattern matcher()
find() //尝试查找与该模式匹配的输入序列的下一个子序列
start()
end()
group()
String regex="[1-9][0-9]{4,14}"
[abc]
[abc]
[a-zA-Z] a到z或A到Z
[a-d[m-p]] a到d或m-p(并集)
[a-z&&[def]] d,e或f(交集)
\d 数字：[0-9]
\D 非数字 [^0-9]
\w 单词字符：[a-zA-Z_0-9]
\W 非单词字符：[^\w]
String reg="[a-zA-Z]\\d"
X? X，一次或一次也没有
X* X,零次或多次
X+ X,一次或多次
X{n}？ X,恰好n次
X{n,} X,至少n次
X{n,m} X,至少n次，但是不超过m次
\b 单词边界
-----
"\\."점을 切할때,그냥 점은 任意符号
\\ "\\\\"
kkqqzz "(.)\\1" 叠词完成切割
azzzzzo "(.)\\1+"
可以将规则封装成一个组。用（）完成。组的出线都有编号。
从1还是。想要使用已有的组可以通过 \n（n就是组的编号）的形式来获取
-----
str=str.replaceAll(reg,newStr)
replaceAllDemo(str,"\\d{5,}","#")
-----
获取操作步骤：
1.将正则表达式封装成对象。 Pattern(没有构造函数，返回值是自己)
2.让正则对象和要操作的字符串相关联
3.关联后，获取正则匹配
4.通过引擎对符合规则的子串进行操作，比如取出。
RegexDemo2.java
import java.util.regex.*;
//将规规则封装成对象
Pattern p=Pattern.compile(reg);
//让正则对象和要操作的字符串相关联
Matcher m=p.matcher(str);
System.out.println(m.matches()); //其实String类中的matches方法。用的就是Pattern和Matcher对象完成的，只不过被String的方法封装后，用起来较为简单，但是单一
boolean b=m.find(); //将规则作用到字符串上，并进行符合规则的子串查找
System.out.println(m.group()); //用于获取匹配后结果。
什么情况里使用四种功能重的哪一个呢？或者那个几个呢？
思路方式：
1.如果只想知道该字符是否对是错，使用匹配。matches
2.想要将已有的字符串变成另一个字符串，替换。replace
3.想要按照自定的方式将字符串变成多个字符串，切割。split 获取规则以外的子串
4.想要拿到符合需求的字符串子串，获取。获取符合规则的子串。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
