01.08_学习Java的day18(详解)

最新推荐文章于 2023-02-15 15:01:38 发布

学习Java的唐唐

最新推荐文章于 2023-02-15 15:01:38 发布

阅读量121

点赞数

分类专栏： JavaSE

本文链接：https://blog.csdn.net/weixin_45506970/article/details/103941444

版权

JavaSE 专栏收录该内容

53 篇文章 0 订阅

订阅专栏

一、字符串的比较

1、==比较

（1）常量池中的两个字符串对象比较，只要内容相同，那么地址就相同，因为常量对象是共享的
（2）其他==比较结果都是false。

2、boolean equals(Object anObject)

如果没有重写Object中equals，等价于=，
String类重写了Object中的equals，比较字符串的字符内容。并且区分大小写

如果自己实现，如何重写equals方法？
（1）地址比较
（2）equals（）的参数的非空判断
（3）equals（）的参数的类型判断
（4）两个字符串的长度比较
（5）两个字符串的字符挨个比较

3、boolean equalsIgnoreCase(String anotherString) :

比较字符串的内容，忽略大小写

4、比较大小

A：String本身实现Comparable自然比较接口，重写int compareTo(T t)：按照字符的Unicode编码值比较大小
当前字符串this 大于指定字符串 t 返回正整数
当前字符串this 小于指定字符串 t 返回负整数
当前字符串this 等于指定字符串 t 返回零
B：java.text.Collator比较器，是系统预定义的一种定制比较器
C：也可以自定义定制比较：实现Comparator接口，重写int compare(T t1, T t2)

5、int compareToIgnoreCase(String str) ：

忽略大小写的比较大小

public class StringCompare {
    @Test
    public void test08() {
        String s1 = new String("hello");
        String s2 = new String("HELLO");

        System.out.println(s1.compareTo(s2));//32   区分大小写
        System.out.println(s1.compareToIgnoreCase(s2));//0  不区分大小写
    }

    @Test
    public void test07() {
        String s1 = new String("hello");
        String s2 = new String("HELLO");

        //按照字符串的长度比较
        Comparator c = new Comparator(){

            @Override
            public int compare(Object o1, Object o2) {
                String s1 = (String) o1;
                String s2 = (String) o2;
                return s1.length() - s2.length();
            }
        };
        System.out.println(c.compare(s1,s2));//0
    }

    @Test
    public void test06(){
        String s1 = new String("张三");
        String s2 = new String("李四");

        System.out.println(s1.compareTo(s2));//-2094  按照张和李的Unicode编码值比较的

        Collator collator = Collator.getInstance(Locale.CHINESE);
        System.out.println(collator.compare(s1,s2));//1   按照 康熙字典 中汉字的顺序，相当于拼音的顺序
    }


    @Test
    public void test05(){
        String s1 = new String("hello");
        String s2 = new String("HELLO");

        System.out.println(s1.compareTo(s2));//32
    }


