常见对象·String类

Scanner 的概述和方法介绍

* A：Scanner 的概述

* B：Scanner 的构造方法原理

* Scanner(InputStream source)

* System 类下有一个静态的字段：

* public static final ImputStream in; 标准的输入流，对应着键盘录入。

* C：一般方法：

* hasNextXxx()  判断是否还有下一个输入项，其中Xxx可以是Int，Double等。如果需要判断是否包含下一个字符串，则可以省略Xxx

* nextXxx() 　　获取下一个输入项。Xxx 的含义和上一个方法中的Xxx相同，默认情况下，Scanner使用空格，回车等作为分隔符

packagecom.heima.scanner;importjava.util.Scanner;public classDemo1_Scanner {public static voidmain(String[] args) {

Scanner sc= new Scanner(System.in); //键盘录入//int i = sc.nextInt();//键盘录入整数，存储在 i中//System.out.println(i);

if(sc.hasNextInt()) {int i =sc.nextInt();

System.out.println(i);

}else{

System.out.println("输入的类型错误");

}

}

}

Scanner

Scanner 获取数据出现的小问题及解决方案

* A：两个常用的方法：

* public int nextInt() ：获取一个int类型的值

* public String nextLine() ：获取一个String类型的值

* B：案例演示：

* a：先演示获取多个int值，多个String值的情况

* b：再演示先获取int值，再获取String值出现的问题

* c：问题的解决方案：

* 第一种：先获取一个数值后，再创建一个新的键盘录入对象

* 第二章：把所有的数据都先按照字符串获取，然后要什么，你就对应的转换为什么(后面讲具体的实现方法)

packagecom.heima.scanner;importjava.util.Scanner;public classDemo2_Scanner {public static voidmain(String[] args) {

Scanner sc= newScanner(System.in);/*System.out.println("请输入第一个整数：");

int i = sc.nextInt();

System.out.println("请输入第二个整数");

int j = sc.nextInt();

System.out.println("i = " + i + ", j = " + j);*/

/*System.out.println("请输入第一个字符串");

String line1 = sc.nextLine();

System.out.println("请输入第二个字符串");

String line2 = sc.nextLine();

System.out.println("line1 = " + line1 + ", line2 = " + line2);*/

/** nextInt() 是键盘录入整数的方法，当我们录入10的时候

* 其实在键盘上录入的是 10 和 \r\n

* nextInt() 只获取10就结束了

* nextLine() 是键盘录入字符串的方法，可以接受任意类型

* 遇到\r\n就证明字符串录入结束，并且不存储\r\n*/

/*System.out.println("请输入第一个整数：");

int i = sc.nextInt();

System.out.println("请输入第二个字符串");

String line2 = sc.nextLine();

System.out.println("i = " + i + ", line2 = " + line2);*/

/** 解决方案

* 1,创建两次对象，浪费空间

* 2,键盘录入的都是字符串，都用nextLine方法，后面我们会学习将整数字符串转换成整数的方法*/System.out.println("请输入第一个整数：");int i =sc.nextInt();

Scanner sc2= newScanner(System.in);

System.out.println("请输入第二个字符串");

String line2=sc2.nextLine();

System.out.println("i = " + i + ", line2 = " +line2);

}

}

Scanner

String类的概述

* A：String 类 的概述

* 通过JDK提供的API，查看String类的说明

* 可以看到这样两句话：

* a：字符串字面值 "abc" 可以被看成一个字符串对象

* b：字符串是常量，一旦被赋值，就不能被改变

packagecom.heima.string;public classDemo1_String {public static voidmain(String[] args) {//Person p = new Person();

String str = "abc"; //字符串可以看坐一个字符串对象

System.out.println(str);//String类重写了 toString()方法，使其返回该对象本身

str = "def"; //原来str记录的字符串 "abc" 变成了垃圾

System.out.println(str);

}

}

String

String类的构造方法

* A：常见构造方法

* public String()  ：空参构造

* public String(byte [ ] bytes) ：把字节数组转化为字符串

* public String(byte [ ] bytes, int index, int length) ：把字节数组的一部分转化为字符串

* public String(char [ ] value) ：把字符数组转化为字符串

