常见对象·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使用空格，回车等作为分隔符

  1. package com.heima.scanner;
  2.  
  3. import java.util.Scanner;
  4.  
  5. public class Demo1_Scanner {
  6.  
  7.     public static void main(String[] args) {
  8.         Scanner sc = new Scanner(System.in); // 键盘录入
  9.         // int i = sc.nextInt(); // 键盘录入整数，存储在 i中
  10.         // System.out.println(i);
  11.         if (sc.hasNextInt()) {
  12.             int i = sc.nextInt();
  13.             System.out.println(i);
  14.         } else {
  15.             System.out.println("输入的类型错误");
  16.         }
  17.  
  18.     }
  19. }

Scanner

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

* A：两个常用的方法：
　　* public int nextInt() ：获取一个int类型的值
　　* public String nextLine() ：获取一个String类型的值

* B：案例演示：
　　* a：先演示获取多个int值，多个String值的情况
　　* b：再演示先获取int值，再获取String值出现的问题
　　* c：问题的解决方案：
　　　　* 第一种：先获取一个数值后，再创建一个新的键盘录入对象
　　　　* 第二章：把所有的数据都先按照字符串获取，然后要什么，你就对应的转换为什么（后面讲具体的实现方法）

  1. package com.heima.scanner;
  2.  
  3. import java.util.Scanner;
  4.  
  5. public class Demo2_Scanner {
  6.  
  7.     public static void main(String[] args) {
  8.         Scanner sc = new Scanner(System.in);
  9.         /*System.out.println("请输入第一个整数：");
  10.         int i = sc.nextInt();
  11.         System.out.println("请输入第二个整数");
  12.         int j = sc.nextInt();
  13.         System.out.println("i = " + i + ", j = " + j);*/
  14.  
  15.         /*System.out.println("请输入第一个字符串");
  16.         String line1 = sc.nextLine();
  17.         System.out.println("请输入第二个字符串");
  18.         String line2 = sc.nextLine();
  19.         System.out.println("line1 = " + line1 + ", line2 = " + line2);*/
  20.  
  21.         /*
  22.          * nextInt() 是键盘录入整数的方法，当我们录入10的时候
  23.          * 其实在键盘上录入的是 10 和 \r\n
  24.          * nextInt() 只获取10就结束了
  25.          * nextLine() 是键盘录入字符串的方法，可以接受任意类型
  26.          * 遇到\r\n就证明字符串录入结束，并且不存储\r\n
  27.          */
  28.  
  29.         /*System.out.println("请输入第一个整数：");
  30.         int i = sc.nextInt();
  31.         System.out.println("请输入第二个字符串");
  32.         String line2 = sc.nextLine();
  33.         System.out.println("i = " + i + ", line2 = " + line2);*/
  34.  
  35.         /*
  36.          * 解决方案
  37.          * 1,创建两次对象，浪费空间
  38.          * 2,键盘录入的都是字符串，都用nextLine方法，后面我们会学习将整数字符串转换成整数的方法
  39.          */
  40.         System.out.println("请输入第一个整数：");
  41.         int i = sc.nextInt();
  42.         Scanner sc2 = new Scanner(System.in);
  43.         System.out.println("请输入第二个字符串");
  44.         String line2 = sc2.nextLine();
  45.         System.out.println("i = " + i + ", line2 = " + line2);
  46.     }
  47.  
  48. }

Scanner

String类的概述

