常用类

标签：operator   not   创建   实例化   ++   match   ret   row   可变   

String的使用

String：字符串，使用一对""引起来表示。

1. String声明为final的，不可被继承

2. String实现了Serializable接口：表示字符串是支持序列化

3. 实现了Comparable接口：表示String可以比较大小

4. String内部定义了final char[] value用于存储字符串数据

5. String：代表不可变的字符序列。简称：不可变性

   1. 当对字符串重新赋值时，需要重新指定内存区域赋值，不能使用原有的value进行赋值

   2. 当对现有的字符串进行连接操作时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值

   3. 当调用String的replace()方法修改指定字符或字符串时，也需要重新指定内存区域赋值，不能使用原有的value进行赋值

6. 通过字面量的方式（区别于new）给一个字符串赋值，此时的字符串值声明在字符串常量池中。

7. 字符串常量池是不会存储相同内容的字符串的

String的实例化方式

• 方式一：通过字面量定义的方式

• 方式二：通过new+构造器的方式

• 面试题：String s=new String("abc");方式创建对象，在内存中创建了几个对象？

  （两个：一个是堆空间中new结构，另一个是char[]对应的常量池中的数据：“abc”）

    public void test2(){
       //通过字面量定义的方式：此时的s1和s2的数据javaEE声明在方法区中的字符串常量池中。
        String s1="javaEE";
        String s2="javaEE";
?
        //通过new + 构造器的方式：此时的s3和s4保存的地址值，是数据在堆空间中开辟空间以后
        String s3 = new String("javaEE");
        String s4 = new String("javaEE");
?
        System.out.println(s1 == s2);//true
        System.out.println(s1 == s3);//false
        System.out.println(s1 == s4);//false
        System.out.println(s3 == s4);//false
?
        System.out.println("***********************");
        Person p1 = new Person("Tom", 12);
        Person p2 = new Person("Tom", 12);
?
        System.out.println(p1.name.equals(p2.name));  //true
        System.out.println(p1.name==p2.name);  //true
?
?
    }
?

1.常量与常量的拼接结果在常量池中。且常量池中不会存在相同内容的常量。 2.只要其中有一个变量，结果就在堆中 3.如果拼接的结果调用intern()方法，返回值就在常量池中

 public void test3(){
       String s1="javaEE";
       String s2="hadoop";
?
       String s3="javaEEhadoop";
       String s4="javaEE"+"hadoop";
       String s5=s1+"hadoop";
       String s6="javaEE"+s2;
       String s7=s1+s2;
       final String s9="javaEE"; //常量
       String s10=s9+"hadoop";
?
        System.out.println(s3==s4);//true
        System.out.println(s3==s5);//false
        System.out.println(s3==s6);//false
        System.out.println(s3==s7);//false
        System.out.println(s5==s6);//false
        System.out.println(s5==s7);//false
        System.out.println(s6==s7);//false
        System.out.println("*************");
        System.out.println(s10==s3);  //true
        System.out.println("*************");
        String s8=s5.intern();   //返回值得到的S8使用的常量值中已经存在的"javaEEhadoop"
        System.out.println(s3==s8);//true
    }

一道面试题

public class StringTest {
    String str=new String("good");
    char[] ch={‘t‘,‘e‘,‘s‘,‘t‘};
?
?
    public void change(String str,char ch[]){
        str="test ok";
        ch[0] =‘b‘;
    }
?
    public static void main(String[] args) {
        StringTest ex=new StringTest();
        ex.change(ex.str,ex.ch);
        System.out.println(ex.str);   //good
        System.out.println(ex.ch);  //best
    }
}

4

String常用方法1