* public String(char [ ] value, int index, int count) ：把字符数组的一部分转化为字符串

* public String(String original) ：把字符串常量值转化为字符串

* B：案例演示

* 演示String类 的常见构造方法

packagecom.heima.string;public classDemo2_String {public static voidmain(String[] args) {

String s1= new String();//空参构造

System.out.println(s1);byte[] arr1 = { 97, 98, 99};

String s2= new String(arr1);//把字节数组转成字符串

System.out.println(s2); //解码，将计算机读得懂的转换成我们能读得懂的

byte[] arr2 = { 97, 98, 99, 100, 101, 121};

String s3= new String(arr2, 2, 3);//指定起始位置和字符串长度

System.out.println(s3);char[] arr3 = { 'a', 'b', 'c', 'd', 'e'};

String s4= new String(arr3); //将字符数组转换成字符串

System.out.println(s4);

String s5= new String(arr3, 1, 3);//指定起始位置和字符串长度

System.out.println(s5);

String s6= new String("heima");//将字符串转化为字符串

System.out.println(s6);

}

}

String

String类的常见面试题

* 1、判断定义为 String 类型的s1 和 s2 是否相等

String s1 = "abc";

String s2= "abc";

System.out.println(s1==s1);　　// true

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

常量池中没有这个字符串对象就创建一个，如果有，就直接用

Java中重写了equals方法，使其比较的是值而不是地址值

* 2、下面这句话在内存中创建了几个对象？

String s1 = new String("abc");　　// 2

创建了两个对象，一个在常量池中，一个在堆中

* 3、判断定义为String类型的s1 和 s2 是否相等

String s1 = new String("abc");

String s2= "abc";

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

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

* 4、判断定义为String类型的s1 和 s2 是否相等

String s1 = "a" + "b" + "c";

String s2= "abc";

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

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

Java中有常量优化机制，编译时将  "a" + "b" + "c" 识别成了 "abc"

* 5、判断定义为String类型的 s1 和 s2 是否相等

String s1 = "ab";

String s2= "abc";

String s3= s1 + "c";

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

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

底层会先创建一个StringBuilder(或 StringBuffer)，然后将字符串 及其他数据类型 append 到 StringBuilder 中，再变成String对象

String类的判断功能

* A：String类的判断功能

* boolean equals(Object obj) ：比较字符串的内容是否相同，区分大小写

* boolean equalsIgnoreCase(String str) ：比较字符串的内容是否相同，忽略大小写

* boolean contains(String str) ：判断大的字符串中是否包含小的字符串

* boolean startsWith(String str) ：判断字符串是否以某个特定的字符串开头

* boolean endsWith(String str) ：判断字符串是否以某个指定的字符串结尾

* boolean isEmpty() ：判断字符串是否为空

packagecom.heima.string;public classDemo4_StringMethod {public static voidmain(String[] args) {//demo1();//demo2();//demo3();//demo4();

}private static voiddemo4() {

String s1= "heima";

String s2= "";

String s3= null;

System.out.println(s1.isEmpty());

System.out.println(s2.isEmpty());//System.out.println(s3.isEmpty());//java.lang.NullPointerException

/** 判断是否为空,空格不是空，并且字符串不能是null

* ""和null的区别 ：

* ""是字符串常量，同时也是一个String类的对象 ，既然是对象，当然就可以调用String类中的方法

* null是空常量，不能调用任何方法，否则会出现空指针异常，null常量可以给任意的引用数据类型赋值*/}private static voiddemo3() {

String s1= "我爱你haha";

System.out.println(s1.startsWith("我爱你"));//判断是否为指定字符串开头

System.out.println(s1.endsWith("e"));//判断是否为指定字符串结尾

}private static voiddemo2() {

String s1= "我爱你,haha";

String s2= "我爱";

String s3= "hehe";

System.out.println(s1.contains(s2));//判断字符串内是否包含小字符串

System.out.println(s1.contains(s3));

}private static voiddemo1() {

String s1= "heima";

String s2= "heima";

String s3= "HeiMa";

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

System.out.println(s2.equals(s3)); //false 区分大小写

System.out.println("---------------");

System.out.println(s1.equalsIgnoreCase(s2));

System.out.println(s1.equalsIgnoreCase(s3));//忽略大小写

}

}

