黑马程序员——java基础——常用类String

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

    (1)概述：多个字符组成的一串数据。

                     可以和字符数组进行相互转换。

    (2)构造方法：

        A:public String()     初始化一个新创建的

String

对象，使其表示一个空字符序列。

        B:public String(byte[] bytes)   通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的

String

        C:public String(byte[] bytes,int offset,int length)    通过使用平台的默认字符集解码指定的 byte 子数组，构造一个新的

String

。

        D:public String(char[] value)   分配一个新的

String

，使其表示字符数组参数中当前包含的字符序列。

        E:public String(char[] value,int offset,int count)   分配一个新的

String

，它包含取自字符数组参数一个子数组的字符。

        F:public String(String original)   初始化一个新创建的

String

对象，使其表示一个与参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的副本

       

        G:String s = "hello";  这一个虽然不是构造方法，但是结果也是一个字符串对象

    (3)字符串的特点

        1:字符串一旦被赋值，就不能改变。

            注意：这里指的是字符串的内容不能改变，而不是引用不能改变。

        2:字面值作为字符串对象和通过构造方法创建对象的不同

            String s = new String("hello"); 和 String s1 = "hello"的区别?

           s在内存中有两个对象，s1在内存中只有一个对象

    (4)字符串的面试题

        1:==和equals()

            String s1 = new String("hello");

            String s2 = new String("hello");

            System.out.println(s1 == s2);               // false

            System.out.println(s1.equals(s2))      ;// true

            String s3 = new String("hello");

            String s4 = "hello";

            System.out.println(s3 == s4)              ;// false

            System.out.println(s3.equals(s4));    // true

            String s5 = "hello";

            String s6 = "hello";

            System.out.println(s5 == s6)            ;// true

            System.out.println(s5.equals(s6))  ;// true

        2:字符串的拼接

            String s1 = "hello";

            String s2 = "world";

            String s3 = "helloworld";

            System.out.println(s3 == s1 + s2);                        // false

            System.out.println(s3.equals((s1 + s2)));           // true

            System.out.println(s3 == "hello" + "world") ;              // true

            System.out.println(s3.equals("hello" + "world"));     // true

    (5)字符串的功能

        1:判断功能

            boolean equals(Object obj)  将此字符串与指定的对象比较。

            boolean equalsIgnoreCase(String str)    将此

String

与另一个

String

比较，不考虑大小写。

            boolean