* A：String 类 的概述
　　* 通过JDK提供的API，查看String类的说明
　　* 可以看到这样两句话：
　　　　* a：字符串字面值 "abc" 可以被看成一个字符串对象
　　　　* b：字符串是常量，一旦被赋值，就不能被改变

  1. package com.heima.string;
  2.  
  3. public class Demo1_String {
  4.  
  5.     public static void main(String[] args) {
  6.         //Person p = new Person();
  7.         String str = "abc";  //字符串可以看坐一个字符串对象
  8.         System.out.println(str);//String类重写了 toString()方法，使其返回该对象本身
  9.         str = "def";    // 原来str记录的字符串 "abc" 变成了垃圾
  10.         System.out.println(str);
  11.     }
  12.  
  13. }

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类 的常见构造方法

  1. package com.heima.string;
  2.  
  3. public class Demo2_String {
  4.  
  5.     public static void main(String[] args) {
  6.         String s1 = new String();// 空参构造
  7.         System.out.println(s1);
  8.  
  9.         byte[] arr1 = { 97, 98, 99 };
  10.         String s2 = new String(arr1);// 把字节数组转成字符串
  11.         System.out.println(s2); // 解码，将计算机读得懂的转换成我们能读得懂的
  12.  
  13.         byte[] arr2 = { 97, 98, 99, 100, 101, 121 };
  14.         String s3 = new String(arr2, 2, 3);// 指定起始位置和字符串长度
  15.         System.out.println(s3);
  16.  
  17.         char[] arr3 = { 'a', 'b', 'c', 'd', 'e' };
  18.         String s4 = new String(arr3); // 将字符数组转换成字符串
  19.         System.out.println(s4);
  20.  
  21.         String s5 = new String(arr3, 1, 3);// 指定起始位置和字符串长度
  22.         System.out.println(s5);
  23.  
  24.         String s6 = new String("heima");// 将字符串转化为字符串
  25.         System.out.println(s6);
  26.     }
  27.  
  28. }

String

String类的常见面试题

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

  1. String s1 = "abc";
  2. String s2 = "abc";
  3.  
  4. System.out.println(s1 == s1);　　// true
  5. System.out.println(s1.equals(s2));　　// true

常量池中没有这个字符串对象就创建一个，如果有，就直接用
 Java中重写了equals方法，使其比较的是值而不是地址值

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

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

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

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

  1. String s1 = new String("abc");
  2. String s2 = "abc";
  3. System.out.println(s1 == s2);　　// false
  4. System.out.println(s1.equals(s2));　　// true

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

  1. String s1 = "a" + "b" + "c";
  2. String s2 = "abc";
  3. System.out.println(s1 == s2);　　// true
  4. System.out.println(s1.equals(s2));　　// true

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

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

  1. String s1 = "ab";
  2. String s2 = "abc";
  3. String s3 = s1 + "c";
  4. System.out.println(s3 == s2);　　// false
  5. 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() ：判断字符串是否为空

  1. package com.heima.string;
  2.  
  3. public class Demo4_StringMethod {
  4.  
  5.     public static void main(String[] args) {
  6.         // demo1();
  7.         // demo2();
  8.         // demo3();
  9.         //demo4();
  10.     }
  11.  
  12.     private static void demo4() {
  13.         String s1 = "heima";
  14.         String s2 = "";
  15.         String s3 = null;
  16.  
  17.         System.out.println(s1.isEmpty());
  18.         System.out.println(s2.isEmpty());
  19.         //System.out.println(s3.isEmpty());    // java.lang.NullPointerException
  20.  
  21.         /*
  22.          * 判断是否为空,空格不是空，并且字符串不能是null
  23.          * ""和null的区别 ：
  24.          *       ""是字符串常量，同时也是一个String类的对象 ，既然是对象，当然就可以调用String类中的方法
  25.          *       null是空常量，不能调用任何方法，否则会出现空指针异常，null常量可以给任意的引用数据类型赋值
  26.          */
  27.     }
  28.  
  29.     private static void demo3() {
  30.         String s1 = "我爱你haha";
  31.         System.out.println(s1.startsWith("我爱你"));// 判断是否为指定字符串开头
  32.         System.out.println(s1.endsWith("e"));// 判断是否为指定字符串结尾
  33.     }
  34.  
  35.     private static void demo2() {
  36.         String s1 = "我爱你,haha";
  37.         String s2 = "我爱";
  38.         String s3 = "hehe";
  39.  
  40.         System.out.println(s1.contains(s2));// 判断字符串内是否包含小字符串
  41.         System.out.println(s1.contains(s3));
  42.     }
  43.  
  44.     private static void demo1() {
  45.         String s1 = "heima";
  46.         String s2 = "heima";
  47.         String s3 = "HeiMa";
  48.  
  49.         System.out.println(s1.equals(s2)); // true
  50.         System.out.println(s2.equals(s3)); // false 区分大小写
  51.         System.out.println("---------------");
  52.         System.out.println(s1.equalsIgnoreCase(s2));
  53.         System.out.println(s1.equalsIgnoreCase(s3)); // 忽略大小写
  54.     }
  55.  
  56. }