String

模拟用户登录

* A：案例演示

* 需求：模拟登录，给三次机会，并提示还有几次

* 用户名和密码都是 admin

packagecom.heima.test;importjava.util.Scanner;public classTest1 {/** 分析：

* 1、模拟登录，需要键盘输入

* 2、给三次机会，需要循环，for

* 3、提示有几次机会，需要判断，if*/

public static voidmain(String[] args) {

Scanner sc= new Scanner(System.in); //创建键盘录入对象

for (int i = 0; i < 3; i++) {

System.out.println("请输入用户名：");

String userName= sc.nextLine(); //将键盘录入的用户名存储再userName中

System.out.println("请输入密码：");

String passwd= sc.nextLine(); //将键盘录入的密码存储再passwd中//如果是字符串常量和字符串变量比较，通常都是字符串常量调用方法，防止空指针异常

if ("admin".equals(userName) && "admin".equals(passwd)) {

System.out.println("欢迎" + userName + "登录");break;

}else{

System.out.println("用户名 或者 密码 错误");if (i == 2) {

System.out.println("您的尝试次数已满，请您明天再来");

}else{

System.out.println("输入错误，您还剩下" + (2 - i) + "次机会");

}

}

}

}

}

Test1

String类的获取功能

* A：String类的获取功能

* int length() ：获取字符串到长度

* char charAt(int index) ：获取指定索引位置的字符

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

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

* int indexOf(int ch, int fromIndex) ：返回指定字符串在此字符串中从指定位置后第一次出现处的索引

* lastIndexOf ：从后向前找

* String substring(int start) ：从指定位置开始截取字符串，默认到末尾，会将截取后的字符串返回，原字符串实际不改变

* String substring(int start, int end) ：从指定位置开始到指定位置结束截取字符串

packagecom.heima.string;public classDemo5_StringMethod {public static voidmain(String[] args) {//demo1();//demo2();//demo3();//demo4();

}private static voiddemo4() {

String s1= "heimawudi";

String s2= s1.substring(5);//从指定位置开始，默认到最后，包含指定的那个索引值

System.out.println(s2);

String s3= s1.substring(0, 5);//包含头，不包含尾；左闭右开

System.out.println(s3); //substring会产生一个新的字符串，需要将新的字符产接收

}private static voiddemo3() {

String s1= "woaiheima";int i = s1.indexOf('a', 3);//从第三个开始向后找，包括第三个

System.out.println(i);int d = s1.lastIndexOf('i');//从后向前找，第一次出现的字符，但是索引值不变，找不到返回-1

System.out.println(d);int e = s1.lastIndexOf('a', 7);//从指定位置开始，由后向前寻找

System.out.println(e);

}private static void demo2() { //根据字符找索引

String s1 = "heima";int index1 = s1.indexOf(97);int index2 = s1.indexOf('a');//参数接收int类型的，传入char类型的能自动提升

System.out.println(index1);//如果不存在，返回-1；如果存在，返回该字符第一次出现的位置

System.out.println(index2);int index3 = s1.indexOf("ma");//找字符串,如果匹配返回子串中第一个字符的位置，如果不匹配，返回-1

System.out.println(index3);

}private static void demo1() { //根据索引找字符//int[] arr = { 11, 22, 33 };//System.out.println(arr.length);//数组中的length是属性，没有()

String s1 = "heima";

System.out.println(s1.length());//String中的length是方法,有()

String s2 = "你要减肥,造吗?";

System.out.println(s2.length());char c1 = s2.charAt(5);//根据索引获取相应位置的字符

System.out.println(c1);//

//char c2 = s2.charAt(10);//java.lang.StringIndexOutOfBoundsException//System.out.println(c2);//注意下标越界

}

}

String

字符串的遍历

* A：案例演示

* 需求：遍历字符串

Test2

packagecom.heima.test;public classTest2 {public static voidmain(String[] args) {

String s= "heima";for (int i = 0; i < s.length(); i++) { //通过for循环获取到字符串中每个字符的索引//char c = s.charAt(i);//System.out.println(c);

System.out.println(s.charAt(i)); //通过索引获取每个字符

}

}

}

