黑马程序员——第四章 JavaAPI之常用类

最新推荐文章于 2021-05-18 22:49:55 发布

clearlovedog

最新推荐文章于 2021-05-18 22:49:55 发布

阅读量381

点赞数

本文链接：https://blog.csdn.net/zoutyp/article/details/45691753

版权

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

Object类

java.lang.Object

Object类是Java中所有类的父类，一切类都直接或者间接继承Object类。

native本地，这是一个用C/C++编写的本地方法，运行在本地方法栈。

常见方法

1，Object类方法 toString

public String toString()：对象描述

public String toString(){

return getClass()+"@"+Integer.toHexString(hashCode());

}

int hashCode()是Object类自己的方法，运行结果是一个十进制数的哈希值。

toHexString(十进制) 计算结果就是十六进制。

建议Object子类重写Object类的toString()方法，建立自定义的对象字符串

重写的依据：成员变量，做到将类中所有的成员变量连接变成字符串，返回此字符串。

System.out.println(a)实际是System.out.println(a.toString( ))

2，Object类方法 finalize

JVM启动垃圾回收器前调用这个方法。

3，public boolean equals(Object obj) {}

java认为，所有的对象，都具备比较性，因此Object中，定义了一个比较对象的方法equals。

重写equals方法，建立对象的自己的比较方式，不比较内存地址，比较的是对象的成员变量的值。

重写的依据就是类的成员变量。

==和equals的区别：

==比较基本数据类型，比较具体数值是否相等。

== 两边是引用数据类型，比较的是两个对象的内存真实地址。

equals默认情况下，比较的是两个对象的真实地址。

String类

java.lang.String

String类的定义方法

第一种： String s= "abc"，创建一个对象 s直接指向对象"abc"。

第二种： String s1= new String("abc")，使用的是String类的构造器，创建两个对象，对象"abc",对象 new String()，变量s1指向的是newString() 。

字符串的特点

实际：publicfinal class String s = “abc”；字符串实际是加final的字符数组。

特点一：不需要new 的对象，直接写双引号，就表示一个字符串对象。

特点二：String前面实际有final修饰，所以字符串是常量，一旦创建，不能改变。

输出字符串的时候，其实输出的就是那个字符数组，但是输出语句println对字符串数组直接遍历，所以看到的是每个字符，不是地址。

"" 和null的区别：""是对象；null是常量，不占内存。

String类的构造方法

空参，byte[]转成String，char[]转成String

1，空参数构造，new String(),

2，byte[]转成String，new String(字节数组),查询ASCII编码表。

例：byte[] b = {97,98,99};

//将字节数组传递给String类的构造器

String s = new String(b);//s = “abc”

3，byte[]一部分转成String，，new String(字节数组,int,int)，第一个int是开始下标，第二个int是获取几个，注意的数组的长度，防止越界异常。

例：byte[] b = {97,98,99,100,101,102};

//将字节数组传递String构造器，从下标2开始转3个

String s = new String(b,2,3);//s =“cde”

4，char[]转成String，new String(字符数组)

例：char[] ch ={'n','v','q','3','w','a'};

//将字符数组传递给String构造器

String s = new String(ch);//s=“nvq3wa”

5，char[]一部分转成String，new String(字符数组,int,int) ，第一个int是开始下标，第二个int是获取几个，注意的数组的长度，防止越界异常。

例：char[] ch ={'n','v','q','3','w','a'};

//将字符数组传递String构造器，从下标1开始转4个

String s = new String(ch,1,4);//s=”vq3w”

String的判断方法 -- 都是布尔类型

equals，equalsIgnoreCase，isEmpty，startsWith，endsWith

1，判断两个字符串是否完全相等，重写Object类的equals，两个字符串完全相等，返回真，有一点不同，返回假，equals(Objectobj)。

例：String s1 = "hello";

String s2 = newString("hello");

boolean b = s1.equals(s2);//b=true

String s3 = null;

String s4 = null;//s3==s4

b = s3.equals(s4);//空指针异常

2，判断两个字符串是否相等，忽略大小写，equalsIgnoreCase(String s)。

例：String s1 = "hello 汉字 world";

String s2 = "hello 汉字 World";

boolean b =s1.equalsIgnoreCase(s2);//b=true

3，判断一个字符串是不是空串""，isEmpty()，开始于JDK1.6(包含)以后版本。

例：String s = " ";

boolean b = s.isEmpty();//b=false

4，判断一个字符串是否以另一个字符串开头，startsWith(String s)。

5，判断一个字符串是否以另一个字符串结尾，endsWith(String s)，反向查找。

例：String s = "Demo.java";

boolean b =s.startsWith("Demo.java");//b=true

b =s.endsWith(".java");//b=true

String类的获取方法

charAt， indexOf， lastIndexOf ，substring，length

1，指定下标，返回这个下标上的单个字符，charAt(int index)，注意越界异常。

例：String s = "howareyou";

char ch = s.charAt(2);//ch=’w’

2，指定字符，找这个字符在字符串中第一次出现的下标，indexOf(char ch)，如果没有找到，返回负数。

例：String s ="howoldareyou";

int i = s.indexOf('d');//i=5

3，指定字符，找这个字符在字符串中第一次出现的下标，indexOf(char ch,int formIndex)，指定开始查找的位置索引。如果没有找到，返回负数;如果索引过大，不会报越界异常，而是返回负数；如果索引为负数，则索引默认为0开始查找。

