（十二）Object和String

大家好，欢迎来到IT知识分享网。

Object和String

面向对象讲完之后就是API，也就是我们现在要说的这些，这里面我们会接触大量的方法，只有多看多用，你才能记住，下面我们就来说一下常用的类。

Object class（对象类）

Objec是Java中的顶级父类，Java中所有的类都默认直接或者间接的继承object。Objec是Java中唯一没有父类的类，任何一个类的对象都可以用Object对象接住。

1、构造方法摘要

构造方法中提供的所有构造方法默认是public修饰的。

Object();

Object class 中只提供了这么一个无参的构造函数。

2、重要方法

1.clone();

 public class T1 implements Cloneable { 
    int i; public static void main(String[] args) throws CloneNotSupportedException { T1 t = new T1(); t.i = 5; T1 t1 = (T1) t.clone(); System.out.println(t); System.out.println(t1); } } 

2.equals(Object o);

Public boolean equals(Object obj){ if (this == obj) //1.判断地址是否一致 return true; if (obj == null) //2.判断参数是否为空 return false; if (getClass() != obj.getClass()) //3.判断类型是否一致 return false; Person other = (Person) obj; //4.强制转换类别 if (age != other.age) //5.判断属性是否一致 return false; if (gender != other.gender) return false; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; return true; } 

3.finalize();

个人理解：这个方法实在是很尴尬的一个方法，不能发号施令，只能干吆喝，干不干是别人的事。这就相当于街头小贩了，只吆喝，管不了你买不买。

4.getClass();

获取对象的实际类型（创建类型）。

5.hashCode();

6.toString();

返回对象的字符串形式，默认返回对象的地址。当打印对象的时候默认是调用了这个对象的toString方法。一般会重写。

面试题总结

String class（字符串类）

String class 就是字符串类，我看了源码，底层就是使用char数组存储数据的。

1、特点

String s = “abc”; //产生了1对象 String s = new String(“abc”); //产生了2个对象 String s = “a”; s += “b”; //产生了5个对象 String s = “a”; //产生了1个对象 s = new StringBuilder(“a”).append(“b”).toString(); //这个过程产生了4对象 String s = “a”; s += “b”; //1个a，1个b，2个对象。 String s = “a”; // s = new StringBuilder(“a”).append(“b”).toString(); //3个对象：StringBuilder1个，append拼接产生1个，toString产生1个。 s = new String(“ab”);//最终只存活了4个对象，StringBuilder产生的对象会被解析。

// 100个字符串组成的字符数组 String[] arr = new String[100]; // + 进行拼接 String s = “”; // 1 for(String str : arr){ s += str; //s = new StringBuilder(s).append(str).toString(); //300 } // StringBuilder StringBuilder sb = new StringBuilder(); // 1 for(String str : arr){ sb.append(str); // 100 } String s = sb.toString(); // 1

2、StringBuilder class（字符串生成器）

构造方法

StringBuilder();

构造一个不带任何字符的字符串生成器，其初始容量为 16 个字符。

StringBuilder(int capacity);

构造一个不带任何字符，容量有参数确定的字符串生成器。

StringBuilder(String str);

构造一个字符串生成器，并初始化为指定的字符串内容。

重要方法

append(object o);

将参数的字符串形式追加到此序列。

capacity();

返回当前容量。

3、StringBuffer class

4、字段摘要

字段摘要里面介绍的变量都是常量。

5、构造方法

String();

创建一个字符串对象。

String s = null; //没有对象产生。 String s = “ ”; //有1个对象，存储在常量池中，值为空即null。 String s = new String(); //堆内存中存储一个对象，值为null。 String s = new String(“ ”); //2个对象一个堆内存中，一个方法区中。 

String(byte[] bs);

将字节数组按照系统默认编码转化为字符串。

byte[] bs = { 
  97,98,100}; String s = new String(bs); Byte[] bs = “汉字”.getByte(); //转化为字节数组。 String s = new String(bs);

String(byte[] bs, Charset ch);

将字符串按照指定的编码编译。

String(byte[] bs,int index,int size,Charset ch);

将字节数组按照指定的编码ch，从下标index开始，转化size个。

String(char[] ch);

将字符数组中的元素拼接成一个字符串。

char[] cs = { 'a', 'd', 'e', 'g', 'b', 'm', 'o' }; String s = new String(cs);

String(char[] ch, int i, int k)

String(int[] codePoints,int offset,int count);

String(StringBuffer buffer);

分配一个新的字符串，它包含字符串缓冲区参数中当前包含的字符序列。该字符串缓冲区的内容已被复制，后续对它的修改不会影响新创建的字符串。

String(StringBuilder builder);

分配一个新的字符串，它包含字符串缓冲区参数中当前包含的字符序列。该字符串缓冲区的内容已被复制，后续对它的修改不会影响新创建的字符串。

6、重要方法

charAt(int index)

表示获取这个字符串指定下标index位置上的字符。

String s = “jbksedfgew”; System.out.println(s.charAt(4));

length()

System.out.println(s.length());

练习

 Scanner s = new Scanner(System.in); String str = s.nextLine(); s.close(); int letterNo=0,numberNo=0; for (int i = 0; i < str.length(); i++) { if(str.charAt(i)>='a'&&str.charAt(i)<='z'||str.charAt(i)>='A'&&str.charAt(i)<='Z'){ letterNo++; }else if(str.charAt(i)>='0'&&str.charAt(i)<='9'){ numberNo++; } } System.out.println("字母为"+letterNo+"个,数字为"+numberNo+"个");

Scanner s=new Scanner(System.in); String str = s.next(); s.close(); int count = 0; char[] c1 = new char[str.length()]; for (int i = 0; i < str.length(); i++) { char c = str.charAt(i); if(c>='0'&&c<='9'){ c1[count]=c; count++; } } c1=Arrays.copyOf(c1, count); Arrays.sort(c1); System.out.println(new String(c1));

 Scanner s = new Scanner(System.in); String str =s.next(); s.close(); int sum = 0; for (int i = 0; i < str.length(); i++) { sum+=(str.charAt(i)-'0'); } System.out.println(sum);

compareTo(String str);

比较两个字符串的大小。根据返回值的正负来确定大小

底层过程

System.out.println(str.compareTo("dhnalgola")); System.out.println(str.compareToIgnoreCase("DHNALGOLA"));

compareToIgnoreCase(String str);

不区分大小写比较两个字符串的大小。

concat(String str);

将参数字符串拼接到对象字符串的末尾,返回一个新的字符串而不改变原串。

底层过程

 //将参数字符串拼接对象字符串的尾部---产生一个新串而不改变原串 /* * 1. 将两个字符串转化为字符数组 * c1, c2 * 2. 将两个字符数组进行合并 * char[] cs = new char[c1.length + c2.length]; //创建一个新数组。 * System.arraycopy(c1,0,cs,0,c1.length); //将两个数组放入新数组 * System.arraycopy(c2,0,cs,c1.length,c2.length); * 3. 将合并后的字符数组转化为字符串返回 * return new String(cs); */ System.out.println(str.concat("abc")); System.out.println(str);

注意：在String中提供了一系列的操作而不改变的原串的方法。

contains(String str)

判断是否包含指定的子串

endsWith(String s);

判断字符串是否以指定字符结尾。经常用于筛选。

equals(Object o)

String中已经对equals做了重写。判断两个字符串是否相等，判断的是实际值。

 String str = new String("abcdefghijkmn"); // 判断是否包含指定的子串 System.out.println(str.contains("dee")); // 判断是否是指定的结尾---筛选 // .docx System.out.println(str.endsWith("mn")); // 判断是否为指定的开头 System.out.println(str.startsWith("a")); // 对equals方法做过了重写，判断的是两个字符串的实际值是否一样 // 将两个字符串转化为字符数组，然后按位比较 System.out.println(str.equals(new String("ABCDEFGHIJKMN"))); // 适用于验证码，不区分大小写 System.out.println(str.equalsIgnoreCase(new String("ABCDEFGHIJKMN")));

equalsIgnoreCase(String str);

忽略大小写判断是否相等。

getBytes();

将字符串转化为字节数组，如果不指定编码，会按照默认的系统平台码转化。

getBytes(Charset ch);

 String str = "中文"; // 表示将字符串转化为字节数组 // 如果没有指定编码，会默认采用系统平台码 byte[] bs = str.getBytes("utf-8"); System.out.println(bs.length); System.out.println(new String(bs, 0, 3, "UTF-8")); for (byte b : bs) { System.out.println(b); } byte[] bs = { 
  12,55,120,127,15}; // 将字节数组转化为字符串 // 表示从字节数组的下标为1的位置开始转化，转化2个字节 System.out.println(new String(bs,1,2));