统计不同类型的字符个数

* A：案例演示

* 需求：统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数，其他字符出现的次数

* 例：ABCDEafcd123456!@#$%^

packagecom.heima.test;public classTest3 {/** 分析：字符串都是由字符组成的，而字符的值都是有范围的，通过范围来判断是否包含该字符 如果包含，就让计数器变量自增*/

public static voidmain(String[] args) {

String s= "ABCDEabcd123456!@#$%^";int big = 0;int small = 0;int num = 0;int other = 0;//1、获取每一个字符，通过for循环

for (int i = 0; i < s.length(); i++) {char c = s.charAt(i); //通过索引获取每一个字符//2、判断字符是否在某个特定范围内

if (c >= 'A' && c <= 'Z') {

big++; //如果满足是大写字母的条件，就让其对应的变量自增

} else if (c >= 'a' && c <= 'z') {

small++;

}else if (c >= '0' && c <= '9') { //注意范围是0字符到9字符，而不是数字0到9

num++;

}else{

other++;

}

}//3、打印每一个计数器的结果

System.out.println(s);

System.out.println("大写字母有 " + big + "个");

System.out.println("小写字母有 " + small + "个");

System.out.println("数字有 " + num + "个");

System.out.println("其他字符有 " + other + "个");

}

}

Test3

String类的转换功能

* A：String的转换功能：

* byte[ ] getBytes() ：把字符串转换为字节数组

* char[ ] toCharArray() ：把字符串转换为字符数组

* static String valueOf(char[ ] chs) ：把字符数组转换成字符串

* static String valueOf(int i) ：把int类型的数据转换成字符串

注意：String类的valueOf() 方法可以把任意类型的数据转换成字符串

* String toLowerCase() ：把字符串转成小写

* String toUpperCase() ：把字符串转成大写

* String concat(String str) ：把字符串拼接

packagecom.heima.string;importcom.heima.bean.Person;public classDemo6_StringMethod {public static voidmain(String[] args) {//demo1();//demo2();//demo3();

demo4();

}private static voiddemo4() {

String s1= "heiMa";

String s2= "chengxvYUAN";

System.out.println(s1.toLowerCase());//全转小写

System.out.println(s2.toUpperCase());//全转大写

System.out.println(s1 + s2); //用加号拼接字符串更强大，可以将字符串与任意类型相加

System.out.println(s1.toLowerCase().concat(s2.toUpperCase()));//concat方法调用的和传入的都必须是字符串

}private static voiddemo3() {char[] arr = { 'a', 'b', 'c'};

String s= String.valueOf(arr);//底层是由String类的构造方法完成的

System.out.println(s);

String s2= String.valueOf(100);//将数字转换为字符串

System.out.println(s2 + 100); //字符串相加，不是数字相加

Person person= new Person("张三", 23);

String s3= String.valueOf(person);//调用的是对象的toString方法

System.out.println(s3);

System.out.println(person);

}private static voiddemo2() {

String s= "heima";char[] arr = s.toCharArray(); //将字符串转换为字符数组

for (int i = 0; i < arr.length; i++) {

System.out.print(arr[i]+ " ");

}

}private static voiddemo1() {

String s1= "abc";byte[] arr = s1.getBytes(); //通过ASCII码表，将字符串转换成字节数组

for (int i = 0; i < arr.length; i++) {

System.out.print(arr[i]+ " ");

}

System.out.println();/** 通过 gbk码表 或者 utf-8 码表 将字符串转换成字节数组 编码：把我们看得懂的转换为计算机看得懂的 gbk码表中，一个中文代表两个字节

* gbk码表特点，中文的第一个字节肯定是负数，第二个字节有可能是正的*/String s2= "你好你好";byte[] arr2 =s2.getBytes();for (int i = 0; i < arr2.length; i++) {

System.out.print(arr2[i]+ " ");

}

System.out.println();

}

}

String

按要求转换字符 (链式编程思想)

* A：案例演示：