例：String s ="howoldareyou";

int i= s.indexOf('o',5);//i=10

4，指定字符串，找字符串在另一个字符串中第一次出现的下标，indexOf(String s)。

5，指定字符串，找字符串在另一个字符串中第一次出现的下标，indexOf(String s,int fromIndex)，指定开始查找的位置。如果没有找到，返回负数;如果索引过大，不会报越界异常，而是返回负数；如果索引为负数，则索引默认为0开始查找。

例：String s ="howoldareyou";

int i= s.indexOf("are");//i= 6

i = s.indexOf("are",7);//i= -1

6，指定字符，找这个字符在字符串最后一次出现的下标，lastIndexOf(char ch)反向索引，如果没找到，返回负数。

例：String s ="howoldareyou";

int i = s.lastIndexOf('o');//i=10

7，指定字符，找这个字符在字符串最后一次出现的下标，lastIndexOf(char ch,int fromIndex),反向索引，指定开始查找的位置。

例：String s ="howoldareyou";

int i = s.lastIndexOf('o',5);//i=3

8，lastIndexOf(String s)

9，lastIndexOf(String s,int formIndex)

10，获取字符串中的字符个数：length()

11，获取(截取)字符串的一部分，substring(int start, intend)返回新的字符串，原始不变,包含头，不包含尾。

例：String s ="abcdefghijk";

s = s.substring(0, 5);//s=”abcdef”

12，获取字符串的一部分，substring(int start)返回新的字符串，从开始下标计算，后面的全要。

例：String s = "haqapafa";

s = s.substring(2);//s=”qapafa”

String类的转换方法

getBytes，toCharArray，toLowerCase，toUpperCase，concat

1，将字符串转成字节数组，返回字节数组getBytes()，查询ASCII表。

例：String s = "abc";

byte[] b = s.getBytes();//b={97,98,99}

2，将字符串转成字符数组，返回字符数组toCharArray()，不查询ASCII表。

例：String s = "to China";

char[] ch = s.toCharArray();//ch={‘t’,’o’,’’,’C’,’h’,’i’,’n’,’a’}

3，将字符串全部转成大写字符，返回新字符串，toUpperCase()。

4，将字符串全部转成小写字符，返回新字符串，toLowerCase()。

例：String upper = "AbcHK";

upper = upper.toUpperCase();//upper=”ABCHK”

String lower = "BG6T汉字HwaK@H";

lower = lower.toLowerCase();//lower=”bg6t汉字hwak@h”

5，字符串的追加方法返回新字符串 concat(String s)

例：String s = "abc";

s = s.concat("fg");//s=”abcfg”

String类的其他方法

contains，valueOf，split，replace，compareTo，trim

1，一个字符串是否包含另一个字符串，contains(String s)，完全包含返回真。

例：String s = "abcdefg";

//传递的是接口CharSequence 的实现类对象 String

boolean b =s.contains("cd");//b=ture

2，将其他数据类型转成字符串 static String valueOf(任意类型)。

例：int x = 10;

String s = String.valueOf(x);//s=”10”

3，切割字符串 String[] split("切割规则")，返回新的字符串数组.如果规则不满足，原始字符串直接装进新的数组的0下标。.在正则中匹配任意字符。

例：String s = "192.168.3.199";

//正则中，\\表示一个\

String[] str =s.split("\\.");//str={“192”,”168”,”3”,”199”}

4，替换字符串，返回新的字符串 String replace(老char,新char)。

5，替换字符串，返回新的字符串 String replace(老串,新串)。

例：String s = "good bye";

s = s.replace('d', 'Q'); //s=”gooQ bye”

String str = "how do you do";

str = str.replace("do","while");//str=”how while you while”

6，安照字典顺序比较两个字符串 int compareTo(String s)，比较有三种结果，我比你小，我和你一样，我比你大。调用者小于参数结果是负数，调用者等于参数，结果是0，调用者大于参数，结果是正数。字典顺序，称为自然顺序。

例：String s1 = "abcd";

String s2 = "bcde";

int num = s1.compareTo(s2);//num=-1,因为a比bASCII码小1

7，去掉字符串的两端空格，返回新字符串，String trim()，不去除字符串中间空格。

例：String s1 = " abc def qq ";

String s2 = s1.trim();//s2=”abc def qq”

StringBuffer类

java.lang.StringBuffer，String类固定不变，很浪费内存，运行速度较慢。

StringBuffer是字符串的缓冲区，底层数据结构可变数组(字符)，StringBuffer自己会做数组的扩容，删除原数组，降低资源的浪费，提升速度，提高效率。

StringBuffer类的构造方法

空参数，默认创建16个位置的数组。

带有String参数的，直接把字符串，装进缓冲区。

StringBuffer类的常见方法

1，将数据追加到缓冲区，append(任意类型)，出来的结果都是字符串，方法的返回值是StringBuffer,返回本类对象。链式编程，对象调用方法，方法的返回值还是一个对象。

例：//空的缓冲区，里面默认16位置字符数组

StringBuffer buffer = new StringBuffer();

//追加数据，用append，方法调用链，链式编程

buffer.append(true).append(false).append('a').append(1.1).append(22);

System.out.println(buffer);//buffer=”truefalsea1.122”

2，删除缓冲区中的字符串，delete(intstart,int end)，包含头，不包含尾。