contains(CharSequence
s

）     当且仅当此字符串包含指定的 char 值序列时，返回 true。

            boolean startsWith(String str)    测试此字符串是否以指定的前缀开始。

            boolean endsWith(String str)    测试此字符串是否以指定的后缀结束。

            boolean isEmpty()    当且仅当

length()

为 0 时返回 true。

  注意：

        字符串内容为空和字符串对象为空。

        String s = "";

        String s = null;

        2:获取功能

            int length()   返回此字符串的长度。

            char charAt(int index)   返回指定索引处的

char

值。

            int indexOf(int ch)     返回指定字符在此字符串中第一次出现处的索引。

            int indexOf(String str)    返回指定子字符串在此字符串中第一次出现处的索引。

            int indexOf(int ch,int fromIndex)   返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。

            int indexOf(String str,int fromIndex)    返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。

            String substring(int start)    返回一个新的字符串，它是此字符串的一个子字符串。

            String substring(int start,int end)     返回一个新字符串，它是此字符串的一个子字符串。

        3:转换功能

            byte[] getBytes()  使用平台的默认字符集将此

String

编码为 byte 序列，并将结果存储到一个新的 byte 数组中。

            char[] toCharArray()   将此字符串转换为一个新的字符数组。

            static String valueOf(char[] chs)    返回

char

数组参数的字符串表示形式。

            static String valueOf(int i)   返回

int

参数的字符串表示形式。

            String toLowerCase()   使用默认语言环境的规则将此

String

中的所有字符都转换为小写。

            String toUpperCase()    使用默认语言环境的规则将此

String

中的所有字符都转换为大写。

            String concat(String str)  将指定字符串连接到此字符串的结尾。

        4:其他功能

            a:替换功能

                String replace(char old,char new)   返回一个新的字符串，它是通过用

newChar

替换此字符串中出现的所有

oldChar

得到的。

                String replace(String old,String new)    使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串。

            b:去空格功能

                String trim()  返回字符串的副本，忽略前导空白和尾部空白。

            c:按字典比较功能

                int compareTo(String str)   按字典顺序比较两个字符串。

                int compareToIgnoreCase(String str)   按字典顺序比较两个字符串，不考虑大小写。

    (6)字符串的案例

        A:模拟用户登录

<span style="font-size:18px;">public class StringTest2 {
public static void main(String[] args) {
// 定义用户名和密码。已存在的。String username = "admin";String password = "admin";

// 给三次机会，用循环改进，最好用for循环。
for (int x = 0; x < 3; x++) {
// x=0,1,2
// 键盘录入用户名和密码。
Scanner sc = new Scanner(System.in);
System.out.println("请输入用户名：");String name = sc.nextLine();
System.out.println("请输入密码：");String pwd = sc.nextLine();

// 比较用户名和密码。
if (name.equals(username) && pwd.equals(password)) {
// 如果都相同，则登录成功
System.out.println("登录成功,开始玩游戏");
//猜数字游戏
GuessNumberGame.start();
break;
} else {
// 如果有一个不同，则登录失败
// 2,1,0
// 如果是第0次，应该换一种提示
if ((2 - x) == 0) {
System.out.println("帐号被锁定，请与班长联系");
} else {
System.out.println("登录失败，你还有" + (2 - x) + "次机会");
}
}
}
}
}</span>

        B:字符串遍历

<span style="font-size:18px;">public class StringTest {
public static void main(String[] args) {
// 定义字符串String s = "helloworld";
for (int x = 0; x < s.length(); x++) {
// char ch = s.charAt(x);
// System.out.println(ch);
System.out.println(s.charAt(x));
}
}
}</span>

        C:统计字符串中大写，小写及数字字符的个数

<span style="font-size:18px;">public class StringTest2 {
public static void main(String[] args) {
//定义一个字符串String s = "Hello123World";

//定义三个统计变量
int bigCount = 0;
int smallCount = 0;
int numberCount = 0;

//遍历字符串，得到每一个字符。
for(int x=0; x<s.length(); x++){
char ch = s.charAt(x);

//判断该字符到底是属于那种类型的
if(ch>='a' && ch<='z'){
smallCount++;
}else if(ch>='A' && ch<='Z'){
bigCount++;
}else if(ch>='0' && ch<='9'){
numberCount++;
}
}

//输出结果。
System.out.println("大写字母"+bigCount+"个");
System.out.println("小写字母"+smallCount+"个");
System.out.println("数字"+numberCount+"个");
}
}</span>

    

    

        D:把字符串的首字母转成大写，其他小写

<span style="font-size:18px;">public class StringTest {
public static void main(String[] args) {
// 定义一个字符串String s = "helloWORLD";

// 先获取第一个字符String s1 = s.substring(0, 1);
// 获取除了第一个字符以外的字符String s2 = s.substring(1);
// 把A转成大写String s3 = s1.toUpperCase();
// 把B转成小写String s4 = s2.toLowerCase();
// C拼接DString s5 = s3.concat(s4);
System.out.println(s5);

// 优化后的代码
// 链式编程String result = s.substring(0, 1).toUpperCase()
.concat(s.substring(1).toLowerCase());
System.out.println(result);
}
}</span>

        E:把int数组拼接成一个指定格式的字符串

<span style="font-size:18px;">public class StringTest {
public static void main(String[] args) {
// 前提是数组已经存在
int[] arr = { 1, 2, 3 };

// 定义一个字符串对象，只不过内容为空String s = "";

// 先把字符串拼接一个"["
s += "[";

// 遍历int数组，得到每一个元素
for (int x = 0; x < arr.length; x++) {
// 先判断该元素是否为最后一个
if (x == arr.length - 1) {
// 就直接拼接元素和"]"
s += arr[x];
s += "]";
} else {
// 就拼接元素和逗号以及空格
s += arr[x];
s += ", ";
}
}

// 输出拼接后的字符串
System.out.println("最终的字符串是：" + s);
}
}</span>

        F:字符串反转

<span style="font-size:18px;">public class StringTest3 {
public static void main(String[] args) {
// 键盘录入一个字符串
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个字符串：");String line = sc.nextLine();

/*
// 定义一个新字符串String result = "";

// 把字符串转成字符数组
char[] chs = line.toCharArray();

// 倒着遍历字符串，得到每一个字符
for (int x = chs.length - 1; x >= 0; x--) {
// 用新字符串把每一个字符拼接起来
result += chs[x];
}

// 输出新串
System.out.println("反转后的结果是：" + result);
*/

// 改进为功能实现String s = myReverse(line);
System.out.println("实现功能后的结果是：" + s);
}

/*
* 两个明确： 返回值类型：String 参数列表：String
*/
public static String myReverse(String s) {
// 定义一个新字符串String result = "";

// 把字符串转成字符数组
char[] chs = s.toCharArray();

// 倒着遍历字符串，得到每一个字符
for (int x = chs.length - 1; x >= 0; x--) {
// 用新字符串把每一个字符拼接起来
result += chs[x];
}
return result;
}
}</span>

        G:统计大串中小串出现的次数

<span style="font-size:18px;">public class StringTest5 {
public static void main(String[] args) {
// 定义大串String maxString = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";
// 定义小串String minString = "java";

// 写功能实现
int count = getCount(maxString, minString);
System.out.println("Java在大串中出现了：" + count + "次");
}

/*
* 两个明确： 返回值类型：int 参数列表：两个字符串
*/
public static int getCount(String maxString, String minString) {
// 定义一个统计变量，初始化值是0
int count = 0;

/*
// 先在大串中查找一次小串第一次出现的位置
int index = maxString.indexOf(minString);
// 索引不是-1，说明存在，统计变量++
while (index != -1) {
count++;
// 把刚才的索引+小串的长度作为开始位置截取上一次的大串，返回一个新的字符串，并把该字符串的值重新赋值给大串
// int startIndex = index + minString.length();
// maxString = maxString.substring(startIndex);
maxString = maxString.substring(index + minString.length());
// 继续查
index = maxString.indexOf(minString);
}
*/

int index;
//先查，赋值，判断
while((index=maxString.indexOf(minString))!=-1){
count++;
maxString = maxString.substring(index + minString.length());
}

return count;
}
}</span>