API基础应用1

1. String字符串类型：

   • java.lang.String类使用final修饰，不能被继承
   • String的底层封装的是一个字符数组
   • String在内存中采用Unicode编码格式，每个字符占用2个字节的内存空间
   • 字符串对象一旦创建，对象内容永远无法改变，但字符串引用可以重新赋值(指向新的对象)
     • String称为不变对象

2. 字符串常量池：是java对String的一个优化措施

   • java推荐我们使用字面量/直接量(直接"")的方式来创建字符串对象，并且会将所有以字面量方式创建的对象缓存到常量池中，当使用相同字面量再创建字符串对象时将会复用常量池中的对象，以减少内存开销。

     public class StringDemo {
         public static void main(String[] args) {
             /*
               常见面试题:
                 String s = new String("hello");
                 问:如上语句创建了几个对象?
                 答:2个
                   第一个:字面量"hello"
                   ----java会创建一个String对象表示字面量"hello"，并将其存入常量池中
                   第二个:new String()
                   ----new String()时会再创建一个字符串对象，并引用hello字符串内容
              */
             String s = new String("hello"); //创建了2个对象
             String s1 = "hello"; //复用常量池中的字面量对象地址
             System.out.println(s==s1); //false，==比较的是地址是否相同
     
             //在实际应用中，String比较相等一般都是比较字符串的内容是否相同
             //因此我们需要使用equals()方法来比较两个字符串内容是否相同
             System.out.println(s.equals(s1)); //true，equals()比较的是内容是否相同---必须掌握
     
             /*
               使用字面量("")来创建字符串对象时，JVM会检查常量池中是否有该对象
               1)若没有，则会创建字符串对象，并将其引用存入到常量池中
               2)若有，则直接将常量池中的对象(引用)返回，并不会创建新的字符串对象
              */
             /*
             String s1 = "123abc"; //常量池还没有，因此创建该字符串对象，并存入常量池中
             String s2 = "123abc"; //常量池中已经有了，直接复用了
             String s3 = "123abc"; //常量池中已经有了，直接复用了
             //引用类型==，比较的是地址是否相同-----这是规定
             System.out.println(s1==s2); //true
             System.out.println(s1==s3); //true
             System.out.println(s2==s3); //true
     
             s1 = s1+"!"; //创建新的字符串对象("123abc!")，并将地址赋值给s1
             System.out.println(s1==s2); //false
             */
     
             /*
             String s1 = "123abc"; //堆中创建123abc字符量对象，并缓存到常量池中
             //编译器在编译时，若发现是两个字面量相连，则会直接连接好并将结果保存起来
             //如下语句会被编译为: String s2 = "123abc";
             String s2 = "123"+"abc";
             System.out.println(s1==s2); //true
     
             String s3 = "123";
             //因为s3是一个变量，所以在编译期并不会直接编译好
             String s4 = s3+"abc"; //创建一个新的对象存储123abc
             System.out.println(s1==s4); //false
             */
         }
     }
     

3. String常用方法：

   • length()：获取字符串的长度(字符个数)

     public class LengthDemo {
         public static void main(String[] args) {
             String str = "我爱Java!";
             int len = str.length(); //获取str的长度
             System.out.println(len); //7
         }
     }
     

   • trim()：去除当前字符串两边的空白字符

     public class TrimDemo {
         public static void main(String[] args) {
             String str = "     hello world        ";
              str =str.trim(); //去除str两边的空白字符(一个新的字符串对象)，并存入str中
             System.out.println(str); //hello world
         }
     }
     

   • toUpperCase()/toLowerCase()：将当前字符串中的英文部分给转换为全大写/全小写

     public class ToUpperCaseDemo {
         public static void main(String[] args) {
             String str = "我爱Java!";
             String upper = str.toUpperCase(); //将str中的英文部分转换为全大写，并赋值给upper
             System.out.println(upper); //我爱JAVA!
             String lower = str.toLowerCase(); //将str中的英文部分转换为全小写，并赋值为lower
             System.out.println(lower); //我爱java!
         }
     }
     

   • startsWith()/endsWith()：判断当前字符串是否是以给定的定符串开始/结束的

     public class StartsWithDemo {
         public static void main(String[] args){
             String str = "thinking in java"; //java编程思想(java经典书---工具书)
             boolean starts = str.startsWith("think"); //判断str是否是以think开头的
             System.out.println(starts); //true
             boolean ends = str.endsWith(".png"); //判断str是否是以.png结尾的
             System.out.println(ends); //false
         }
     }
     

   • charAt()：返回当前字符串指定位置上的字符----根据位置找字符

     public class CharAtDemo {
         public static void main(String[] args) {
             //                      111111----和下面的连成10/11/12/13/14/15
             //            0123456789012345
             String str = "thinking in java";
             char c = str.charAt(8); //获取str中下标9所对应的字符
             System.out.println(c); //i
         }
     }
     

   • indexOf()/lastIndexOf()：检索给定字符串在当前字符串中第一次/最后一次出现的位置----根据字符串找位置

     public class IndexOfDemo {
         public static void main(String[] args) {
             //                      111111----和下面的连成10/11/12/13/14/15
             //            0123456789012345
             String str = "thinking in java";
             int index = str.indexOf("in"); //检索in在str中第1次出现的位置
             System.out.println(index); //2
             index = str.indexOf("in",3); //从下标为3的位置开始找in第1次出现的位置
             System.out.println(index); //5
             index = str.indexOf("abc"); //若字符串在str中不存在，则返回-1
             System.out.println(index); //-1
     
             index = str.lastIndexOf("in"); //检索in在str中最后一次出现的位置
             System.out.println(index); //9
         }
     }
     

   • substring()：截取当前字符串中指定范围的字符串(含头不含尾)

     public class SubstringDemo {
         public static void main(String[] args) {
             //                      1----与下面的数字连成10
             //            01234567890
             String str = "www.tedu.cn";
             int start = str.indexOf(".")+1; //4
             int end = str.indexOf(".",start); //8
             String name = str.substring(start,end); //截取下标4到7的字符串
             System.out.println(name); //tedu
     
         }
     }
     

   • 静态方法valueOf()：将其它数据类型转换为String

     public class ValueOfDemo {
         public static void main(String[] args) {
             int a = 123;
             String s1 = String.valueOf(a); //将int型变量a转换为String类型并赋值给s1
             System.out.println(s1); //123---字符串类型
     
             double b = 123.456;
             String s2 = String.valueOf(b); //将double型变量b转换为String类型并赋值给s2
             System.out.println(s2); //123.456---字符串类型
     
             String s3 = b+""; //任何类型与字符串相连，结果都会变为字符串类型，效率低
             System.out.println(s3); //123.456---字符串类型
         }
     }