String

模拟用户登录

* A：案例演示
　　* 需求：模拟登录，给三次机会，并提示还有几次
　　* 用户名和密码都是 admin

  1. package com.heima.test;
  2.  
  3. import java.util.Scanner;
  4.  
  5. public class Test1 {
  6.     /*
  7.      * 分析：
  8.      * 1、模拟登录，需要键盘输入
  9.      * 2、给三次机会，需要循环，for
  10.      * 3、提示有几次机会，需要判断，if
  11.      */
  12.     public static void main(String[] args) {
  13.         Scanner sc = new Scanner(System.in);    // 创建键盘录入对象
  14.         for (int i = 0; i < 3; i++) {
  15.             System.out.println("请输入用户名：");
  16.             String userName = sc.nextLine();    // 将键盘录入的用户名存储再userName中
  17.             System.out.println("请输入密码：");
  18.             String passwd = sc.nextLine();    // 将键盘录入的密码存储再passwd中
  19.             // 如果是字符串常量和字符串变量比较，通常都是字符串常量调用方法，防止空指针异常
  20.             if ("admin".equals(userName) && "admin".equals(passwd)) {
  21.                 System.out.println("欢迎" + userName + "登录");
  22.                 break;
  23.             } else {
  24.                 System.out.println("用户名 或者 密码 错误");
  25.                 if (i == 2) {
  26.                     System.out.println("您的尝试次数已满，请您明天再来");
  27.                 } else {
  28.                     System.out.println("输入错误，您还剩下" + (2 - i) + "次机会");
  29.                 }
  30.  
  31.             }
  32.         }
  33.     }
  34.  
  35. }

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) ：从指定位置开始到指定位置结束截取字符串

  1. package com.heima.string;
  2.  
  3. public class Demo5_StringMethod {
  4.  
  5.     public static void main(String[] args) {
  6.         // demo1();
  7.         // demo2();
  8.         // demo3();
  9.         // demo4();
  10.     }
  11.  
  12.     private static void demo4() {
  13.         String s1 = "heimawudi";
  14.         String s2 = s1.substring(5);// 从指定位置开始，默认到最后，包含指定的那个索引值
  15.         System.out.println(s2);
  16.         String s3 = s1.substring(0, 5);// 包含头，不包含尾；左闭右开
  17.         System.out.println(s3);    // substring会产生一个新的字符串，需要将新的字符产接收
  18.     }
  19.  
  20.     private static void demo3() {
  21.         String s1 = "woaiheima";
  22.         int i = s1.indexOf('a', 3);// 从第三个开始向后找，包括第三个
  23.         System.out.println(i);
  24.  
  25.         int d = s1.lastIndexOf('i');// 从后向前找，第一次出现的字符，但是索引值不变，找不到返回-1
  26.         System.out.println(d);
  27.  
  28.         int e = s1.lastIndexOf('a', 7);// 从指定位置开始，由后向前寻找
  29.         System.out.println(e);
  30.     }
  31.  
  32.     private static void demo2() { // 根据字符找索引
  33.         String s1 = "heima";
  34.         int index1 = s1.indexOf(97);
  35.         int index2 = s1.indexOf('a');// 参数接收int类型的，传入char类型的能自动提升
  36.         System.out.println(index1);// 如果不存在，返回-1；如果存在，返回该字符第一次出现的位置
  37.         System.out.println(index2);
  38.         int index3 = s1.indexOf("ma");// 找字符串,如果匹配返回子串中第一个字符的位置，如果不匹配，返回-1
  39.         System.out.println(index3);
  40.     }
  41.  
  42.     private static void demo1() { // 根据索引找字符
  43.         // int[] arr = { 11, 22, 33 };
  44.         // System.out.println(arr.length); // 数组中的length是属性，没有()
  45.         String s1 = "heima";
  46.         System.out.println(s1.length()); // String中的length是方法,有()
  47.         String s2 = "你要减肥,造吗?";
  48.         System.out.println(s2.length());
  49.  
  50.         char c1 = s2.charAt(5);// 根据索引获取相应位置的字符
  51.         System.out.println(c1);//
  52.         // char c2 = s2.charAt(10); // java.lang.StringIndexOutOfBoundsException
  53.         // System.out.println(c2); // 注意下标越界
  54.     }
  55.  
  56. }