* 需求：把一个字符串的首字母转换成大写，其余为小写(只考虑英文大小写字母字符)

packagecom.heima.test;public classTest4 {/** 链式编程：

* 只要保证每次调用完方法返回的是对象，就可以继续调用*/

public static voidmain(String[] args) {

String s= "woaiHEImaNiAIMA";

String s2= s.substring(0,1).toUpperCase().concat(s.substring(1).toLowerCase());

System.out.println(s2);

}

}

Test4

把数组转换成字符串

* A：案例演示

* 需求：把数组中的数据按照指定的格式拼接成一个字符串

* 举例：

* int[ ] arr = { 1, 2, 3};

* 输出结果：

* "[1, 2, 3]"

packagecom.heima.test;public classTest5 {/** 分析：

* 1、需要定义一个字符串 "["

* 2、遍历数组获取每一个元素

* 3、用字符串与数组中的元素进行拼接*/

public static voidmain(String[] args) {int[] arr = { 1, 2, 3};

String s= "["; //定义一个字符串用来与数组中的元素拼接

for (int i = 0; i < arr.length; i++) {//{1, 2, 3}

if (i == arr.length - 1) {

s= s + arr[i] + "]"; //[1, 2, 3]

} else{

s= s + arr[i] + ", "; //[1, 2,

}

}

System.out.println(s);

}

}

Test5

String类的其他功能

* A：替换功能

* String replace(char old, char new)

* String reolace(String old, String new)

* B：去除字符串两边空格

* String trim()

* C：按字典顺序比较两个字符串

* int compareTo(String str) (讲集合TreeSet时细讲)

* int compareToIgnoreCase(String str)

packagecom.heima.string;public classDemo7_StringMethod {public static voidmain(String[] args) {//demo1();//demo2();

demo3();

}private static voiddemo3() {

String s1= "abc";

String s2= "bcd";int num = s1.compareTo(s2); //按照unicode码表,从左开始逐个比较

System.out.println(num);

String s3= "黑";

String s4= "黑马";

System.out.println(s3.compareTo(s4));

String s5= "heima";

String s6= "HEIMA";

System.out.println(s5.compareToIgnoreCase(s6));//不区分大小写

}private static voiddemo2() {

String s= " hei ma ";

System.out.println(s.trim());//除去两端的空格

System.out.println(s);

}private static voiddemo1() {

String s= "heimaheima";

String s2= s.replace('a', 'o'); //字符替换，如果不存在指定字符，就保留原字符

System.out.println(s2);

String s3= s.replace("ei", "ao"); //字符串替换

System.out.println(s3);

}

}

String

字符串反转

* A：案例演示：

* 需求：把字符串反转

* 举例：键盘录入"abc"

* 输出结果："cba"

packagecom.heima.test;importjava.util.Scanner;public classTest6 {/** 分析：

* 1、通过键盘录入获取字符串Scanner

* 2、将字符串转换成字符数组

* 3、倒着遍历字符数组，并再次拼接成字符串

* 4、打印*/

public static voidmain(String[] args) {

Scanner sc= new Scanner(System.in); //创建键盘录入对象

System.out.println("请输入一个字符串");

String str= sc.nextLine(); //将键盘录入的字符串存储在line中

String s = "";char[] arr = str.toCharArray(); //将字符串转换为字符数组

for (int i = arr.length - 1; i >= 0; i--) {

s+= arr[i]; //拼接成字符串，实际上，每次都在生成新的字符串，产生大量垃圾

}

System.out.println(s);

}

}

Test6

在大串中查找小串出现的次数

* A：画图演示

* 需求：统计大串中小串出现的次数

* 这里的大串和小串可以自己给出

* B：案例演示

* 统计大串中小串出现的次数

packagecom.heima.test;public classTest7 {public static voidmain(String[] args) {

String max= "woaiheima,heimabaima,zhaodaogongzuojiushihaoma"; //定义大串

String min = "heima"; //定义小串

int index = 0; //定义索引

int count = 0; //定义计数器变量

while ((index = max.indexOf(min)) != -1) { //定义循环，判断小串是否在大串中出现

count++;

max= max.substring(index +min.length());

}

System.out.println(count);

}

}

Test7