java String

###11.01_常见对象(String类的概述)(掌握)
 

* A:String类的概述

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

     *"abc"是String类的一个实例,或者成为String类的一个对象

     * 可以看到这样的两句话。

         * a:字符串字面值"abc"也可以看成是一个字符串对象。

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

案例:

public class Demo1_String {

     /**

      * @param args

      */

     public static void main(String[] args) {

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

         str = "def";//当把"def"赋值给str,原来的"abc"就变成了垃圾

         System.out.println(str);//打印的结果不是"类名@字符串地址",而是"abc",说明String重写了toString()方法

     }

}

 

 

###11.02_常见对象(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类的常见构造方法

案例:

public class Demo2_StringCon {   

     public static void main(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,102};

         String s3 = new String(arr2,2,3);         //将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);         //将arr3字符数组,从1索引开始转换3个

         System.out.println(s5);

         

         String s6 = new String("aaaa");

         System.out.println(s6);

     }

}

 

 

###11.03_常见对象(String类的常见面试题)(掌握)

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

     * String s1 = "abc";

     * String s2 = "abc";

     * System.out.println(s1 == s2);                       

     * System.out.println(s1.equals(s2));       

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

     * String s1 = new String("abc");            

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

     * String s1 = new String("abc");            

     * String s2 = "abc";

     * System.out.println(s1 == s2);    

     * System.out.println(s1.equals(s2));

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

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

     * String s2 = "abc";

     * System.out.println(s1 == s2);    

     * System.out.println(s1.equals(s2));

* 5.判断定义为String类型的s1和s2是否相等 重点记忆

     * String s1 = "ab";

     * String s2 = "abc";

     * String s3 = s1 + "c";

     * System.out.println(s3 == s2);

     * System.out.println(s3.equals(s2));

案例:

public class Demo3_String { 

     public static void main(String[] args) {

         //demo1();

         //demo2();

         //demo3();

         //demo4();

         demo5();

     }

 

     private static void demo5() {

         String s1 = "ab";

         String s2 = "abc";

         String s3 = s1 + "c";

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

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

     }

 

     private static void demo4() {

         //byte b = 3 + 4;                         //在编译时就变成7,把7赋值给b,常量优化机制

         String s1 = "a" + "b" + "c";//java中有常量优化机制,在编译时期就能确定s2的值为"abc",所以编译时期,在常量池中创建"abc"

         String s2 = "abc";//执行到这里时常量池中已经有了"abc",所以就不再创建,所以s1和s2指向的是常量池中同一个字符串常量"abc"

         System.out.println(s1 == s2);              //true,java中有常量优化机制 

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

     }

 

     private static void demo3() {//==比较的是地址值

         String s1 = new String("abc");            //录的是堆内存对象的地址值     

         String s2 = "abc";                        //记录的是常量池中的地址值

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

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

     }

 

     private static void demo2() {

         //创建几个对象

         //创建两个对象,一个在常量池中,一个在堆内存中

         String s1 = new String("abc");       

         System.out.println(s1);

     }

 

     private static void demo1() {                  //常量池中没有这个字符串对象,就创建一个,如果有直接用即可

         String s1 = "abc";

         String s2 = "abc";

         System.out.println(s1 == s2);              //==号比较的是地址值,true   

         System.out.println(s1.equals(s2));        //比较的是字符串的内容:true

     }

 

}

 

图解1(针对demo1方法):

图解2(针对demo2()):

图解3(针对demo5方法):

 

案例:

import org.junit.Test;

 

public class StringTest1 {

     public static void main(String[] args) {

         String str1 = "AA";

         String str2 = "AA";

         System.out.println(str1==str2);

         Person p1 =  new Person("AA",12);

         Person p2 =  new Person("AA",21);

         System.out.println(p1.name==p2.name);

     }

}

class Person{

     String name;

     int age;

     public Person() {

         // TODO Auto-generated constructor stub

     }

     public Person(String name, int age) {

         super();

         this.name = name;

         this.age = age;

     }   

}

###11.04_常见对象(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():判断字符串是否为空。

案例:

public class Demo4_StringMethod {

     public static void main(String[] args) {

         //demo1();

         //demo2();

         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

     }

 

