【Java数据类型学习——String】

ImAileen

发布于 2024-12-18 16:26:43

10700

代码可运行

文章被收录于专栏：Python数据结构与算法Python数据结构与算法

运行总次数：0

代码可运行

`打印字符串长度的两种方法`

        //①通过引用来打印字符串长度
        System.out.println(s1.length());

        //②通过String类型对象打印字符串长度
        System.out.println("Aileen".length());

`字符串String的比较`

`1.==用于比较引用的对象是否指向同一个内存地址`

        String s1 = new String("hello");
        String s2 = new String("world");
        String s3 = s1;//S3这个引用指向S1这个引用所指向的对象
        System.out.println(s3);
        System.out.println(s1 == s3);
        System.out.println(s1 == s2);

        String s1 = new String("hello");
        String s5 = new String("hello");
        System.out.println(s1 == s5);

`2.用equal比较两个字符串的值是否一致`

        System.out.println("-------------------------------------------");
        String s1 = new String("hello");
        String s5 = new String("hello");
        System.out.println(s1 == s5);
        System.out.println(s1.equals(s5));
        System.out.println("-------------------------------------------");

我们可以看到，当我们调用equals方法的时候，他就会被String进行重写（它原本是Object的equals方法），如上图所示，最后通过equals可以直接比较字符串的内容。

在Java中只要是直接赋值的字符串都会被放到一个字符串的常量池里面，但是如果值相等的话，它只会放一个。

`3.判断字符串的大小-compareTo`

与equals不同的是，equals返回的是boolean类型，而compareTo返回的是int类型。具体比较规则如下：
- 1.先按照字典次序比较大小，若出现不等的字符，直接返回这两个字符的大小差值。
- 2.如果前k个字符相等（K为两个字符长度的最小差值），返回值是两个字符串长度差值(相同输出0)。

①

public class Test {
    public static void main(String[] args) {
        //判断字符串大小
        String s6 = "hello";
        String s7 = "aaello";

        //s1 和 s2 比较大小 s1 > s2
        System.out.println(s6.compareTo(s7));
    }
   }

Java中，String类的compareTo方法用来比较两个字符串。它按照两个字符串的字典顺序去比较，比较规则是Unicode值。

因为h的Unicode值（104）大于a的（97），所以调用compareTo方法打印的结果是这两个Unicode值之差，结果是7。

②

        String s8 = "hello";
        String s9 = "helloAileen";
        System.out.println(s8.compareTo(s9));

`4.忽略大小写进行比较-compareToIgnoreCase和equalsIgnoreCase`

public class Test {

    public static void main(String[] args) {
        String s1 = new String("hello");
        String s2 = new String("Hello");

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

        System.out.println(s1.compareTo(s2));
        System.out.println(s1.compareToIgnoreCase(s2));
    }
 }

`字符串常用于查找调用的方法及使用示例`

①返回字符串对应下标的字符-charAt

        String s1 = new String("hello");
        char ch1 = s1.charAt(0);
        System.out.println(ch1);

       String s1 = new String("hello");
        char ch2 = s1.charAt(100);
        System.out.println(ch2);

②返回对应字符出现的下标位置，从头开始一个一个查。- indexOf

public class Test {
    public static void main(String[] args) {
        String s1 = new String("hello");
//        返回对应字符出现的下标位置，从头开始一个一个查
        int pos = s1.indexOf("l");
        System.out.println(pos);
        }
     }

③：从指定位置找某个字符出现的位置 - indexOf

//        从指定位置开始找某个字符出现的位置
        int index = s1.indexOf("l",0);
        System.out.println(index);

从一个字符串中找另一个字符串，下面例子就是从我的s1这个字符串中查找我的字符串“lo”的位置。

public class Test {
    public static void main(String[] args) {
        String s1 = new String("hello");
        int index1 = s1.indexOf("lo");
        System.out.println(index1);
		}
    }

④：从后往前找 - lastIndexOf

public class Test {

    public static void main(String[] args) {
        String s1 = new String("hello");

        int index = s1.lastIndexOf("l");
        System.out.println(index);

        int index2 = s1.lastIndexOf("o",4);
        System.out.println(index2);

        int index3 = s1.lastIndexOf("e",0);
        System.out.println(index3);

        int index4 = s1.lastIndexOf("l",2);
        System.out.println(index4);

    }
  }

`数据类型的转换`

将整数转换成字符串

序列化：将对象转化成字符串 反序列化：将字符串转换成对象

import com.sun.org.apache.bcel.internal.util.ClassStack;
class Student{
    public String name;
    public  int age;

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

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

public class Test {
    public static void main(String[] args) {
//  将整数转换成字符串
        String str = String.valueOf(1123);
        System.out.println(str);

//  序列化（将对象转换成字符串）与反序列化（将字符转换成对象）：
//      序列化：
        String str2  = String.valueOf(new Student("Aileen", 21));
        System.out.println(str2);

//        Ⅰ把字符串转换成整数
        int a = Integer.valueOf("87384");
        System.out.println(a + 6);

//        Ⅱ把字符串转换成整数  和I的功能基本一致 、
//        Integer是Java当中的包装类，其拥有更多的方法 使得我们可以通过调用这些方法直接完成转换
        int b = Integer.parseInt("123");
        System.out.println(b + 7);
    }

其他类型转换

同理，对于小数类型我们也可以使用这两种方法进行转换：

