关闭

黑马程序员-Java基础(数组,String,StringBuffer,正则表达式)

67人阅读 评论(0) 收藏 举报

数组

格式:

   元素类型[] 数组名 = 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。因为ab指向了同一个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.想要拿到符合需求的字符串子串,获取。获取符合规则的子串。

 

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:975次
    • 积分:103
    • 等级:
    • 排名:千里之外
    • 原创:10篇
    • 转载:0篇
    • 译文:0篇
    • 评论:0条
    文章存档