     private static void demo2() {

         String s1 = "我爱aaa,哈哈";

         String s2 = "aaa";

         String s3 = "mmm";

         String s4 = "我爱";

         String s5 = "哈哈";

        

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

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

        

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

         System.out.println(s1.startsWith(s4));     //判断是否以传入的字符串开头

         System.out.println(s1.startsWith(s5));

        

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

         System.out.println(s1.endsWith(s4));      //判断是否以传入的字符串结尾

         System.out.println(s1.endsWith(s5));

     }

 

     private static void demo1() {

         String s1 = "sss";

         String s2 = "ddddd";

         String s3 = "fffff";

        

         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));      //不区分大小写

     }

}

###11.05_常见对象(模拟用户登录)(掌握)

* A:案例演示

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

     * 用户名和密码都是admin

案例:

import java.util.Scanner;

public class Test1 {

 

     /**

      * * A:案例演示

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

         * 用户名和密码都是admin

         * 分析:

         * 1,模拟登录,需要键盘录入,Scanner

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

         * 3,并提示有几次,需要判断,if

      */

     public static void main(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 password = sc.nextLine();         //将键盘录入的密码存储在password中

             

              //如果是字符串常量和字符串变量比较,通常都是字符串常量调用方法,将变量当作参数传递,防止空指针异常

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

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

                   break;                                     //跳出循环

              }else {

                   if(i == 2) {

                       System.out.println("您的错误次数已到,请明天再来吧");

                   }else {

                       System.out.println("录入错误,您还有" + (2-i) + "次机会");

                   }

              }

        

         }

     }

 

}

实现方式二:

/**

 * * A:案例演示

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

     * 用户名和密码都是admin

 * @author JX

 *

 */

public class ScannerTest {

     public static void main(String[] args) {

         Scanner sc = new Scanner(System.in);

         int count = 3;

         while(true) {

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

              String userName = sc.nextLine();

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

              String password = sc.nextLine();

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

                   System.out.println("欢迎光临:"+userName);

                   break;

              } else {

                   if(--count==0) {

                       System.out.println("登录次数已到,请明天再来吧!");

                       break;

                   } else{

                       System.out.println("您还有"+(count)+"机会!");        

                   }

              }

         }                 

     }

}

 

 

 

###11.06_常见对象(String类的获取功能)(掌握)

* A:String类的获取功能

     * int length():获取字符串的长度。

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

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

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

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

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

     * lastIndexOf

     * String substring(int start):从指定位置开始截取字符串,默认到末尾。

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

案例:

public class Demo5_StringMethod {

     public static void main(String[] args) {

         //demo1();

         //demo2();

         //demo3();

         //demo4();

         String s = "woaifgdg";

         s.substring(4);                                     //subString会产生一个新额字符串,需要将新的字符串记录

         System.out.println(s);

     }

 

     private static void demo4() {

         String s1 = "hdfghdfgh";

         String s2 = s1.substring(5);

         System.out.println(s2);

        

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

         System.out.println(s3);

     }

 

     private static void demo3() {

         String s1 = "dfghdfgh";

         int index1 = s1.indexOf('a', 3);                //从指定位置开始向后找

         System.out.println(index1);

        

         int index2 = s1.lastIndexOf('a');                  //从后向前找,第一次出现的字符

         System.out.println(index2);

        

         int index3 = s1.lastIndexOf('a', 7);           //从指定位置向前找

         System.out.println(index3);

     }

 

     private static void demo2() {

         String s1 = "dfghdf";

         int index = s1.indexOf('e');                  //参数接收的是int类型的,传递char类型的会自动提升

         System.out.println(index);

        

         int index2 = s1.indexOf('z');                      //如果不存在返回就是-1

         System.out.println(index2);

        

         int index3 = s1.indexOf("ma");                     //获取字符串中第一个字符出现的位置

         System.out.println(index3);

        

         int index4 = s1.indexOf("ia");

         System.out.println(index4);

     }

 

     private static void demo1() {

         //int[] arr = {11,22,33};

         //System.out.println(arr.length);              //数组中的length是属性

         String s1 = "dfghfgh";

         System.out.println(s1.length());          //length()是一个方法,获取的是每一个字符的个数

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

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

        

         char c = s2.charAt(5);                             //根据索引获取对应位置的字符

         System.out.println(c);

         char c2 = s2.charAt(10);                       //StringIndexOutOfBoundsException字符串索引越界异常

         System.out.println(c2);

     }

 

}

 

 

###11.07_常见对象(字符串的遍历)(掌握)

* A:案例演示

     * 需求：遍历字符串

案例:

public class Test2 {

 