int length();返回字符串长度：return value.length char charAt(int index):返回某索引处的字符return value[index] boolean isEmpty();判断是否是空字符串：return value.length==0 String toLowerCase();使用默认环境语言，将String中的所有字符转化为小写 String toUpperCase();使用默认环境语言，将String中的所有字符转化为大写 String trim();返回字符串的副本，忽略前导空白和尾部空白 boolean equals(Object obj):比较字符串的内容是否相同 boolean equalsIgnoreCase(String anotherString):与equals方法类似，忽略大小写 String concat(String str):将指定字符串连接到此字符串的结尾。 等价于用“+” int compareTo(String anotherString);比较两个字符串的大小 String substring(int beginIndex):返回一个新的字符串，它是此字符串的从beginIndex开始截取到最后的一个字符串 String substring(int beginIndex,int endIndex):返回一个新字符串，它是此字符串从beginIndex开始截取到endIndex（不包括）的一个子字符串

 public void test1(){
        String s1="HelloWorld";
        System.out.println(s1.length());//10
        System.out.println(s1.charAt(0));//H
        System.out.println(s1.charAt(9));//d
?
        System.out.println(s1.isEmpty());  //false
?
        String s2=s1.toLowerCase();
        System.out.println(s1); //HelloWorld   s1不可变仍然为原来的字符串
        System.out.println(s2); //helloworld   改成小写以后的字符串
?
        String s3="   he  llo  world  ";
        String s4 = s3.trim();  //消除首尾的空格
        System.out.println("----"+s3+"----");//----   he  llo  world  ----
        System.out.println("----"+s4+"----");//----he  llo  world----
    }
?
  public void test2(){
        String s1="HelloWorld";
        String s2="helloworld";
        System.out.println(s1.equals(s2));//比较字符串的内容是否相同
        System.out.println(s1.equalsIgnoreCase(s2));//与equals方法类似，忽略大小写
?
        String s3="abc";
        String s4=s3.concat("def");
        System.out.println(s4);//将指定字符串连接到此字符串的结尾。  等价于用“+”
?
        String s5="abc";
        String s6=new String("abe");
        System.out.println(s5.compareTo(s6));//涉及到字符串排序   比较两个字符串的大小
?
        String s7="我爱北京天安门";
        String s8 = s7.substring(2);
        System.out.println(s7);
        System.out.println(s8);//北京天安门
?
        String s9 = s7.substring(1, 4); //  [1,4) 左闭右开
        System.out.println(s9); //爱北京
?
    }

String常用方法2

boolean endsWith(String suffix):测试此字符串是否以指定的后缀结束 boolean startsWith(String prefix):测试此字符串是否以指定的前缀开始 boolean startsWith(String prefix,int toffset):测试此字符串从指定索引开始的子字符串是否以指定前缀开始

boolean contains(CharSequence s):当且仅当此字符串包含指定的char值序列时，返回true int indexOf(String str):返回指定子字符串在此字符串中第一次出现处的索引 int indexOf(String str,int fromIndex);返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始 int lastINdexOf(String str):返回指定子字符串在此字符串中最右边出现处的索引 int lastINdexOf(String str,int fromIndex):返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索 注：indexOf和lastIndexOf方法如果未找到都是返回-1

 public void test3(){
        String str1="helloworld";
        boolean b1 = str1.endsWith("rld"); //测试此字符串是否以指定的后缀结束
        System.out.println(b1);  //true
?
        boolean b2 = str1.startsWith("he");// 测试此字符串是否以指定的前缀开始
        System.out.println(b2);  //true
?
        boolean b3 = str1.startsWith("llo",2); //测试此字符串从指定索引开始的子字符串是否以指定前缀开始
        System.out.println(b3);  //true
?
        String str2="wor";
        System.out.println(str1.contains(str2));//true  当且仅当此字符串包含指定的char值序列时，返回true
?
        System.out.println(str1.indexOf("owo"));  //4
        System.out.println(str1.indexOf("lol"));  //-1   indexOf和lastIndexOf方法如果未找到都是返回-1
        System.out.println(str1.indexOf("wo", 4));//5 返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始
?
        String str3="hellorworld";
        System.out.println(str3.lastIndexOf("or"));//7  返回指定子字符串在此字符串中最右边出现处的索引
        System.out.println(str3.lastIndexOf("or",6));//4  返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索
?
        //什么情况下，indexOf(str)和LastIndexOf(str)返回值相同？
        //情况一：存在唯一的一个str。情况二：不存在str
?
    }

String常用方法3