String

字符串的遍历

* A：案例演示
　　* 需求：遍历字符串

Test2

  1. package com.heima.test;
  2.  
  3. public class Test2 {
  4.     public static void main(String[] args) {
  5.         String s = "heima";
  6.         for (int i = 0; i < s.length(); i++) { // 通过for循环获取到字符串中每个字符的索引
  7.             // char c = s.charAt(i);
  8.             // System.out.println(c);
  9.             System.out.println(s.charAt(i)); // 通过索引获取每个字符
  10.         }
  11.     }
  12. }

统计不同类型的字符个数

* A：案例演示
　　* 需求：统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数，其他字符出现的次数
　　* 例：ABCDEafcd123456!@#$%^

  1. package com.heima.test;
  2.  
  3. public class Test3 {
  4.     /*
  5.      * 分析：字符串都是由字符组成的，而字符的值都是有范围的，通过范围来判断是否包含该字符 如果包含，就让计数器变量自增
  6.      */
  7.     public static void main(String[] args) {
  8.         String s = "ABCDEabcd123456!@#$%^";
  9.         int big = 0;
  10.         int small = 0;
  11.         int num = 0;
  12.         int other = 0;
  13.         // 1、获取每一个字符，通过for循环
  14.         for (int i = 0; i < s.length(); i++) {
  15.             char c = s.charAt(i); // 通过索引获取每一个字符
  16.             // 2、判断字符是否在某个特定范围内
  17.             if (c >= 'A' && c <= 'Z') {
  18.                 big++; // 如果满足是大写字母的条件，就让其对应的变量自增
  19.             } else if (c >= 'a' && c <= 'z') {
  20.                 small++;
  21.             } else if (c >= '0' && c <= '9') { // 注意范围是0字符到9字符，而不是数字0到9
  22.                 num++;
  23.             } else {
  24.                 other++;
  25.             }
  26.         }
  27.         // 3、打印每一个计数器的结果
  28.         System.out.println(s);
  29.         System.out.println("大写字母有 " + big + "个");
  30.         System.out.println("小写字母有 " + small + "个");
  31.         System.out.println("数字有 " + num + "个");
  32.         System.out.println("其他字符有 " + other + "个");
  33.     }
  34.  
  35. }

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) ：把字符串拼接

  1. package com.heima.string;
  2.  
  3. import com.heima.bean.Person;
  4.  
  5. public class Demo6_StringMethod {
  6.  
  7.     public static void main(String[] args) {
  8.         // demo1();
  9.         // demo2();
  10.         // demo3();
  11.         demo4();
  12.  
  13.     }
  14.  
  15.     private static void demo4() {
  16.         String s1 = "heiMa";
  17.         String s2 = "chengxvYUAN";
  18.         System.out.println(s1.toLowerCase());// 全转小写
  19.         System.out.println(s2.toUpperCase());// 全转大写
  20.         System.out.println(s1 + s2);    // 用加号拼接字符串更强大，可以将字符串与任意类型相加
  21.         System.out.println(s1.toLowerCase().concat(s2.toUpperCase()));// concat方法调用的和传入的都必须是字符串
  22.     }
  23.  
  24.     private static void demo3() {
  25.         char[] arr = { 'a', 'b', 'c' };
  26.         String s = String.valueOf(arr);// 底层是由String类的构造方法完成的
  27.         System.out.println(s);
  28.  
  29.         String s2 = String.valueOf(100);// 将数字转换为字符串
  30.         System.out.println(s2 + 100); // 字符串相加，不是数字相加
  31.  
  32.         Person person = new Person("张三", 23);
  33.         String s3 = String.valueOf(person);// 调用的是对象的toString方法
  34.         System.out.println(s3);
  35.         System.out.println(person);
  36.     }
  37.  
  38.     private static void demo2() {
  39.         String s = "heima";
  40.         char[] arr = s.toCharArray(); // 将字符串转换为字符数组
  41.         for (int i = 0; i < arr.length; i++) {
  42.             System.out.print(arr[i] + "    ");
  43.         }
  44.     }
  45.  
  46.     private static void demo1() {
  47.         String s1 = "abc";
  48.         byte[] arr = s1.getBytes(); // 通过ASCII码表，将字符串转换成字节数组
  49.         for (int i = 0; i < arr.length; i++) {
  50.             System.out.print(arr[i] + "    ");
  51.         }
  52.  
  53.         System.out.println();
  54.         /*
  55.          * 通过 gbk码表 或者 utf-8 码表 将字符串转换成字节数组 编码：把我们看得懂的转换为计算机看得懂的 gbk码表中，一个中文代表两个字节
  56.          * gbk码表特点，中文的第一个字节肯定是负数，第二个字节有可能是正的
  57.          */
  58.         String s2 = "你好你好";
  59.         byte[] arr2 = s2.getBytes();
  60.         for (int i = 0; i < arr2.length; i++) {
  61.             System.out.print(arr2[i] + "    ");
  62.         }
  63.         System.out.println();
  64.     }
  65.  
  66. }

