Java-String、编码-day12

最新推荐文章于 2021-05-25 17:55:49 发布

马彦龙plus

最新推荐文章于 2021-05-25 17:55:49 发布

阅读量128

点赞数 1

本文链接：https://blog.csdn.net/qq_45807045/article/details/108069107

版权

String

1.概念

最终类
java中所有字符串常量都是String类的对象
String类底层是根据不可改变字符数组来实现数据存储，
string类对象的内容无法改变（常量）
Java所有的常量都是在存储在方法区的运行时常量池类
当常量池中已经存在引用，如果后续有同名的引用那么共享一个引用（共享）
//创建了几个对象？5个对象
String str=“a”;//1
str+=“b”;//str=new StringBuilder(“a”).append(“b”).toString();//4
1 1 "ab"1 1

package cn.tedu.string;

public class StringDemo1 {
    public static void main(String[] args) {
        //字符串常量存储在方法区的运行时常量池中
        //s1指向方法区常量池
        String s1 = "ab";
        //s2指向堆内存
        String s2 = new String("ab");
        //当常量池中已经存在引用，如果后续有同名的引用那么共享同一个引用
        // s3和s1指向同一个常量池
        String s3 = "ab";
        //byte b=128-1;
        //当参与运算的都是常量那么在编译时期就会进行优化直接计算结果再进行赋值
        //String s4="ab";,s4和s1指向同一个常量池
        String s4 = "a" + "b";
        String s5 = "a";
        //s5=s5+"b";
        //有String类不能直接做拼接
        //所以底层是由  s5=new StringBuilder("a").append("b").toString();
        //toString方法底层是new一个新的String类对象返回
        //s5指向堆内存
        s5 += "b";

        //s1指向方法区，s2指向堆内存，地址值不一样
        System.out.println(s1 == s2);//false
        //s1和s3指向同一个常量池，地址值一样
        System.out.println(s1 == s3);//true
        //s1和s4指向同一个常量池，地址值一样
        System.out.println(s1 == s4);//true
        //s1指向方法区，s5指向堆内存，地址值不一样
        System.out.println(s1 == s5);//false
        //s2和s5指向不同的堆内存
        System.out.println(s2 == s5);//false
    }
}

2.StringBuilder与StringBuffer

从jdk1.0开始String类做拼接使用的是StringBuffer，安全可靠但是拼接效率较低。
从jdk1.5开始String类做拼接使用的是StringBuilder，不安全但是拼接效率较高。

3.重要方法

1.charAt（）：根据指定的下标返回字符串对象对应的字符
2.length（）：返回字符串对象数组的长度值
3.toCharArray（）：把字符串对象的内容转成字符数组
4.new String（char [] cs.int offset int ocount):指定字符数组内容
转成新的字符串对象

package cn.tedu.string;

public class StringDemo2 {
    public static void main(String[] args) {
        //
        String str="wdjvwhdv";
        //指代String类对象的下标来返回对应字符
        /*System.out.println(str.charAt(2));//可以获取字符串对象中任意一个字符

        //遍历字符串对象的内容
        //length()方法---返回字符串对象的长度值
        //length属性---返回数组长度值
        for(int i=0;i<str.length();i++){
            System.out.println(str.charAt(i));
        }*/

        //把String类对象的内容转成字符数组
        char[] cs=str.toCharArray();
        //把字符数组内容转成新的字符串对象
        //String s=new String(cs);
        //把字符数组指定内容转成新的字符串对象
        String s=new String(cs,1,3);
        //
        System.out.println(s);

    }
}

5，compareTo():根据字典比较来确定两个字符串对象的大小
6.compareToIgnoreCase():忽略大小写来进行字典比较

 //
       /* String str1="AbcsRg";
        String str2="abcsrg";

        //把两个字符串对象内容转到两个字符数组
        //根据对应位置的两个字符数组的字符求差值
        //如果差值不为0就当做返回值来返回，如果差值为0挪到下一位继续求差值
        //如果每个差值都为0，最后就以两个字符串对象的长度之差当做返回值来返回
        //如果方法返回值为正数，说明前面对象大于后面的对象
        //如果方法返回值为负数，说明前面对象小于后面的对象
        //如果方法返回值为0，说明前面对象和后面的对象的内容一致
        //根据字典比较来确定对象的大小关系
        System.out.println(str1.compareTo(str2));
        //可以忽略大小写比较
        System.out.println(str1.compareToIgnoreCase(str2));*/

7.concat():底层是根据数组扩容来拼接字符串，把指定字符串拼接到原串的末尾

 //
        String str="abc";
        //把指定字符串内容拼接到原串的末尾
        //底层是根据数组扩容来进行拼接
        //+和concat拼接的区别？
        // 1.底层实现不同  2.+可以拼接任意数据，但是concat只能拼接字符串
        System.out.println(str.concat("123"));

8.contains();判断指定内容是否是原串的子串

  //
        //String str="sdgvcd";
        //原串中连续区域---子串
        //判断指定内容是否是原串的子串
        //System.out.println(str.contains("dgvd"));

9.startsWith/endsWith:判断是否以子串来开头/结尾

//
        String str="1xxxxxxx.avi";
        //判断是否以子串来结尾
        //文件后缀  .doc    .txt   .zip
        System.out.println(str.endsWith(".avi"));
        //判断是否以子串来开头
        //火车  （G-高铁）、D（动车）、T（特快）、Z（直达）
        //车牌   （渝---重庆）、（川---四川）、（鲁---山东）
        //身份证号（前6位---户籍所在地）
        System.out.println(str.startsWith("1xxx"));