        double c = Double.valueOf("1");
        System.out.println(c + 0.05);

        double d = Double.parseDouble("9");
        System.out.println(d + 0.1);

大小写转换

public class Test {

    public static void main(String[] args) {
        String a = "hello";
        String b = "Aileen";
//        大写转换
        System.out.println(a.toUpperCase());
//        小写转换
        System.out.println(b.toLowerCase());
    }
  }

字符串转数组

public class Test {
    //字符串转数组
    public static void main(String[] args) {
        String name = "Aileen";
        char[] chars = name.toCharArray();
        for (char ch : chars) {
            System.out.println(ch);

        }
    }

Ⅰ.代码首先通过 name.toCharArray() 把字符串 “Aileen” 转换为字符数组 chars，即：{‘A’, ‘i’, ‘l’, ‘e’, ‘e’, ‘n’}。
Ⅱ.然后，for 循环依次取出 chars 数组中的每个字符，并将其赋值给变量 ch。
Ⅲ.在每次循环中，System.out.println(ch) 会打印出当前字符 ch。

格式化输出

public class Test {
    public static void main(String[] args) {
        String s = String.format("%d-%d-%d" , 2024,11,27);
        System.out.println(s);
    }

字符串替换

public class Test {

    public static void main(String[] args) {
        String str = "ababababbababbabaababaabbabdfcdf";

//      替换所有老字符为第二个参数
        String str1 = str.replace("ab","098");
        System.out.println(str1);

        String str2 = str.replace("a","A");
        System.out.println(str2);

        String str3 = str.replaceAll("df","Aileen");
        System.out.println(str3);

        String str4 = str.replaceFirst("ab","21");
        System.out.println(str4);

        System.out.println(str);
    }

字符串的拆分

public class Test {
//    字符串的拆分
    public static void main(String[] args) {
        String str = "hello Aileen you are so good.";
//        ①按照空格分割
        String[] ret = str.split(" ");
        for (int i = 0; i < ret.length; i++) {
            System.out.println(ret[i]);
        }
        System.out.println("====================================");
//        ②按照空格拆分成limit = 2组进行分割
        String[] limitret = str.split(" " , 2);
        for (int j = 0; j < limitret.length; j++) {
            System.out.println(limitret[j]);
        }
        System.out.println("*************************************");
//        特殊类型分割：
//        ③一些特殊符号：*，+，. 的分割按照转义字符进行分割：其前面需要加上"\\"
        String str1 = "192.186.1.1";
//        ④正则表达式的分割
        String[] address = str1.split("\\.",3);

        for (int k = 0; k < address.length; k++) {
            System.out.println(address[k]);

        }

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

        String str2 = "110\\1123\\1\\1";

        String[] rot = str2.split("\\\\");

        for (int l = 0; l < rot.length ; l++) {
            System.out.println(rot[l]);
        }

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

//        ⑤若一个字符串有多个分隔符，可以通过 | 进行连接
        String str3 = "name=Aileen&age=21";
        String[] infor = str3.split("=|&");
        for (int m = 0; m < infor.length; m++) {
            System.out.println(infor[m]);

        }
    }

通过循环遍历进行分割

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

//        ④通过多次分割的方式进行分割 - for循环
        String str4 = "name=Aileen&age=21";
        //多次分割
        String[] myinfo = str4.split("&");
        //分割后myinfo数组包含两个元素： [0]:name=Aileen  [1]:age=21
        for (String x : myinfo) {
//            通过新变量x获取myinfo数组的每一个元素
            String[] newinfo = x.split("=") ;
//            再将每一个元素用=分割，并存储在一个新的数组newinfo里面
            for (String ss : newinfo) {
//                最后通过变量ss遍历数组的每一个元素
                System.out.println(ss);

            }
        }

字符串截取

public class Test {

//    字符串截取
    public static void main(String[] args) {
        String str = "abcdef";
        String ret = str.substring(1,3);//左闭右开，取得1到2的元素
        System.out.println(ret);
    }

去掉字符串左右空格，保留中间空格通过 trim（）方法

        String str2 = "        Aileen is an excellent people.                      ";
        System.out.println(str2);
        String ret2 = str2.trim();
        System.out.println(ret2);

字符串的不可变性

String是一种不可变的对象，字符串中的内容是不可改变的，原因如下：

1.String类在设计时就是不可变的，String类实现过程中就已经说明了。

通过对比上面的两段代码可得出：final关键字保证是引用不可改变，而不是对象内容不可改变。在这个例子中，我们可以改变array数据库的内容，但不能将array指向新的数据库。

//    ---------------字符串修改---------------------
    public static void main15(String[] args) {
//        String s = "hello";
//        s += " world";// s 指向了新的对象
//        System.out.println(s);//hello world


        //通过反汇编将上面的代码转换成下面的代码：
        String s = "hello";
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append(s);
        stringBuilder.append(" world");
        s = stringBuilder.toString();
        System.out.println(s);
//        通过上面代码可得出：
        //String的 加号的拼接 会产生一些 临时的对像(stringBuilder)

    }

stringBuffer & stringBulider的引入