String

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

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

  1. package com.heima.test;
  2.  
  3. public class Test4 {
  4.     /*
  5.      * 链式编程：
  6.      * 只要保证每次调用完方法返回的是对象，就可以继续调用
  7.      */
  8.     public static void main(String[] args) {
  9.         String s = "woaiHEImaNiAIMA";
  10.         String s2 = s.substring(0,1).toUpperCase().concat(s.substring(1).toLowerCase());
  11.         System.out.println(s2);
  12.     }
  13. }

Test4

把数组转换成字符串

* A：案例演示
　　* 需求：把数组中的数据按照指定的格式拼接成一个字符串
　　　　* 举例：
　　　　　　* int[ ] arr = { 1, 2, 3};
　　　　* 输出结果：
　　　　　　* "[1, 2, 3]"

  1. package com.heima.test;
  2.  
  3. public class Test5 {
  4.     /*
  5.      * 分析：
  6.      * 1、需要定义一个字符串 "["
  7.      * 2、遍历数组获取每一个元素
  8.      * 3、用字符串与数组中的元素进行拼接
  9.      */
  10.     public static void main(String[] args) {
  11.         int[] arr = { 1, 2, 3 };
  12.         String s = "[";    // 定义一个字符串用来与数组中的元素拼接
  13.  
  14.         for (int i = 0; i < arr.length; i++) {// {1, 2, 3}
  15.             if (i == arr.length - 1) {
  16.                 s = s + arr[i] + "]";    // [1, 2, 3]
  17.             } else {
  18.                 s = s + arr[i] + ", ";    // [1, 2,
  19.             }
  20.         }
  21.         System.out.println(s);
  22.     }
  23. }

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)

  1. package com.heima.string;
  2.  
  3. public class Demo7_StringMethod {
  4.  
  5.     public static void main(String[] args) {
  6.         // demo1();
  7.         // demo2();
  8.         demo3();
  9.     }
  10.  
  11.     private static void demo3() {
  12.         String s1 = "abc";
  13.         String s2 = "bcd";
  14.  
  15.         int num = s1.compareTo(s2); // 按照unicode码表,从左开始逐个比较
  16.         System.out.println(num);
  17.  
  18.         String s3 = "黑";
  19.         String s4 = "黑马";
  20.         System.out.println(s3.compareTo(s4));
  21.  
  22.         String s5 = "heima";
  23.         String s6 = "HEIMA";
  24.         System.out.println(s5.compareToIgnoreCase(s6)); // 不区分大小写
  25.     }
  26.  
  27.     private static void demo2() {
  28.         String s = "   hei   ma   ";
  29.         System.out.println(s.trim());// 除去两端的空格
  30.         System.out.println(s);
  31.     }
  32.  
  33.     private static void demo1() {
  34.         String s = "heimaheima";
  35.         String s2 = s.replace('a', 'o'); // 字符替换，如果不存在指定字符，就保留原字符
  36.         System.out.println(s2);
  37.         String s3 = s.replace("ei", "ao"); // 字符串替换
  38.         System.out.println(s3);
  39.     }
  40. }