替换： String replace(char oldChar,char newChar):返回一个新字符串，它是通过newChar替换此字符串中出现的所有oldChar得到的。 String replace(CharSequence target,CharSequence replacement):使用指定的字面值替换序列替换此字符串所有匹配字面值目标序列的子字符串 String replaceALL(String regex,String replacement):使用给定的replacement替换此字符串所有匹配给定的正则表达式的子字符串 String replaceFirst(String regex,String replacement)：使用给定的replacement替换此字符串匹配给定的正则表达式的第一个子字符串 匹配： boolean matches(String regex):告知此字符串是否匹配给定的正则表达式。 切片： String[] split(String regex): 根据给定正则表达式的匹配拆分此字符串。 String[] split(String regex,int limit): 根据匹配给定的正则表达式来拆分此字符串，最多不超过limit个，如果超过了，剩下的全部都放到最后一个元素中。

public void test4(){
        String str1="北京你好,你好北京";
        String str2=str1.replace("北京","上海");//返回一个新字符串，它是通过newChar替换此字符串中出现的所有oldChar得到的。
        System.out.println(str1);//北京你好,你好北京
        System.out.println(str2);//上海你好,你好上海
?
        System.out.println("******************");
        String str="12hello54world54java575mysql8451";
        //把字符串中的数字替换成，，如果结果中开头和结尾有，的话去掉
        String string=str.replaceAll("\\d+",",").replaceAll("^,|,$","");
        System.out.println(string);//hello,world,java,mysql
        System.out.println("******************");
        str="12345";
        //判断str字符串中是否全部有数字组成，即有1-n个数字组成
        boolean matches=str.matches("\\d+");
        System.out.println(matches);//true
        String tel="0571-43512988";
        //判断这是否是一个杭州的固定电话
        boolean result=tel.matches("0571-\\d{7,8}");
        System.out.println(result);//true
        System.out.println("******************");
        str="hello|world|java";
        //根据给定正则表达式的匹配拆分此字符串。
        String[] strs=str.split("\\|");
        for (int i = 0; i < strs.length; i++) {
            System.out.println(strs[i]);
        }
        System.out.println("******************");
        str2="hello.world.java";
        String[] strs2=str2.split("\\.");
        for (int i = 0; i < strs2.length; i++) {
            System.out.println(strs2[i]);
        }
?
    }

涉及到String类与其他结构之间的转换

String 与基本数据类型、包装类之间的转换。

String --> 基本数据类型、包装类：调用包装类的静态方法：parseXxx(str) 基本数据类型、包装类 -->String:调用String重载的valueOf（xxx）

 public void test1(){
        String str1="123";
        //int num=(int)str1;  //错误写法
        int num=Integer.parseInt(str1);  //将字符串参数作为有符号的十进制整数进行解析。
?
        String str2=String.valueOf(num);//"123"
        String str3=num+"";
?
        System.out.println(str1==str3);   //false   str3在堆中
    }

String 与 char[]之间的转换

String - - > char[]：调用String的toCharArray() char[] - ->String:调用String的构造器

 public void test2(){
        String str1="abc123";
?
        char[] charArray=str1.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
            System.out.println(charArray[i]);
        }
?
        char[] arr=new char[]{‘h‘,‘e‘,‘l‘,‘l‘,‘o‘};
        String str2=new String(arr);
        System.out.println(str2);
    }

String 与 byte[]之间的转换

编码：String - -> byte[]:调用String的getBytes() 解码：byte[]- ->String:调用String的构造器

编码：字符串 - - >字节（看得懂 - - >看不懂的二进制数据） 解码：编码的逆向过程，字节- - > 字符串（看不懂的二进制数据- - >看得懂）

说明：解码时，要求解码使用的字符集必须与编码时使用的字符集一致，否则会出现乱码。

public void test3() throws UnsupportedEncodingException {
        String str1="abc123中国";
        byte[] bytes = str1.getBytes();//使用默认的字符集，进行转换
        System.out.println(Arrays.toString(bytes));

        byte[] gbks = str1.getBytes("gbk");//使用gbk字符集进行编码
        System.out.println(Arrays.toString(gbks));

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

        String str2 = new String(bytes); //使用默认的字符集，进行解码。
        System.out.println(str2);

        String str3=new String(gbks); //出现乱码。原因：编码集和解码集不一致！
        System.out.println(str3);

        String str4=new String(gbks,"gbk");
        System.out.println(str4);
    }

String、StringBuffer、StringBuilder三者的异同(面试题)