     /**

      * * A:案例演示

      * 需求：遍历字符串

      */

     public static void main(String[] args) {

         String s = "afsdfa";

         for(int i = 0; i < s.length(); i++) { //通过for循环获取到字符串中每个字符的索引

              /*char c = s.charAt(i);

              System.out.println(c);*/

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

         }

}

 

    

###11.08_常见对象(统计不同类型字符个数)(掌握)

* A:案例演示

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

     * ABCDEabcd123456!@#$%^

        案例:

public class Test3 {

 

     /**

         * 分析:字符串是有字符组成的,而字符的值都是有范围的,通过范围来判断是否包含该字符

         * 如果包含就让计数器变量自增

      */

     public static void main(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') {

                   num++;

              }else {

                   other++;

              }

         }

        

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

         System.out.println(s + "中大写字母有:" + big + "个,小写字母有:" +small + "个,数字字符:"

         + num + "个,其他字符:" + other + "个");

     }

 

}

 

 

###11.09_常见对象(String类的转换功能)(掌握)

* A:String的转换功能：

     * byte[] getBytes():把字符串转换为字节数组。   // 字符串  ---.>字节数组

     * char[] toCharArray():把字符串转换为字符数组。//字符串 --->字符数组

     * static String valueOf(char[] chs):把字符数组转成字符串。//字符数组---->字符串

     * static String valueOf(int i):把int类型的数据转成字符串。 // valueOf可以把任意类型--->字符串

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

 

     * String toLowerCase():把字符串转成小写。(了解)

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

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

案例:

public class Demo6_StringMethod {

     public static void main(String[] args) {

         //demo1();

         //demo2();

         //demo3();

         String s1 = "sdfgsdf";

         String s2 = "zAADFgdsds";

         String s3 = s1.toLowerCase();

         String s4 = s2.toUpperCase();

        

         System.out.println(s3);

         System.out.println(s4);

        

         System.out.println(s3 + s4);              //用+拼接字符串更强大,可以用字符串与任意类型相加

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

     }

 

     private static void demo3() {

         char[] arr = {'a','b','c'};

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

         System.out.println(s);

        

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

         System.out.println(s2 + 100);

        

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

         System.out.println(p1);

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

         System.out.println(s3);

     }

 

     private static void demo2() {

         String s = "aasdfa";

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

        

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

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

         }

     }

 

     private static void demo1() {

         String s1 = "abc";

         byte[] arr = s1.getBytes();

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

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

         }

        

         String s2 = "你好你好";

         byte[] arr2 = s2.getBytes();              //通过gbk码表将字符串转换成字节数组

         for (int i = 0; i < arr2.length; i++) {        //编码:把我们看的懂转换为计算机看的懂得

              //System.out.print(arr2[i] + " ");      //gbk码表一个中文代表两个字节

         }                                              //gbk码表特点,中文的第一个字节肯定是负数

        

         String s3 = "琲";

         byte[] arr3 = s3.getBytes();

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

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

         }

     }

 

}

Person类的内容:

public class Person {

     private String name;

     private int age;

     public Person() {

         super();

        

     }

     public Person(String name, int age) {

         super();

         this.name = name;

         this.age = age;

     }

     public String getName() {

         return name;

     }

     public void setName(String name) {

         this.name = name;

     }

     public int getAge() {

         return age;

     }

     public void setAge(int age) {

         this.age = age;

     }

     @Override

     public String toString() {

         return "Person [name=" + name + ", age=" + age + "]";

     }

}

 

    

###11.10_常见对象(按要求转换字符)(链式编程掌握)

* A:案例演示

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

案例:

public class Test4 {

 

     /**

      * * A:案例演示

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

      * 链式编程:只要保证每次调用完方法返回的是对象,就可以继续调用

      */

     public static void main(String[] args) {

         String s = "woaiHEImaniaima";

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

         System.out.println(s2);

     }

 

}

 

 

###11.11_常见对象(把数组转成字符串)

* A:案例演示

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

         * 举例：

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

         * 输出结果：

              * "[1, 2, 3]"

案例:

public class Test5 {

 

     /**

      * 分析:

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

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

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

      */

     public static void main(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);

     }

 

}

 

###11.12_常见对象(String类的其他功能)

* A:String的替换功能及案例演示

     * String replace(char old,char new)

     * String replace(String old,String new)

* B:String的去除字符串两空格及案例演示

     * String trim()