10.equals():根据字符串对象的地址值和内容来综合判断对象是否相等
11.equalsIgnoreCase():忽略大小写进行比较

package cn.tedu.string;

public class StringDemo5 {
    public static void main(String[] args) {
        //
        String str1="abc";
        String str2=new String("Abc");
        //instanceof---判断对象和类之间的关系
        //instanceof,左边是对象，右边是子类、本类、父类
        //对Object类里equals方法进行重写
        //重写之后根据对象的地址值以及对象的内容来综合判断
        System.out.println(str1.equals(str2));
        //忽略大小写进行比较---验证码
        System.out.println(str1.equalsIgnoreCase(str2));
    }
}

12.getBytes():把字符串对象内容转成字节数组
13.new String(byte[] bs,int offset,int length,CharSet charset):可以把字节数组部分
内容按照指定码表转成新的字符串对象

package cn.tedu.string;

import java.io.UnsupportedEncodingException;

public class StringDemo6 {
    public static void main(String[] args) throws UnsupportedEncodingException {
        //
        String str="订外卖";

        //把字符串对象内容转成字节数组
        //把字符串对象（字符形式）按照码表转成字节---编码
        byte[] bs=str.getBytes("gbk");
        //把字节数组转成新的字符串对象
        //根据指定码表把字节形式数据转成字符形式数据---解码
        //由于编码和解码使用的码表不一致产生乱码
       // String s=new String(bs,"gbk");
        //把字节数组的部分内容转成新的字符串对象
        String s=new String(bs,0,4,"gbk");
        //
        System.out.println(s);
    }
}

14.hashcode():计算哈希码值过程只和对象内容有关系

 /* //
        String str1="abc";
        String str2=new String("abc");

        //重写Object类里hashcode方法
        //哈希码值的计算过程只和对象的内容有关系
        System.out.println(str1.hashCode());
        System.out.println(str2.hashCode());*/

15.indexOf():根据指定内容返回在对象内容中的第一次出现下标值

  //
        String str="adsfbdsf";
        //返回指定内容第一次出现下标值
        //如果没有查找到返回-1
        System.out.println(str.indexOf("df"));
        //根据指定的起始下标（包含）来进行查找返回第一次出现的下标值
        System.out.println(str.indexOf("dsf",5));

编码

把文字转成数字—编码转换规律—码表
ASCII（阿斯克码表占一个字节）、ISO8859-1（西欧码表占一个字节）、
BIG5（中文繁体），GB2312（中文简体）—GBK（国标码占两个字节）、
Unicode编码体系（UTF-8（占3个字节）、UTF-16（占两个字节）等等）
在这里插入图片描述

练习：
1.给定字符串，返回字符串中小写英文字母、数字以及其他字符出现的个数

package cn.tedu.string;

public class StringText1 {
    public static void main(String[] args) {
        //
        String str="ehjf2683f- %1^";

        //给定统计变量
        int letter=0;//统计小写英文字母
        int number=0;//统计数字

        //遍历字符串
        for(int i=0;i<str.length();i++){
            //获取每个字符
            char c=str.charAt(i);

            //判断获取字符是否是小写英文字母
            //'a'---97   'A'---65   '0'---48
            if(c>='a'&&c<='z'){
                letter++;
            }
            //判断获取字符是否是数字
            if(c>='0'&&c<='9'){
                number++;
            }
        }

        //
        System.out.println("小写英文字母:"+letter+",数字:"+number+
                ",其他字符"+(str.length()-letter-number));
    }
}

2.给定字符串，对字符串中的数字进行求和

package cn.tedu.string;

public class StringText2 {
    public static void main(String[] args) {
        //
        String str="wvf347vv9shfbv0fdv3";

        //提供求和变量
        int sum=0;

        //遍历字符串
        for(int i=0;i<str.length();i++){
            //获取每个字符
            char c=str.charAt(i);

            //判断获取字符是否是数字
            if(c>='0'&&c<='9'){
                //差值就是数字真实值
                sum+=c-'0';//'3'-'0'
            }
        }

        //
        System.out.println(sum);

    }
}

3.给定字符串，对（获取）字符串中数字进行排序

package cn.tedu.string;

import java.util.Arrays;

public class StringText3 {
    public static void main(String[] args) {
        //
        String str="eqf4wqg90342tej45";

        //新建数组存储字符串对象中的数字
        char[] cs=new char[str.length()];

        //计数变量、代表数组下标
        int index=0;

        //遍历字符串
        for(int i=0;i<str.length();i++){
            //获取所有的字符
            char c=str.charAt(i);

            //判断获取的字符是否是数字
            if(c>='0'&&c<='9'){
                //把数字字符存储在新的数组中
                cs[index++]=c;
            }
        }

        //缩容---index（代表字符串对象中数字字符的个数）
        cs=Arrays.copyOf(cs,index);

        //数组排序
        Arrays.sort(cs);

        //输出
        System.out.println(Arrays.toString(cs));
    }
}

4.给定字符串，输出每个字符出现的次数（晚自习）
5.给定字符串数组,根据冒泡来进行排序（compareTo 晚自习）
String[] ss={“abc”,“def”,“ab”,“asf”,“bas”,“acb”};
6.给定字符串String str=“订外卖";，转成字节数组根据字节数组的部分内容
转成新的字符串对象，要求无论指定字节数组转成字符串对象的字节数多大，
保证新的字符串对象没有？（晚自习）
7.给定字符串，返回第一个字符出现的所有下标（indexOf 晚自习）