String

字符串反转

* A：案例演示：
　　* 需求：把字符串反转
　　　　* 举例：键盘录入"abc"
　　　　* 输出结果："cba"

  1. package com.heima.test;
  2.  
  3. import java.util.Scanner;
  4.  
  5. public class Test6 {
  6.     /*
  7.      * 分析：
  8.      * 1、通过键盘录入获取字符串Scanner
  9.      * 2、将字符串转换成字符数组
  10.      * 3、倒着遍历字符数组，并再次拼接成字符串
  11.      * 4、打印
  12.      */
  13.     public static void main(String[] args) {
  14.         Scanner sc = new Scanner(System.in);    // 创建键盘录入对象
  15.         System.out.println("请输入一个字符串");
  16.         String str = sc.nextLine();    // 将键盘录入的字符串存储在line中
  17.         String s = "";
  18.  
  19.         char[] arr = str.toCharArray();    // 将字符串转换为字符数组
  20.         for (int i = arr.length - 1; i >= 0; i--) {
  21.             s += arr[i];    // 拼接成字符串，实际上，每次都在生成新的字符串，产生大量垃圾
  22.         }
  23.         System.out.println(s);
  24.  
  25.     }
  26.  
  27. }

Test6

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

* A：画图演示
　　* 需求：统计大串中小串出现的次数
　　* 这里的大串和小串可以自己给出

* B：案例演示
　　* 统计大串中小串出现的次数

  1. package com.heima.test;
  2.  
  3. public class Test7 {
  4.  
  5.     public static void main(String[] args) {
  6.         String max = "woaiheima,heimabaima,zhaodaogongzuojiushihaoma"; // 定义大串
  7.         String min = "heima"; // 定义小串
  8.         int index = 0; // 定义索引
  9.         int count = 0; // 定义计数器变量
  10.         while ((index = max.indexOf(min)) != -1) { // 定义循环，判断小串是否在大串中出现
  11.             count++;
  12.             max = max.substring(index + min.length());
  13.         }
  14.         System.out.println(count);
  15.     }
  16.  
  17. }

Test7