练习

public static void printStr2(String str,int number){ //判断字符串是否为空 if(str==null){ return; } //判断字节个数是否是非负数 if(number<0){ return; } //先将所有的字符看成中文 int index = number/2; //按照这个新的长度从原字符串身上截取 String newstr = str.substring(0,index); while(newstr.getBytes().length!=number){ //如果少来就多添加一个字符 if(newstr.getBytes().length<number){ index++; newstr = str.substring(0,index); }else{ index--; newstr = str.substring(0,index); break; } } System.out.println(str.substring(0,index)); }

方法二：

public static void printStr1(String str,int number){ //判断字符串是否为空 if(str==null){ return; } //判断字节个数是否是非负数 if(number<0){ return; } //获取字符串对应的字节数组 byte[] b = str.getBytes(); //创建一个新的字节数组用来放截取之后的字节组数 byte[] newb = Arrays.copyOf(b, number); //将新数组转化成一个字符串 String st = new String(newb); //获取这个字符串最后一个字符 char c = st.charAt(st.length()-1); //获取原字符串对应位置上的字符 char oldc = str.charAt(st.length()-1); System.out.println(c == oldc ? st : new String(newb, 0, newb.length - 1));

hashCode();

String中的hashCode方法做过了重写，同一个字符串在任何情况下的哈希码都是一样的。

indexOf(char c/String s);

获取指定字符c在字符串中的第一次出现的位置，如果找不到该字符会返回一个-1。

indexOf(char c /String s,int i);

表示从指定的下标i开始向后寻找该字符c出现的位置。

练习

public static void all(String str, String sub) { // 判断str是否为null if (str == null) { return; } // 记录位置 int index = 0; while (index < str.length()) { // 获取指定字符第一次出现的位置 index = str.indexOf(sub, index); if (index != -1) { System.out.println(index); index++; } else { return; } }

isEmpty();

判断字符串长度是否为0.

lastIndexOf(char ch/String s);

表示最后一次出现的位置。

lastIndexOf(char ch,int indexfrom);

从指定下标开始向前寻找最后一次出现的位置。

replace(char oldch,char newch);

startsWith(char ch);

判断是否指定参数作为开头。作为筛选使用。

subString(int index);

从指定下标开始截取。

subString(int beginIndex,int endIndex);

从指定位置开始截取，截取到指定位置的前一位。

toCharArray();

将字符串转化为字符数组。

toLowerCase() ;

转化为小写。

底层

toUpperCase();

转为大写。

toString();

返回本身。

trim();

去掉字符串前后的空白符。

valueOf(int i/char c/boolean b/long l/Object o);

返回参数的对应字符串形式。

 // valueOf是一个静态方法---表示将参数转化为一个字符串 // 如果传入的是一个对象，则会调用这个对象的toString方法 System.out.println(String.valueOf(new Object())); System.out.println(String.valueOf(new int[] { 2, 5, 1, 7, 0 })); // 如果传入的是字符数组，则会转化为字符串显示 System.out.println(String.valueOf(new char[] { 'a', 'b', 'c' })); System.out.println(new char[] { 'a', 'd', 'g' });

7、Pattern class（正则表达式（Regex））

1.作用

用于过滤筛选。

2.正则类型

字符型

[abc]

a、b或c。[]括号中的字母可以按照自己的使用要求任意改换。

//字符串由三个字母组成， abc/def/opq System.out.println(str.matches("[cab][def][opq]"));

[a-zA-Z]

a 到z或A到Z，两头的字母包含在内。[]括号中的内容可以按照自己的使用要求任意替换成一段连续的字符。

// 判断字符串是否是由一个字母组成 System.out.println(str.matches("[a-zA-Z]"));

[^abc]

任何字符，除了a、b或c。[]括号中的字母可以按照自己的使用要求任意改换。

// 字符串由一个字符组成，字符不是a/d/h/l/p System.out.println(str.matches("[^adhlp]"));

通配符/预定义字符类

.点

表示任意字符。

 // 匹配字母a开头的由两个字符组成的字符串 // . 表示任意字符 System.out.println(str.startsWith("a") && str.length() == 2); System.out.println(str.matches("a."));

\\.

表示匹配点。

 // 匹配 "." System.out.println(str.matches("\\."));

\\\\

匹配反斜杠。

 // 匹配 \ // "\\\\ " -> "\\" -> \ // 路径名 System.out.println(str.matches("\\\\"));

\\d

表示所有数字。

 // 任意一个数字 System.out.println(str.matches("[0-9]")); System.out.println(str.matches("\\d"));

\\D

表示非数字。

\\s 小写s

表示空白符。

\\S

表示非空白。

\\w 小写w

表示单词字符。

\\W

非单词字符。

数量词

+

表示至少出现一次。>=1。

 // 匹配字符a开头的至少由两个字符组成的字符串 // System.out.println(str.startsWith("a") && str.length() >= 2); // + 表示至少出现一次 // "a+" 至少出现1个a System.out.println(str.matches("a.+"));

?

表示至多出现一次。<=1。

 // 匹配字符a开头的至多由2个字符组成的字符串 // ？表示至多一次 System.out.println(str.matches("a.?"));

*

表示可有可无，有的话不限制次数。>=0。

 // 匹配字符串"ab"/"abc"/ abcc // * 表示可有可无 ---如果有的话，不限制次数 System.out.println(str.matches("abc*"));

{n}

表示有n个字符组成。==n。

 // 匹配由5个字符组成的字符串 System.out.println(str.length() == 5); // {n} 表示恰好由n个字符组成 System.out.println(str.matches(".{5}"));

{n,}

至少有n个组成。>=n。

 // 匹配至少由5个字符a组成的字符串 // {n,} 至少由n个组成 // + -> {1,} System.out.println(str.matches("a{5,}"));

{n,m}

数量在n到m之间。

 // 匹配由8-12个字符组成的字符串 System.out.println(str.matches(".{8,12}"));

注意

package cn.tedu.regex; import java.util.Scanner; public class PatternExer1 { 
    public static void main(String[] args) { Scanner s = new Scanner(System.in); String str = s.nextLine(); s.close(); // 3.21 10.53 System.out.println(str.trim().matches("0\\.\\d+|[1-9]\\d+\\.\\d+")); } }

public class PatternExer5 { 
    public static void main(String[] args) { String password = ""; System.out.println(checkPwd(password)); } private static boolean checkPwd(String password) { // 判断密码是否为空 if (password == null) { return false; } // 判断密码的位数是否符合 if (!password.matches(".{8,12}")) { return false; } // 记录出现的字符的种类 int i = 0; // 判断是否含有字母 if (password.matches(".*[a-zA-Z].*")) { i++; } // 判断是否包含数字 if (password.matches(".*\\d.*")) { i++; } // 判断是否有符号 if (password.matches(".*\\W.*")) { i++; } else if (password.matches(".*_.*")) { i++; } return i >= 2; } }

捕获组

(字符)

捕获组。

 // (字符) --- 捕获组 System.out.println(str.matches(".*(abc).*"));

\\n

 // 匹配至少含有两个"abc"的字符串 // \\n 表示引用之前对应编号为n的捕获组---捕获组的编号是从1开始的 System.out.println(str.matches(".*(abc).*\\1.*"));

练习

1.匹配邮箱（典型练习）

package cn.tedu.regex; public class PatternExer4 { 
    public static void main(String[] args) { String email = ""; System.out.println(checkEmail(email)); } private static boolean checkEmail(String email) { return email == null ? false : email.matches("\\w+@[0-9A-Za-z]+(\\.com)|\\w+@[0-9A-Za-z]+(\\.com)?(\\.cn)"); } }

8、String中包含正则的重要方法

matches(String regex);

是否匹配参数。

replaceAll(String regex,String replacement);

将一类东西替换。后一个参数想引用前一个参数的捕获组，改用$符。$这个符号，仅限于此方法使用。

 // String str = "adag35bknl2nkld08aadb"; // 将数字替换为* // System.out.println(str.replaceAll("\\d", "*")); // 消除所有的数字 // System.out.println(str.replaceAll("\\d", "")); String str = "Amy Tom Sam David Grace"; // Tom和David调换顺序 System.out.println(str.replaceAll("(.*)(Tom)(.*)(David)(.*)", "$1$4$3$2$5"));

练习

public static void main(String[] args) { Scanner s = new Scanner(System.in); String str = s.next(); s.close(); while (str.length() > 0) { // 记录字符串的原始长度 int len = str.length(); // 获取这个字符串的首字母 char c = str.charAt(0); // 判断数量词 if (c == '+' || c == '?' || c == '*') { str = str.replaceAll("\\"+c + "", ""); }else // 去除掉这个字符串中的这个字母 str = str.replaceAll(c + "", ""); System.out.println(c + ":" + (len - str.length())); } }

package cn.tedu.regex; public class PatternExer3 { 
    public static void main(String[] args) { String str = "我我我我我我爱爱爱爱学学学学学学学学学学学学编编编程程程程程程"; System.out.println(str.replaceAll("(.)\\1+", "$1")); //$表示对前一个参数捕获组的引用 } }

replaceFirst(String regex,string newstr);

将字符串的首个reges替换为newstr。

练习

字符串碎片的平均长度。

 String str = "aasdddfdg"; // 记录字符串的长度 int len = str.length(); // 记录碎片的个数 double i = 0; while (str.length() > 0) { // 去掉首个叠字 str = str.replaceFirst("(.)\\1*", ""); // 记录+1 i++; } System.out.println(len/i);

split(String regex);

以参数regex作为切割符将字符串分开，切完之后，作为切割符的字符就被切除掉了。如果两个切割符相连，这两个切割符之间会切出一个空字符串（“”）;如果切割符在末尾，直接切除。如果在开头，会切出一个空字符串（“”）。

 String str = "3aga2dha48nsl9dfg0"; // 以数字作为切割符将字符串分开 // 切完之后，作为切割符的符号就没切除掉了 // 如果两个切割符相连，这两个切割符之间会切出一个 "" // 如果切割符在末尾，则会直接切除 String[] arr = str.split("\\d"); System.out.println(Arrays.toString(arr));

Object和String类大部分常用的方法，都给大家罗列出来了，有个别不常用的可以查找API。