String:不可变的字符序列;底层使用char[]存储 StringBuffer:可变的字符序列;线程安全的，效率低;底层使用char[]存储 StringBuilder:可变的字符序列;jdk5.0新增的，线程不安全的，效率高;底层使用char[]存储

源码分析： String str=new String(); //char[] value =new char[0] String str1=new String("abc"); // char[] value =new char[]{‘a‘,‘b‘,‘c‘};

StringBuffer sb1=new StringBuffer(); // char[] value =new char[16];底层创建了一个长度是16的数组。 sb1.append(‘a‘); //value[0]=‘a‘; sb1.append(‘b‘); // value[1]=‘b‘;

StringBuffer sb2=new StringBuffer("abc"); //char[] value =new char["abc".length+16]

//问题1.System.out.println(sb2.length()); //3 //问题2.扩容问题：如果要添加的数据底层数组盛不下了，那就需要扩容底层的数组。 默认情况下，扩容为原来容量的2倍+2 (16*2+2)，同时将原有的数组中的元素复制到新的数组中

指导意义：开发中建议大家使用:StringBuffer(int capacity) 或StringBuilder(int capacity)

StringBuffer常用方法

StringBuffer append(xxx): 提供了很多的append()方法，用于进行字符串的拼接 StringBuffer delete(int start,int ed): 删除指定位置的内容 [start,end) StringBuffer replace(int start,int end ,String str): 把[start,end)位置替换为str StringBuffer insert(int offset,xxx):在指定位置插入xxx StringBuffer reverse():把当前字符序列逆转 Public int indexOf(String str) :返回str在StirngBuffer中首次出现的位置 Public String substring(int start,int end)：返回一个从start开始到end索引结束的左闭右开的子字符串 public int length() public char charAt(int n) public void setCharAt(int n,char ch)

总结： 增：append(xxx) 删：delete(int start,int ed) 改：replace(int start,int end ,String str)(改一个字符串) / setCharAt(int n,char ch)(改一个字符) 查：charAt(int n) 插：insert(int offset,xxx) 长度：length() *遍历：for+charAt() / toString

 public void test2(){
        StringBuffer s1 = new StringBuffer("abc");
        s1.append(1);
        s1.append("1");
        System.out.println(s1);  //abc11
      //  s1.delete(2,4);      //ab1
      //  s1.replace(2,4,"hello"); //abhello1
       // s1.insert(2,false);  //abfalsec11
       // s1.reverse();  //11cba
        String s2 = s1.substring(1, 3);  //bc
        System.out.println(s1);
        System.out.println(s2);

    }

String、StringBuffer、StringBuilder对比三者的效率

从高到低排列：StringBuilder>StringBuffer>String

java.util.Date类和java.sql.Date类

1. 两个构造器的使用

   • 构造器一：Date() 创建一个对应当前时间的Date对象

   • 构造器二：创建指定毫秒数的Date对象

2. 两个方法的使用

   • toString():显示当前的年、月、日、时、分、秒

   • getTime():获取当前Date对象对应的毫秒数。（时间戳）

3. java.sql.Date对应着数据库中的日期类型的变量

   • 如何实例化

   • 如何将java.util.Date对象转换为java.sql.Date对象

 public void test2(){
        //构造器一：Date()  创建一个对应当前时间的Date对象
        Date date1 = new Date();
        System.out.println(date1.toString()); //Tue Oct 20 11:01:26 GMT+08:00 2020
        System.out.println(date1.getTime());  //1603162886285

        //构造器二：创建指定毫秒数的Date对象
        Date date2=new Date(1603162886285L);
        System.out.println(date2);

        //创建java.sql.Date对象
        java.sql.Date date3 = new java.sql.Date(1603162886285L);
        System.out.println(date3);//  2020-10-20

        //如何将java.util.Date对象转换为java.sql.Date对象
        Date date7 = new Date();
        java.sql.Date date8 = new java.sql.Date(date7.getTime());

    }

System类中的currentTimeMillis()

 public void test1(){
        long time=System.currentTimeMillis();
        //返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差
        //称为时间戳
        System.out.println(time);
    }

常用类

标签：operator   not   创建   实例化   ++   match   ret   row   可变   

原文地址：https://www.cnblogs.com/Alvaro/p/13958182.html