【Java数据类型学习—

](https://img-home.csdnimg.cn/images/20220524100510.png#pic_center)
🌈个人主页: Aileen_0v0
🔥热门专栏: 华为鸿蒙系统学习|计算机网络|数据结构与算法
💫个人格言:“没有罗马,那就自己创造罗马~”

文章目录

- `打印字符串长度的两种方法`
- `字符串String的比较`
- - `1.==用于比较引用的对象是否指向同一个内存地址`
  - `2.用equal比较两个字符串的值是否一致`
  - `3.判断字符串的大小-compareTo`
  - `4.忽略大小写进行比较-compareToIgnoreCase和equalsIgnoreCase`
- `字符串常用于查找调用的方法及使用示例`
- `数据类型的转换`
- - 将整数转换成字符串
  - 其他类型转换
  - 大小写转换
  - 字符串转数组
  - 格式化输出
  - 字符串替换
  - 字符串的拆分
  - 字符串截取
  - 去掉字符串左右空格，保留中间空格通过 trim（）方法
  - 字符串的不可变性
  - stringBuffer & stringBulider的引入

在这里插入图片描述

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

        //①通过引用来打印字符串长度
        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类实现过程中就已经说明了。
- 字符串不可改变的原因是因为这个数组是被private修饰的，并且未提供get（）和set（）方法

在这里插入图片描述

通过对比上面的两段代码可得出：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()方法。

](https://img-home.csdnimg.cn/images/20220524100510.png#pic_center)