* C:String的按字典顺序比较两个字符串及案例演示

     * int com

pareTo(String str)(暂时不用掌握)

     * int compareToIgnoreCase(String str)(了解)

案例:

public class Demo7_StringMethod {

     public static void main(String[] args) {

         //demo1();

         //demo2();        

         demo3();     

         /*

          * public int compare(String s1, String s2) {

            int n1 = s1.length();

            int n2 = s2.length();

            int min = Math.min(n1, n2);

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

                char c1 = s1.charAt(i);

                char c2 = s2.charAt(i);

                if (c1 != c2) {

                    c1 = Character.toUpperCase(c1);                          //将c1字符转换成大写

                    c2 = Character.toUpperCase(c2);                          //将c2字符转换成大写

                    if (c1 != c2) {

                        c1 = Character.toLowerCase(c1);                     //将c1字符转换成小写

                        c2 = Character.toLowerCase(c2);                     //将c2字符转换成小写

                        if (c1 != c2) {

                            // No overflow because of numeric promotion

                            return c1 - c2;

                        }

                    }

                }

            }

            return n1 - n2;

          */

     }

 

     private static void demo3() {

         String s1 = "a";

         String s2 = "aaaa";

        

         int num = s1.compareTo(s2);               //按照码表值比较

         System.out.println(num);

        

         String s3 = "a";

         String s4 = "b";

         int num2 = s3.compareTo(s4);

         System.out.println('c' + 0);             //查找的是unicode码表值

         System.out.println('d'+ 0);

         System.out.println(num2);

        

         String s5 = "asdasdf";

         String s6 = "fdfdsa";

         int num3 = s5.compareTo(s6);

         System.out.println(num3);

        

         int num4 = s5.compareToIgnoreCase(s6);

         System.out.println(num4);

     }

 

     private static void demo2() {

         String s = " asdf asd   ";

         String s2 = s.trim();

         System.out.println(s2);

     }

 

     private static void demo1() {

         String s = "asdf ozerao";

         String s2 = s.replace('i', 'o');          //用o替换i

         System.out.println(s2);

        

         String s3 = s.replace('z', 'o');           //z不存在,保留原字符不改变

         System.out.println(s3);

        

         String s4 = s.replace("ei", "ao");

         System.out.println(s4);

     }

 

}

 

    

 

###11.13_常见对象(字符串反转)

* A:案例演示

     * 需求：把字符串反转

         * 举例：键盘录入"abc"        

         * 输出结果："cba"

案例:

import java.util.Scanner;

 

public class Test6 {

 

     /**

      *    *分析:

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

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

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

         *4,打印

      */

     public static void main(String[] args) {

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

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

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

        

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

        

         String s = "";

         for(int i = arr.length-1; i >= 0; i--) {             //倒着遍历字符数组

              s = s + arr[i];                                        //拼接成字符串

         }

        

         System.out.println(s);

     }

 

}

 

 

###11.14_常见对象(在大串中查找小串出现的次数思路图解)

* A:画图演示

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

     * 这里的大串和小串可以自己根据情况给出

图解:

 

 

###11.15_常见对象(在大串中查找小串出现的次数代码实现)

* A:案例演示

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

案例:

public class Test7 {

 

     public static void main(String[] args) {

         //定义大串

         String max ="adfas afsdfas fdfdaaasdf fdasasdfdsaasdf";

         //定义小串

         String min = "asdf";

        

         //定义计数器变量

         int count = 0;

         //定义索引

         int index = 0;

         //定义循环,判断小串是否在大串中出现

         while((index = max.indexOf(min)) != -1) {

              count++;                                  //计数器自增

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

         }

         System.out.println(count);

     }

}

 

Person p = new Person();

String str = "abc";

str = "def";          //当把def赋值给str原来的abc就是变成了垃圾

syso(str.toString())   //打印结果abc,String类重写了toString 方法返回该对象本身

 

public String(byte[] bytes)把字节数组转成字符串

byte[] arr = { 97,98,99};

String s = new String(arr);//解码，将计算机读的懂的转换成我们读的懂的

syso(s)                 //输出结果abc

 

String s = "ni";

String s2 = "hao";

syso(s.equals(s2));

 

equals

equalsIgnore

contains

startsWith

endsWith

isEmpty

 

""是字符串的常量同时也是一个String类的对象

unll是空常量，不能调用任何方法，否则会出现空指针异常，可以给任意引用数据赋值