    @Test
    public void test04(){
        String s1 = new String("hello");
        String s2 = new String("HELLO");

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

    @Test
    public void test03(){
        String s1 = new String("hello");
        String s2 = new String("Hello");

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

    @Test
    public void test02(){
        String s1 = new String("hello");
        String s2 = new String("hello");

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

    @Test
    public void test01(){
        String s1 = "hello";
        String s2 = "hello";

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

二、空字符串的判断

1、什么是空字符串

String str; //不是空字符串，如果是局部变量，表示未初始化，成员变量的默认值是null
String str = null; //不是空字符串，没有创建字符串对象
String str = “”; //空字符串
String str = new String(); //空字符串
String str = new String(""); //空字符串

2、空字符串的特点

（1）有对象
（2）字符串的长度为0
或者说字符串中char数组，byte数组的长度为0

3、如何判断

（1）str!= null && str.length() == 0
（2）str!= null && str.equals("")
（3）str!= null && str.isEmpty()

（4）建议使用第四种
“”.equals(str)

public class StringEmpty {
    @Test
    public void test3() {
        String str = null;
        System.out.println("".equals(str));
//        System.out.println(str.equals(""));//空指针异常

        System.out.println(str!= null && str.equals(""));//也可以
    }

    @Test
    public void test2() {
        String str1 = "";    //空字符串

        System.out.println(str1.isEmpty());
    }

    @Test
    public void test(){
        String str1 = "";    //空字符串
        String str2 = new String(); //空字符串
        String str3 = new String(""); //空字符串

        if(str1.length() == 0){
            System.out.println("str1是空字符串");
        }

        if(str1.equals("")){
            System.out.println("str1是空字符串");
        }

        if(str1 == ""){
            System.out.println("str1是空字符串");
        }
        System.out.println("-----------------");
        if(str2.length() == 0){
            System.out.println("str2是空字符串");
        }

        if(str2.equals("")){
            System.out.println("str2是空字符串");
        }

        if(str2 == ""){//只能比较字符串的常量
            System.out.println("str2是空字符串");
        }
    }
}

三、字符串的常用方法系列（一）

1、和比较相关

boolean equals(x)
boolean equalsIgnoreCase(x)
int compareTo(x)
int compareToIgnoreCase(x)

2、拼接

concat(x)

3、求字符串长度

int length()

数组的length和字符串的length有什么区别？文件的length
数组.length属性
字符串.length()
文件.length()

4、是否为空

boolean isEmpty()

5、转大小写

String toUpperCase()
String toLowerCase()

6、去掉前后空白符

String trim()

如果没有前后空白需要去掉的话，就返回原字符串。
如果有把前后空白符去掉，就返回新字符串

public class StringMethod {

    @Test
    public void test05(){
        String str = "hello";

        str = str.trim();
        System.out.println(str == "hello");//true
    }

    @Test
    public void test04(){
        String str = " ";

        str = str.trim();
        System.out.println(str == "");//false
    }
    @Test
    public void test03(){
        String str = "";//本身就是空字符串，没有修改

        str = str.trim();
        System.out.println(str == "");//true
    }

    @Test
    public void test02(){
        String str = "   hello  world   ";
//        str.trim();//错误的，String不可变，必须接收
        str = str.trim();

        System.out.println("[" + str +"]");
    }

    @Test
    public void test(){
        String str = "hello";
        System.out.println(str.toUpperCase());
    }
}

四、字符串的常用方法系列之二：和查找有关

1、boolean contains(xx)：

是否包含xx

2、int indexOf(xx)：

查找xx在当前字符串中出现的索引，如果有多个，返回第一次出现的，如果没有返回-1

3、int lastIndexOf(xx)：

查找xx在当前字符串中出现的索引，如果有多个，返回最后一次出现的，如果没有返回-1

public class StringMethod2 {
    @Test
    public void test02(){
        String str = "hello";
        System.out.println(str.indexOf("o"));//4
        System.out.println(str.indexOf("he"));//0
        System.out.println(str.indexOf("ch"));//-1
        System.out.println(str.indexOf("l"));//2
    }

    @Test
    public void test(){
        String str = "hello";
        System.out.println(str.contains("o"));
        System.out.println(str.contains("he"));
        System.out.println(str.contains("ch"));
    }
}

五、字符串的常用方法系列之三：和截取有关

1、String substring(int beginIndex)：[beginIndex,最后]
2、String substring(int beginIndex, int endIndex)：[beginIndex,endIndex)

public class StringMethod3 {
    @Test
    public void test02(){
        String str = "d:/atguigu/Hello.java";

        //截取出这个Java源文件的名称
        int dotIndex = str.lastIndexOf(".");
        int ganIndex = str.lastIndexOf("/");
        String name = str.substring(ganIndex+1,dotIndex);
        System.out.println(name);
    }

    @Test
    public void test(){
        String str = "chailinyan is a girl.";

        String substring = str.substring(5);
        System.out.println(substring);//inyan is a girl.

        String substring2 = str.substring(0,5);
        System.out.println(substring2);//chail
    }
}

六、字符串的常用方法系列之三：和字符相关

1、char charAt(int index)：取出[index]的一个字符
2、char[] toCharArray()：创建了一个新数组返回，复制了原来字符串的内容
3、String(char[] data)：可以使用字符数组，构造字符串
String(char[] data,int offset, int count)
4、String.valueOf( char[] data)
String.valueOf( char[] data,int offset, int count)

public class TestStringMethod4 {
    @Test
    public void test04() {
        char[] arr = {'h','e','l','l','o'};

        System.out.println(new String(arr));
        System.out.println(new String(arr,0,2));
    }

    @Test
    public void test03() {
        String str = "hello";
        char[] chars = str.toCharArray();
        chars[0] = 'a';
        System.out.println(str);
    }

    @Test
    public void test02(){
        String str = "hello";
        System.out.println(str.charAt(0));
        System.out.println(str.charAt(3));
    }

    @Test
    public void test(){
        Scanner input = new Scanner(System.in);
        System.out.println("请输入性别：");
        /*
        input.next()：Scanner类的next()方法，返回值类型是String，得到一个字符串对象
        字符串对象.charAt(0)；String类charAt()方法，获取[0]位置的字符
         */
        char gender = input.next().charAt(0);
    }
}

七、字符串的常用方法系列之五：和字节相关

1、byte[] getBytes()：按照平台默认的编码方式进行编码的
2、byte[] getBytes(String charsetName)：按照指定的编码方式进行编码
3、String(byte[] data)：按照台默认的编码方式进行解码的
String(byte[] data,int offset, int length)
4、String(byte[] data,String charsetName)：按照台默认的编码方式进行解码的
String(byte[] data,int offset, int length,String charsetName)

编码：把字符序列转为对应的字节序列就是编码。
因为计算机底层是识别二进制，不识别字符，所以在存储、传输等时，需要把字符转为字节。
编码有很多种编码方式：
（1）ASCII码：只支持0~127的128字符，不支持中文
（2）GBK：支持中文，一个汉字编码为2个字节
不支持日文等其他

            GBK要向下兼容，支持原来的ASCII码。
                    ASCII码表中的字符只要一个字节。
                    汉字是需要两个字节。
                            网络中有一串数据过来了。11001010 11010000 01110000 01110010
                                这边接收者，该如何处理如上数据呢？
                                是按照4个字节，解析为4个字符呢，还是解析为2个字符呢？
                                如果没有区分，就无法处理以上的数据。
                      GBK就这样规定，如果字节开头的是非0，那么就连续读取2个字节，解析为一个汉字。
                                    如果字节开头的是0，那么就是一个字节一个字符
  （3）UTF-8：也支持中文，日文等全世界的字符。
            一个汉字大多数都是编码为3个字节。

               Unicode字符集，收录了全世界的常用文字。称为万国码表。
               UTF-8，UTF-16等编码是针对Unicode字符集在网络中传输，或程序中表示字符使用的。
               UTF-8是变长编码，有1个字节、2个字节、3个字节、4个字节
                    1个字节，最高为0
                    2个字节，第一个字节最高为是110，第二个字节最高为是10
                    3个字节，第一个字节最高为是1110，第二个字节最高为是10，第三个字节最高为是10
                    4个字节，第一个字节最高为是11110，第二个字节最高为是10，第三个字节最高为是10，第四个字节最高为是10

   （4）ISO8859-1：支持欧美系列字符，不支持中文，每一个字符也是使用一个字节

解码：把字节序列重新构建为字符串

中文要正确的解码，即不出现乱码：
（1）必须选择支持中文的字符集
（2）编码与解码的字符集要一致
（3）不能丢失数据

public class TestStringMethod5 {
    @Test
    public void test05()throws UnsupportedEncodingException {
        byte[] data1 = {63};//现在无论使用哪种编码方式进行解码都解不回来，因为当时编码的时候就丢失数据了，一个汉字编码为1个字节是错误的
        byte[] data2 = {-55, -48};//使用GBK编码的，只能使用GBK进行解码
        byte[] data3 = {-27, -80, -102};//使用UTF-8编码的，只能使用UTF-8进行解码
        byte[] data4 = {-27, -80};//使用UTF-8编码的，只能使用UTF-8进行解码，并且这里无法正确解码，因为少了一个字节

        System.out.println(new String(data1, "ISO8859-1"));
        System.out.println(new String(data1, "GBK"));
        System.out.println(new String(data1, "UTF-8"));

        System.out.println("-----------------------------");
        System.out.println(new String(data2, "ISO8859-1"));
        System.out.println(new String(data2, "GBK"));
        System.out.println(new String(data2, "UTF-8"));

        System.out.println("-----------------------------");
        System.out.println(new String(data3, "ISO8859-1"));
        System.out.println(new String(data3, "GBK"));
        System.out.println(new String(data3, "UTF-8"));

        System.out.println("-----------------------------");
        System.out.println(new String(data4, "ISO8859-1"));
        System.out.println(new String(data4, "GBK"));
        System.out.println(new String(data4, "UTF-8"));
    }


    @Test
    public void test04() throws UnsupportedEncodingException {
        String str = "尚";
        byte[] bytes = str.getBytes("ISO8859-1");
        System.out.println(Arrays.toString(bytes));//[63] 数据丢失
    }


    @Test
    public void test03() throws UnsupportedEncodingException {
        String str = "尚";
        byte[] bytes = str.getBytes("GBK");
        System.out.println(Arrays.toString(bytes));//[-55, -48]//两个字节，开头都是1，如果解析为整数是负数
    }
    @Test
    public void test02(){
        String str = "尚";
        byte[] bytes = str.getBytes();
        System.out.println(Arrays.toString(bytes));//[-27, -80, -102]
    }

    @Test
    public void test01(){
        String str = "hello";
        byte[] bytes = str.getBytes();
        System.out.println(Arrays.toString(bytes));//[104, 101, 108, 108, 111]
    }
}

八、字符串常用方法系列之六：判断开头和结尾

1、boolean startsWith(xx)：是否以xx开头
2、boolean endsWith(xx)：是否以xx结尾

public class TestStringMethod6 {
    @Test
    public void test02(){
        String str = "Hello.class";

        //判断某个文件是否是字节码文件
        System.out.println(str.endsWith(".class"));
    }

    @Test
    public void test(){
        String name = "张三峰";
        //判断是否以张开头
        System.out.println(name.startsWith("张"));
        //判断是否以张三开头
        System.out.println(name.startsWith("张三"));
    }
}

九、字符串常用方法系列之七：和正则判断有关

1、正则是什么？
文本数字的规则，格式。
例如：注册用户时，密码要求：必须有大写字母，小写字母，数字，并且个数6~16位之间。
手机号码：
粗略的：11位数字
详细一点：13,14,15,17,18,19,16
银行密码：6位数字
…
2、如何表示这些规则？使用正则表达式
正则表达式不是Java的东西。而是独立于任何编程语言的。
只能说Java也支持正则。
常见的：
表示0-9数字：\d 非数字：\D
表示空白字符：\s 非空白符：\S
表示单词字符：\w [a-zA-Z_0-9] 非单词字符：\W
表示任意字符：.

小写字母字符[a-z]：\p{Lower}
大写字母字符[A-Z]：\p{Upper}
所有ASCII字符：\p{ASCII}
所有字母：\p{Alpha}
空格和制表为：\p{Blank}
…

数量词：X是正则
X?：0次或1次
X*：0次或多次
X+：1次或多次
X{n}：正好n次
X{n,}：至少n次
X{n,m}：次数在[n,m]

逻辑：
|：表示或者

3、Java中如何判断是否匹配xx正则？
boolean matches(正则表达式)

public class TestStringMethod7 {

    @Test
    public void test6(){
        String password1 = "123456";
        String password2 = "ab123566";
        String password3 = "C1lin124";
        String password4 = "124#55Cin";
        String password5 = "12455Cin";
        //注册用户时，密码要求：必须有大写字母，小写字母，数字，并且个数6~20位之间。
        System.out.println(password1.matches("^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])[a-zA-Z0-9]{6,20}$"));//false
        System.out.println(password2.matches("^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])[a-zA-Z0-9]{6,20}$"));//false
        System.out.println(password3.matches("^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])[a-zA-Z0-9]{6,20}$"));//true
        System.out.println(password4.matches("^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])[a-zA-Z0-9]{6,20}$"));//false
        System.out.println(password5.matches("^(?=.*[A-Z])(?=.*[a-z])(?=.*[0-9])[a-zA-Z0-9]{6,20}$"));//true
    }

    @Test
    public void test5(){
        String password = "123456";
        //判断是否输入了6位数字
        System.out.println(password.matches("\\d{6}"));
    }


    @Test
    public void test4(){
        String str = " ";//空格一个字符，不是字母

        //是否全部由字母组成
        System.out.println(str.matches("\\p{Alpha}*"));//false  表示0个或多个字母
    }
    @Test
    public void test3(){
        String str = "";

        //是否全部由字母组成
        System.out.println(str.matches("\\p{Alpha}*"));//true  表示0个或多个字母
    }
    @Test
    public void test2(){
        String str = "hello123";

        //是否全部由字母组成
        System.out.println(str.matches("\\p{Alpha}*"));//false  表示0个或多个字母
    }
    @Test
    public void test(){
        String str = "hello";

        //是否全部由字母组成
        System.out.println(str.matches("\\p{Alpha}"));//false  表示1个字母
        System.out.println(str.matches("\\p{Alpha}*"));//true  表示0个或多个字母
    }
}

十、字符串常用方法系列之八：和替换有关

1、replace(old,new)：把old的字符替换为new的对应字符，不支持正则
2、replaceAll(正则，new)：根据正则替换字符串中的某些字符
3、replaceFirst(正则，new)：只替换第一次满足正则的部分

public class TestStringMethod8 {
    @Test
    public void test01(){
        String str = "hello12world89java90$$$cha(((";
        //里面的非字母去掉
        System.out.println(str.replaceAll("[^a-zA-Z]",""));//helloworldjavacha
        System.out.println(str.replaceFirst("[^a-zA-Z]",""));//hello2world89java90$$$cha(((
    }

    @Test
    public void test(){
        String str = "中国共产党是最优秀的党，中国共产党是执政党";
        System.out.println(str.replace("共产党","***"));
    }
}

十一、字符串的常用方法系列九：拆分

1、String[] split(正则)

public class TestStringMethod9 {
    @Test
    public void test02(){
        String str = "hello.world";
        String[] strings = str.split("\\.");//解释：.在正则中需要转义，\在Java中需要转义

        System.out.println(Arrays.toString(strings));
    }

    @Test
    public void test01(){
        String str = "hello|world";
        String[] strings = str.split("\\|");//解释：|在正则中需要转义，\在Java中需要转义

        System.out.println(Arrays.toString(strings));
    }

    @Test
    public void test(){
        String str = "张三:23;李四:24";

        //这个字符串拆分为两个学生的信息
        //：前面的是姓名，后面是年龄
        String[] students = str.split(";");
        for (int i = 0; i < students.length; i++) {
            String student = students[i];
            System.out.println(student);

            String[] strings = student.split(":");
            String name = strings[0];
            int age = Integer.parseInt(strings[1]);
            Student stu = new Student(name,age);
            System.out.println(stu);
        }

    }
}
class Student{
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

字符串String是字符序列，但是是不可变的字符序列。
在程序中经常需要拼接、修改等操作，如果这种操作频繁的话，String效率比较低。
这个时候JRE给我提供另外一种类型：可变字符序列,StringBuffer，或者称为字符串缓冲区。

java.lang.StringBuffer：

1、如何创建它的对象

new StringBuffer(xx);
new StringBuffer()

2、其他的操作

(1)StringBuffer append(xx)：在后面追加拼接
(2)StringBuffer insert(int index, String value)：在[index]位置插入Value
(3)deleteCharAt(index)：删除一个字符
delete(start,end)：删除[start,end)范围的字符
(4)repalce(int start, int end, String value)：替换[start,end)范围的字符
(5)reverse()：反转字符序列
(6)setCharAt(int index,char c)：替换[index]位置的字符为c
(7)setLength(int len)：设置字符缓冲区的长度为
…

3、如何StringBuffer实现可变字符序列？

(1)内部仍然使用char[]存储字符序列
(2)char[] value;没有final声明，意味着可以扩容等
(3)当char[]不够存储时，char[]会扩容

java.lang.StringBuilder：
JDK1.5引入的。
原来的StringBuffer是线程安全的.大多数情况下对可变字符序列的操作是单线程下完成的，或者是，StringBuffer的对象不是共享数据。
如果是这样的话，我们给方法加synchrornized，就多此一举，而且还会影响速度。
所以，引入StringBuilder类型，来代替StringBuffer在不需要考虑线程安全情况下使用，效率会更高。

StringBuilder和StringBuffer的API是完全一致。

public class TestStringBuffer {
    @Test
    public void test09() {
        StringBuffer s = new StringBuffer();//创建了一个长度为16的char[]数组
        s.append("hello").append("chailinyan").append("atguigu");
    }

    @Test
    public void test08() {
        /*
        有一个数组char[] arr = {'h','e','l','l','o'};反转字符数组
         */
        char[] arr = {'h','e','l','l','o'};
        //方案一：昨天讲过数组的反转
        //方案二：
        //(1)先把char数组转为字符串
        String str = new String(arr);
        //(2)把字符串转为StringBuffer
        StringBuffer s = new StringBuffer(str);
        //(3)调用方法，反转
        s.reverse();
        //(4)把StringBuffer转为字符串
        str = s.toString();
        //(5)再转为字符数组
        arr = str.toCharArray();
        System.out.println(Arrays.toString(arr));
    }



    @Test
    public void test07() {
        StringBuffer s1 = new StringBuffer("hello");
        s1.reverse();
        System.out.println(s1);//olleh
    }

    @Test
    public void test06() {
        StringBuffer s1 = new StringBuffer("hello");
        s1.replace(0,3,"world");
        System.out.println(s1);//worldlo
    }

    @Test
    public void test05() {
        StringBuffer s1 = new StringBuffer("hello");
        s1.deleteCharAt(0).delete(2,4);
        //s1.deleteCharAt(0)==>ello
        //?.delete(2,4); ==>el
        System.out.println(s1);//el
    }

    @Test
    public void test04(){
        StringBuffer s1 = new StringBuffer("hello");
        s1.insert(3,"world");
        System.out.println(s1);
    }

    @Test
    public void test03(){
        StringBuffer s = new StringBuffer();

        //拼接各种值
        s.append(1).append('a').append(1.3).append(true).append("hello");
        //s.append(1)返回结果仍然是StringBuffer的对象，可以继续调用StringBuffer的方法
        //并且这里返回的就是s对象自己

        System.out.println(s);
    }

    @Test
    public void test02(){
        StringBuffer s1 = new StringBuffer("hello");
        StringBuffer s2 = new StringBuffer("world");
//        System.out.println(s1 + s2);//错误的，只有基本数据类型支持+，或String类型支持+，其他类型无法支持+

        System.out.println(s1.append(s2));
    }

    @Test
    public void test(){
//        StringBuffer s = "hello";//左边是StringBuffer类型，右边是String类型，不能这样赋值

        StringBuffer s = new StringBuffer("hello");
    }
}

学习Java的唐唐

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
01.08_学习Java的day18(详解)

一、字符串的比较1、==比较（1）常量池中的两个字符串对象比较，只要内容相同，那么地址就相同，因为常量对象是共享的（2）其他==比较结果都是false。2、boolean equals(Object anObject)如果没有重写Object中equals，等价于=，String类重写了Object中的equals，比较字符串的字符内容。并且区分大小写如果自己实现，如何重写equal...
复制链接

扫一扫