Java 常见对象 02的更多相关文章

  1. Java常见对象Object类中的个别方法

    Java常见对象Object类 public int hashCode() : 返回该对象的哈希码值. 注意:哈希值是根据哈希算法计算出来的一个值,这个值和地址值有关,但是不是实际地址值.你可以理解成 ...

  2. Java 常见对象 05

    常见对象·正则表达式 和 其他类 正则表达式的概述和简单使用 * A:正则表达式 * 是指一个用来描述或者匹配一系列符合某个语法规则的字符串的单个字符串.其实就是一种规则,有自己的特殊应用 * 作用: ...

  3. Java 常见对象 03

    常见对象·StringBuffer类 StringBuffer类概述 * A:StringBuffer类概述 * 通过 JDk 提供的API,查看StringBuffer类的说明 * 线程安全的可变字 ...

  4. Java 常见对象 04

    常见对象·Arrays 类和 包装类 数组高级冒泡排序原理图解 * A:画图演示 * 需求: 数组元素:{24, 69, 80, 57, 13} 请对数组元素进行排序 * 冒泡排序: 相邻元素两两比较 ...

  5. 阶段01Java基础day13常见对象02

    13.01_常见对象(StringBuffer类的概述) A:StringBuffer类概述 通过JDK提供的API,查看StringBuffer类的说明 线程安全的可变字符序列 B:简述安全问题 线 ...

  6. Java 常见对象 01

    常见对象·Object类 Object类的概述 * A:Object 类概述 * 类层次结构的根类 * 所有类都直接或间接地继承自该类 * B:构造方法 * public Object() * 回想为 ...

  7. Java常见对象之String

    String类的概述 String 类代表字符串.Java 程序中的所有字符串字面值(如 "abc" )都作为此类的实例实现.字符串是常量,一旦被赋值,就不能被改变. String ...

  8. Java常见对象内存分析

    首先要明确Java内存的个位置上放的是啥 类.对象.实例三者的关系: 1.类:是对象的模板,可以实例化对象.(this不能出现在静态方法中) 2.对象:类的个体. 3.实例:实现的对象. 4.对应的引 ...

  9. day11<Java开发工具&常见对象>

    Java开发工具(常见开发工具介绍) Java开发工具(Eclipse中HelloWorld案例以及汉化) Java开发工具(Eclipse的视窗和视图概述) Java开发工具(Eclipse工作空间 ...

随机推荐

  1. 使用docker时报错“net/http: TLS handshake timeout”

    问题原因 :该命令默认从docker远端镜像仓库中拉取镜像,但由于远端仓库的服务器是在国外,我们国内有的用户很可能都访问不到 解决:使用国内镜像仓库 docker pull registry.dock ...

  2. k8s-1-交付dubbo微服务

    一.Dubbo微服务概述 1.1: dubbo介绍 1.2: 部署内容 二.实验环境架构 2.1: 架构 1.1 架构图解 1.最上面一排为K8S集群外服务 1.1 代码仓库使用基于git的gitee ...

  3. 命令提示符CMD下切换用户

    工作中遇到需要在windows环境中命令提示符下切换为Guest用户执行程序,类似Linux中的su操作. 操作步骤如下:1.用管理员权限运行cmd.2:执行命令:runas /user:userna ...

  4. 网络协议 & 协议体系结构模型

    基本知识概述 网络协议是什么? 为进行网络中的数据交换,而建立的规则(约定),就称为网络协议 网络协议的三个组成要素? 语法:数据与控制信息的结构或格式 语义:发出何种控制信息,完成何种动作,作出何种 ...

  5. 国内centos/windows10安装minikube

    centos/windows10安装minikube 目录 centos/windows10安装minikube A win10安装minikube 1 下载安装kubectl.exe 1.1 准备目 ...

  6. Leetcode（94）-二叉树的中序遍历

    给定一个二叉树,返回它的中序 遍历. 示例: 输入: [1,null,2,3] 1 \ 2 / 3 输出: [1,3,2] 思路:和上篇的前序遍历一样,同样有递归和非递归的做法 (1)递归 vecto ...

  7. POJ3233 构造子矩阵+矩阵快速幂

    题意:给你矩阵A,求S=A+A^1+A^2+...+A^n sol:直接把每一项解出来显然是不行的,也没必要. 我们可以YY一个矩阵: 其中1表示单位矩阵 然后容易得到: 可以看出这个分块矩阵的左下角 ...

  8. SPN在域环境中的应用

    0X01 SPN    服务主体名称(SPN)是Kerberos客户端用于唯一标识给特定Kerberos目标计算机的服务实例名称.Kerberos身份验证使用SPN将服务实例与服务登录帐户相关联.如果 ...

  9. ARMv7-A 架构下的MMU

    ARM架构中MMU的作用主要就是将CPU发出的虚拟地址转换成为物理地址,从实现内核和用户程序和用户程序之间的虚拟地址空间隔离.MMU的主要组成为两部分,其一是内部的TLBs缓存:还有就是转换表装换单元 ...

  10. Ubuntu pppoeconf失败

    之前是通过sudo pppoeconf一路yes就可以连通有线网络(dsl和ethernet)的, 系统再次瘫痪后终于进入图形界面, 有线网络丢失, sudo pppoeconf也fail了, 其实加 ...