    public static void main(String[] args) {

        //Ⅰ.通过调用StringBuffer拼接字符串所消耗的时间
        long start = System.currentTimeMillis();
        StringBuffer sbf = new StringBuffer("");
        for(int i = 0; i < 100000; ++i){
            sbf.append(i);
        }

        long end = System.currentTimeMillis();
        System.out.println(end - start);

        //Ⅱ.通过调用StringBuilder拼接字符串所消耗的时间
        start = System.currentTimeMillis();
        StringBuilder sbd = new StringBuilder();
        for(int i = 0; i < 100000; ++i){
            sbd.append(i);
        }
        end = System.currentTimeMillis();
        System.out.println(end - start);

        //Ⅲ.通过循环语句拼接字符串所消耗的时间
        start = System.currentTimeMillis();//获取当前系统的时间戳
        String s = "";
        for(int i = 0; i < 100000; ++i){
            //以后不能在循环当中 这样去拼接字符串
            s += i;
        }
        end = System.currentTimeMillis();
        System.out.println(end - start);
    }

通过对比上面的三种字符串的拼接方式，我们可得到，在调用stringBuffer和stringBuilder对象及其append方法的时候，我们不会一直创建对象所以耗时较少，但如果是通过循环语句去拼接字符串就会不断地创建对象，每次循环都会不断地创造对象，这就导致消耗的时间大大增加。
所以字符串拼接要使用stringBuilder和stringBuffer的append方法。

方法	说明
StringBuffer append(String str)	在尾部追加, 相当于String的+=, 可以追加: boolean、char、char[]、double、float、int、long、Object、String、StringBuffer的变量
char charAt(int index)	获取index位置的字符
int length()	获取字符串的长度
int capacity()	获取底层保存字符串空间总的大小
void ensureCapacity(int minimumCapacity)	扩容
void setCharAt(int index, char ch)	将index位置的字符设置为ch
int indexOf(String str)	返回str第一次出现的位置
int indexOf(String str, int fromIndex)	从fromIndex位置开始查找str第一次出现的位置
int lastIndexOf(String str)	返回最后一次出现str的位置
int lastIndexOf(String str, int fromIndex)	从fromIndex位置开始找str最后一次出现的位置
StringBuffer insert(int offset, String str)	在offset位置插入: 八种基类类型&String类型&Object类型数据
StringBuffer deleteCharAt(int index)	删除index位置字符
StringBuffer delete(int start, int end)	删除[start,end)区间内的字符
StringBuffer replace(int start, int end, String str)	将[start,end)位置的字符替换为str
String substring(int start)	从start开始一直到末尾的字符以String的方式返回
String substring(int start, int end)	将[start,end)范围内的字符以String的方式返回
StringBuffer reverse()	反转字符串
String toString()	将所有字符按照String的方式返回

public static void main(String[] args) {
StringBuilder sb1 = new StringBuilder("hello");
StringBuilder sb2 = sb1;
// 追加：即尾插-->字符、字符串、整形数字
sb1.append(' '); // hello
sb1.append("world"); // hello world
sb1.append(123); // hello world123
System.out.println(sb1); // hello world123
System.out.println(sb1 == sb2); // true
System.out.println(sb1.charAt(0)); // 获取0号位上的字符 h
System.out.println(sb1.length()); // 获取字符串的有效长度14
System.out.println(sb1.capacity()); // 获取底层数组的总大小
sb1.setCharAt(0, 'H'); // 设置任意位置的字符 Hello world123
sb1.insert(0, "Hello world!!!"); // Hello world!!!Hello world123
System.out.println(sb1);
System.out.println(sb1.indexOf("Hello")); // 获取Hello第一次出现的位置
System.out.println(sb1.lastIndexOf("hello")); // 获取hello最后一次出现的位置
sb1.deleteCharAt(0); // 删除首字符
sb1.delete(0,5); // 删除[0, 5)范围内的字符
String str = sb1.substring(0, 5); // 截取[0, 5)区间中的字符以String的方式返回
System.out.println(str);
sb1.reverse(); // 字符串逆转
str = sb1.toString(); // 将StringBuffer以String的方式返回
System.out.println(str);
}

从上述例子可以看出：String和StringBuilder最大的区别在于String的内容无法修改，而StringBuilder的内容可以修改。
- 频繁修改字符串的情况考虑使用StringBuilder。
- 注意：String和StringBuilder类不能直接转换。如果要想互相转换，可以采用如下原则:
  - String变为StringBuilder: 利用StringBuilder的构造方法或append()方法
  - StringBuilder变为String: 调用toString()方法。

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2024-12-17，如有侵权请联系 cloudcommunity@tencent.com 删除

数据类型