【JavaSE】String类

已于 2022-04-15 14:46:50 修改
阅读量265 收藏
点赞数
分类专栏： JavaSE 文章标签： java 后端
于 2022-04-10 21:08:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61543874/article/details/123885163
版权

文章目录

前言

本文将重点介绍Java中常用类，并且重点介绍String类，在C语言中涉及过字符串，但其字符串的表示只能是使用字符数组或者字符指针，虽然可以使用标准库提供的字符操作函数完成一系列操作，但这种将数据和操作数据的方法分离开的方式不符合面对对象的思想，然而字符串的应用又十分广泛，因此Java提供了String类；在笔试，开发，面试中会遇到关于字符串的试题，所以我们要认真对待它。

String类

大家可以查看String类官方文档

String类的初始化

1.使用字符串常量直接初始化

格式：

String 变量名 = 字符串;

        //初始化为空，不指向任何对象
        String s1 = null;
        //初始化为空字符串
        String s2 = "";
        //初始化为常量字符串abc
        String s3 = "abc";

2.使用String的构造方法初始化

String类提供多种构造方法，常用的构造方法如下：

  1. String() 创建一个空字符串
  public String() {
        this.value = "".value;
    }
  1. **String(String value)**根据字符串内容初始化
    public String(String original) {
        this.value = original.value;
        this.hash = original.hash;
    }
  1. **String(char[] value)**根据字符数组内容初始化
    public String(char value[]) {
        this.value = Arrays.copyOf(value, value.length);
    }

        //创建一个空字符串
        String s1 = new String();
        //根据字符串内容初始化
        String s2 = new String("abc");
        //根据字符数组内容初始化
        char[] charArray = new char[] {'A', 'B','C'};
        String s3 = new String(charArray);

注：

  1. String是引用类型，其存储的是字符串的地址。

在这里插入图片描述
官方源码表面，String类有两个属性，我们以一段代码来理解它：

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

在这里插入图片描述
2. 在Java中""引起来的是引用类型

	    public static void main(String[] args) {
        System.out.println("Hello".length());//5
    }

String类的常用方法

String类在实际的开发应用非常广泛，因此灵活的使用String类是十分重要的，下面我们介绍常用的方法。

String对象的比较

  1. == 比较是否引用同一个对象

注：对于基本数据类型 == 比较的是变量的值，而引用类型 ==比较的是引用中的地址。

    public static void main(String[] args) {
        String s1 = new String("qaq");
        String s2 = new String("qaq");
        String s3 = new String("aza");
        String s4 = s1;
        //这里的s1和s2的内容虽然是一样但其两个字符串在堆上的地址不同
        System.out.println(s1 == s2);//false
        System.out.println(s2 == s3);//false
        System.out.println(s4 == s1);//true
        //这里的就是指向同一个字符串，其地址必然相同
        String ss1 = "qaq";
        String ss2 = "qaq";
        System.out.println(ss1 == ss2);//true
    }
  1. boolean equals(Object anObject) 方法：按照字典序比较

String类重写父类Object的equal()方法：

    public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        String s1 = new String("qaq");
        String s2 = new String("qaq");
        String s3 = new String("qaq");
        //s1,s2,s3引用的是不同对象
        System.out.println(s1 == s2);//false
        System.out.println(s2 == s3);//false
        //其内容相同
        System.out.println(s1.equals(s2));//true
        System.out.println(s2.equals(s3));//true
    }
  1. int compareTo(String s) 方法: 按照字典序进行比较

与equals不同的是，equals返回的是boolean类型，而compareTo返回的是int类型。比较方式：

  1. 先按照字典次序大小比较，如果出现不等的字符，直接返回这两个字符的大小差值
  2. 如果前k个字符相等(k为两个字符长度中的最小值)，返回值两个字符串长度差值
    public static void main(String[] args) {
        String s1 = new String("abc");
        String s2 = new String("aac");
        String s3 = new String("abc");
        String s4 = new String("abcdef");
        System.out.println(s1.compareTo(s2)); // 不同输出字符差值1
        System.out.println(s1.compareTo(s3)); // 相同输出 0
        System.out.println(s1.compareTo(s4)); // 前k个字符完全相同，输出长度差值 -3
    }
  1. int compareToIgnoreCase(String str) 方法：与compareTo方式相同，但是忽略大小写比较
    public static void main(String[] args) {
        String s1 = new String("Abc");
        String s2 = new String("aC");
        String s3 = new String("ABc");
        String s4 = new String("aBcDef");
        System.out.println(s1.compareToIgnoreCase(s2)); // 不同输出字符差值-1
        System.out.println(s1.compareToIgnoreCase(s3)); // 相同输出 0
        System.out.println(s1.compareToIgnoreCase(s4)); // 前k个字符完全相同，输出长度差值 -3
    }

字符串查找

String类提供的查找方法：
方法功能
char charAt(int index)返回index位置上字符，如果index为负数或者越界，抛出IndexOutOfBoundsException异常
int indexOf(int ch)返回ch第一次出现的位置，没有返回-1
int indexOf(int ch, intfromIndex)从fromIndex位置开始找ch第一次出现的位置，没有返回-1
int indexOf(String str)返回str第一次出现的位置，没有返回-1
int indexOf(String str, intfromIndex)从fromIndex位置开始找str第一次出现的位置，没有返回-1
int lastIndexOf(int ch)从后往前找，返回ch第一次出现的位置，没有返回-1
int lastIndexOf(int ch, intfromIndex)从fromIndex位置开始找，从后往前找ch第一次出现的位置，没有返回-1
int lastIndexOf(String str)从后往前找，返回str第一次出现的位置，没有返回-1
int lastIndexOf(String str, intfromIndex)从fromIndex位置开始找，从后往前找str第一次出现的位置，没有返回-1
    public static void main(String[] args) {
        String s = "aaabbbcccaaabbbccc";
        System.out.println(s.charAt(3)); // 'b'
        System.out.println(s.indexOf('c')); // 6
        System.out.println(s.indexOf('c', 10)); // 15
        System.out.println(s.indexOf("bbb")); // 3
        System.out.println(s.indexOf("bbb", 10)); // 12
        System.out.println(s.lastIndexOf('c')); // 17
        System.out.println(s.lastIndexOf('c', 10)); // 8
        System.out.println(s.lastIndexOf("bbb")); // 12
        System.out.println(s.lastIndexOf("bbb", 10)); // 3
    }

字符串的转化

  1. 数值和字符串转化
    public static void main(String[] args) {
        String s1 = String.valueOf(1234);
        String s2 = String.valueOf(12.34);
        String s3 = String.valueOf(true);
        String s4 = String.valueOf(new A("ad",12));
        System.out.println(s1);//1234
        System.out.println(s2);//12.34
        System.out.println(s3);//true
        System.out.println(s4);//Package.A@1b6d3586
    }
  1. 大小写转化
    public static void main(String[] args) {
        String s1 = "QAQ";
        String s2 = "qaq";
        System.out.println(s1.toLowerCase());
        System.out.println(s2.toUpperCase());
    }
  1. 字符串转数组
    public static void main(String[] args) {
        //字符串转数组
        String s = "knight";
        char[] ch = s.toCharArray();
        System.out.println(Arrays.toString(ch));//[k, n, i, g, h, t]
        //数组转字符串
        String s2 = new String(ch);
        System.out.println(s2);//knight
    }
  1. 格式化
    public static void main(String[] args) {
        String s = String.format("%d-%d-%d", 2022, 4, 9);
        System.out.println(s);
    }

字符串的替换和去除空格

使用一个指定的新的字符串替换掉已有的字符串数据，可用的方法如下：
方法功能
String replaceAll(String regex, String replacement)替换所有的指定内容
String replaceFirst(String regex, String replacement)替换首个内容
String replace(char oldChar, char newChar)替换所以的指定内容
去除字符串中首尾的空格
方法功能
String trim()去除字符串中首尾的空格
    public static void main(String[] args) {
        String s = "  www.4399.com  ";
        System.out.println(s.trim());//www.4399.com
        System.out.println(s.replaceFirst(".","-"));//- www.4399.com  
        System.out.println(s.replace(".","-"));//  www-4399-com  
        System.out.println(s.replaceAll("-","."));//  www.4399.com  
    }

字符串的拆分

将一个完整的字符串按照指定的分隔符划分为若干个子字符串
方法功能
String[] split(String regex)将字符串全部拆分
String[] split(String regex, int limit)将字符串以指定的格式，拆分为limit组
  • 将字符串全部拆分
    public static void main(String[] args) {
        String s = "That is What I Like";
        String[] ret = s.split(" ");
        for (String str : ret) {
            System.out.println(str);
        }
    }
  • 字符串以指定的格式，拆分为limit组
    public static void main(String[] args) {
        String s = "That is What I Like";
        String[] ret = s.split(" ",2);
        for (String str : ret) {
            System.out.println(str);
        }
    }

注：

  1. 字符"|","*","+"都得加上转义字符，前面加上 “\\” .
  2. 而如果是 “\” ，那么就得写成 “\\\\” .
  3. 如果一个字符串中有多个分隔符，可以用"|"作为连字符.

示例：拆分IP地址

    public static void main(String[] args) {
        String str = "192.168.1.1" ;
        String[] result = str.split("\\.") ;
        for(String s: result) {
            System.out.println(s);
        }
    }

示例：多次拆分

    public static void main(String[] args) {
        String str = "name=zhangsan&age=18" ;
        String[] result = str.split("&") ;
        for (int i = 0; i < result.length; i++) {
            String[] temp = result[i].split("=") ;
            System.out.println(temp[0]+" = "+temp[1]);
        }
    }

字符串判断

方法功能
boolean contains(CharSequence s)当且仅当此字符串包含指定的char值序列时才返回true
boolean endsWith(String suffix)判断此字符串是否以指定的后缀结尾
boolean startsWith(String prefix)判断此字符串是否以指定的前缀开头
boolean isEmpty()返回 true当且仅当length()为 0
    public static void main(String[] args) {
        String s = "qaQs";
        System.out.println(s.isEmpty());//false
        System.out.println(s.startsWith("q"));//true
        System.out.println(s.endsWith("a"));//false
        System.out.println(s.contains("aQ"));//true
    }

字符串截取

方法功能
String substring(int beginIndex)从指定索引截取到结尾
String substring(int beginIndex, int endIndex)截取部分内容

注：这里的范围是左闭右开

    public static void main(String[] args) {
        String s = "2022-4-9";
        System.out.println(s.substring(4));//-4-9
        System.out.println(s.substring(0,4));//2022
    }

字符串常量池

常量池

在Java程序中，类似于1，2，120，”hello“等字面常量经常被使用，为了使程序运行速度更快，更节省内存，Java为基本数据类型和String类提供了常量池。

"池"是为了提高效率的方式，还有”内存池“，”线程池“，”数据库连接池“…

概念：
  1. Class文件常量池: .Java文件编译生成.Class文件中会保存当前类的字面常量以及符号信息
  2. 运行时常量池：当程序把编译好的字节码文件中的常量池加载到JVM中后，就形成了运行时常量池。
  3. 字符串常量池：主要存放的是字符串常量，本质上是一个固定大小的HashTable(一种高效查找的数据结构)

注：

  1. 在JVM中字符串常量池只有一份，是全局共享的
  2. 刚开始字符串常量池是空的，随着程序不断运行，字符串常量池中元素会越来越多
  3. 当类加载时，字节码文件中的常量池也被加载到JVM中，称为运行时常量池，同时会将其中的字符串常量保存在字符串常量池中
  4. 字符创常量池中的内容：一部分来自运行时常量池，一部分来自程序动态添加

String对象创建

  1. 直接使用字符串常量进行赋值
    public static void main(String[] args) {
        String str1 = "hello";
        String str2 = "hello";
        System.out.println(str1 == str2);
    }

在字节码文件加载时，会将.Class文件中的常量池加载到内存中形成运行时常量池，所以此时"hello"字符常量保存到字符串常量池中.
在这里插入图片描述

解释：

创建s1时发现该字符串在常量池中，所以直接把该字符串引用赋值给s1;s2同样的道理

  1. 使用new创建对象
    public static void main(String[] args) {
        String str1 = "hello";
        String str2= new String("hello");
        System.out.println(str1 == str2);
    }

在这里插入图片描述

  1. intern方法

intern 是一个native方法(Native方法指：底层使用C++实现的，看不到其实现的源代码)，该方法的作用是手动将创建的String对象添加到常量池中.

  1. 常量和变量的编译方式不同
    public static void main(String[] args) {
        String s1 = "Hello";
        String s2 = "Hel" + "lo";//常量在编译时其内容已经确定，所以会直接放入常量池
        System.out.println(s1 == s2);

        String s3 = "Hel";
        String s4 = "lo";
        String s5 = s3 + s4;//变量在编译时不知道其内容
        System.out.println(s1 == s5);
    }
  1. 面试题：请解释String类中两种对象实例化的区别

JDK1.8中

  1. String str = “hello”
    只会开辟一块堆内存空间，保存在字符串常量池中，然后str共享常量池中的String对象
  2. String str = new String(“hello”)
    会开辟两块堆内存空间，字符串"hello"保存在字符串常量池中，然后用常量池中String对象给新开辟的String对象赋值。
  3. String str = new String(new char[]{‘h’, ‘e’, ‘l’, ‘l’, ‘o’})
    现在堆上创建一个String对象，然后利用copyof将重新开辟数组空间，将参数字符串数组中内容拷贝到String对象中.

字符串的不可变性

我们知道字符串是被final修饰的意味着其指向不能改变，例：

        final int[] arr = {1,2,3};
        arr = new int[]{1,2,3,4};

被final修饰的数组其指向就不能改变了。

String类中的字符实际保存在内部维护的value字符数组中，所以：
  1. String类被final修饰，表明该类不能被继承。
  2. value被final修饰，表明value自身的值不能改变，即不能引用其它字符数组，但是其引用空间中的内容可以修改
  3. final修饰类表明该类不想被继承，final修饰引用类型表明该引用变量不能引用其他对象，但是其引用对象中的内容是可以修改的

StringBuilder和StringBuffer

StringBuilder的介绍

由于String的不可更改特性，为了方便字符串的修改，Java中又提供StringBuilder和StringBuffer类。这两个类大部分功能是相同的，这里介绍 StringBuilder常用的一些方法，其它需要用到了大家可参阅 StringBuilder在线文档

方法说明
StringBuff append(String str)在尾部追加，相当于String的+=，可以追加：boolean、char、char[]、double、float、int、long、Object、String、StringBuff的变量
char charAt(int index)获取index位置的字符
int length()获取字符串的长度
int capacity()获取底层保存字符串空间总的大小
void ensureCapacity(int mininmumCapacity)扩容
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最后一次出现的位置
StringBuff 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(531);//Hello world531
        System.out.println(sb1);//Hello world531
        System.out.println(sb1 == sb2);//true
        System.out.println(sb1.charAt(1));//获取指定位置字符
        System.out.println(sb1.length());//获取字符串长度
        System.out.println(sb1.capacity());// 获取底层数组的总大小
        sb1.setCharAt(6,'W');//修改任意位置字符
        sb1.insert(0,"hihihi");//在指定位置插入
        System.out.println(sb1);
        System.out.println(sb1.indexOf("hi"));//获取hi第一次出现的下标
        System.out.println(sb1.lastIndexOf("hi"));//获取hi最后一次出现的下标
        sb1.deleteCharAt(0);//删除指定位置字符
        sb1.delete(0,5);//删除指定范围字符

        String s = sb1.substring(0,5);//截取[0, 5)区间中的字符以String的方式返回
        System.out.println(s);
        sb1.reverse();//字符串逆转
        s = sb1.toString();//将StringBuffer以String的方式返回
        System.out.println(s);
    }

String和StringBuilder最大的区别在于String的内容无法修改，而StringBuilder的内容可
以修改

注：String类和StringBuilder类不能直接转换。如果要想互相转换，可以采用如下原则:

  • String变为StringBuilder: 利用StringBuilder的构造方法或append()方法
  • StringBuilder变为String: 调用toString()方法

String、StringBuffer、StringBuilder的区别

  • String的内容不可修改，StringBuffer与StringBuilder的内容可以修改.
  • StringBuffer与StringBuilder大部分功能是相似的
  • StringBuffer采用同步处理，属于线程安全操作；而StringBuilder未采用同步处理，属于线程不安全操作

Math类和Random类

Marh类

提供数学运算的一系列方法，其中有两个静态常量PI，E代表数学中的Π和e
|方法 |功能 |
|–|--|
double abs(double a)|返回一个double值的绝对值
double ceil(double a)|返回大于或等于参数的最小（最接近负无穷大） double值，并等于数学整数。
double floor(double a)|返回小于或等于参数的最大（最接近正无穷大） double值，等于数学整数。
int round(float a)|返回参数最接近的int ，其中int四舍五入为正无穷大。
double log10(double a)|返回一个double的基数10对数值
double sqrt(double a)|返回double值正确舍入的正平方根
double pow(double a,double b)|将第一个参数的值返回到第二个参数的幂

    public static void main(String[] args) {
        System.out.println(Math.abs(-1));//绝对值-> 1
        System.out.println(Math.ceil(-5.8));//向上取整 -> -5.0
        System.out.println(Math.floor(-5.2));//向下取整 -> -6.0
        System.out.println(Math.round(4.5));//四舍五入 -> 5
        System.out.println(Math.log10(120));//2.0791812460476247
        System.out.println(Math.sqrt(250));//15.811388300841896
        System.out.println(Math.pow(2,4));//16.0
    }

Random类

构造方法：
方法功能
Random()
Random(long seed)使用单个long种子创建新的随机数生成器
普通方法：
方法功能
double nextDouble()随机生成double类型的数据
int nextInt()随机生成int类型的数据
int nextInt(int bound)随机生成（0，bound]的int类型的数据
boolean nextBoolean()随机生成boolean类型的数据
long nextLong()随机生成long类型的数据
    public static void main(String[] args) {
        Random r = new Random();
        System.out.println(r.nextInt());
        System.out.println(r.nextInt(10));
        System.out.println(r.nextBoolean());
        System.out.println(r.nextDouble());
        System.out.println(r.nextLong());
    }

包装类

在万物皆对象的Java中，基本数据类型不是对象，为了满足万物皆对象的理念就需要对基本数据类型的变量进行打包封装处理变成对象，而负责将这些变量声明为成员变量进行对象化处理的相关类，叫做包装类。

Java中的八种包装类

在这里插入图片描述

  1. 常用的方法

在这里插入图片描述

  1. 装箱和拆箱的概念

装箱： 在上述编写的方法中可以实现从int类型到Integer类型的转换，Integer类实际上是int类的包装类，我们把这种从int类型到Integer类型的转换过程，我们把他叫做装箱。什么叫做装箱？装箱的概念就是把箱子。我要想把int类型变成Integer类型实际上就需要把箱子打开，Integer打开把int类变成integer类的成员变量，这样相当于打包好了，实际上这个过程就叫做装箱。
拆箱： 所有把Integer打开，把里面的数据拿出来这个过程叫做拆箱。

Zzt.opkk
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【Java常用类】String
翱翔于世纪的博客
04-26 208
一、定义 String类创建的实例是字符串,代表不可变的字符序列。 Java程序中的所有字符串文字（例如"abc" ）都被实现为此类的实例。 字符串不变; 它们的值在创建后不能被更改。 String str = "abc"; 二、常用方法 Ⅰ.构造方法： String(String original) 初始化新创建的String对象，使其表示与参数相同的字符序列; 换句话说，新创建的字符串是参...
关于Java中创建String的两种方式
inkynmo的博客
04-15 1160
如果存在，就无需开辟新的内存空间，直接使用；创建new关键字方法缺点：每次创建变量都需要开辟一个新的空间，相比直接赋值，可能会造成地址滥用。比如之前创建s1，时间一长，忘记该变量，再创建相同用法的s2，s1与s2用法和赋值一样，但由于使用new关键词创建，则需开辟两块内存空间，但如果是直接赋值则一定程度上避免此浪费。此方法通过传递一个字节数组构建形成一个字符串，一般要将字节信息进行转换，转成字符串，使用此结构。创建过程看似十分笨拙，但使用方面十分灵活，可以通过修改数组，来进一步修改字符串的长度或者内容。
String字符串为空
你越努力，你的运气就会越好
03-17 1833
String字符串中的一个误区str==null ||str.equals("")) (注意顺序) 说明： 如果str==null说明str还未定义内容。此时，谈不上是否为空。 str=""，说明str是个空字符串。只不过长度为0。 1 String s; 2 if(s==null) { 3 //为null; 4 } 5
创建一个空的String数组，向其中添加元素
qq_43511677的博客
08-12 1万+
//for(int i = 0; i < list.size(); i++) { //Object[] object = list.get(i); String[] xLine={}; xLine= insert(xLine, object[2].toString()); private static String[] insert(String[] arr, String str) { int size = a
Java中字符串定义，初始化，赋值为null的区别
HelloWorld搬运工
07-10 5万+
1、概述： 字符串定义 只定义不分配内存空间，不做任何操作； 字符串初始化 两种方式直接等号赋值，用new初始化，直接等号赋值放入内存池，其它变量也可以引用；new初始化分配内存空间，不可引用； 字符串赋值为null 初始化了，并且有了引用，但是没有指向任何内存空间； 2、详解： String s;和String s=null;和String s="a";有什么区别？ 第一个...
JavaSE之StringBuilder类与String类
07-21
这个文件里的内容适合Java初学者，String类为引用类，不属于基本数据类型，但是String类非常的重要，在后边学习的JavaSE中，几乎使用的全是String类，这个文件里边包含了对String字符串的拆分、拼接以及怎么声明进行...
JavaSE之日期时间类
07-21
JavaSE中的日期时间类是编程中非常基础且重要的部分，主要涉及到`java.util.Date`类和`java.text.SimpleDateFormat`类。下面将详细讲解这两个类的使用及其相关知识点。 首先，`java.util.Date`类用于表示特定的瞬间...
javaSE基础，String
08-24
1 掌握字符串的创建方式 2 熟练使用字符串的常用方法 3 掌握StringBuilder的基本使用和常用方法
JavaSE之数组与集合类
07-21
在这个话题中，我们将探讨Java中的数组和集合类，这些都是JavaSE阶段的重要知识点。 首先，让我们从面向对象编程说起。面向对象编程（OOP）是Java语言的基础，与面向过程编程不同，后者关注的是执行步骤，而OOP更...
黑马程序员Javase笔记
01-18
Map是一个键值对的数据结构，可以嵌套使用，例如`HashMap<String, HashMap<String, String>>`。同时，可以使用匿名内部类创建自定义的比较器来定制排序规则。 总结来说，"黑马程序员Javase笔记"涵盖了Java的基础...
一个完整的括号字符串定义规则如下: 1、空字符串是完整的。 2、如果s是完整的字符串，那么(s)也是完整的。 3、如果s和t是完整的字符串，将它们连接起来形成的st也是完整的。
易大飞
04-09 2034
一个完整的括号字符串定义规则如下: 1、空字符串是完整的。 2、如果s是完整的字符串，那么(s)也是完整的。 3、如果s和t是完整的字符串，将它们连接起来形成的st也是完整的。 例如，"(()())", ""和"(())()"是完整的括号字符串，"())(", "()(" 和 ")"是不完整的括号字符串。 牛牛有一个括号字符串s,现在需要在其中任意位置尽量少地添加括号,将其转化为一个完整的
NULL、空格串、空字符串、0的区别和NULL详解及拓展
猴子姑娘呀的博客
09-05 2万+
NULL、空格串、空字符串、0，‘\0’的区别和NULL详解 在网上查阅并整合了一些资料，供自己学习，同时也希望能帮到大家！ 一、空字符串、NULL、空格串的区别： （1）先附上代码，来表示它们的区别：         string str1=””;  // 空字符串  str1.length( )= 0         string str
python定义空字符串_Python基础:数据类型-字符串：string
weixin_39700220的博客
11-24 1760
一、字符串：string定义：1、单引：''2、双引："" 可以包含单引多行字符串,所见即所得模式,用三个引号。3、三个单引：''' '''4、三个双引：""" """ 可以包含单引号str="""我是所见即所得模式我需要顶格写特殊字符不用转义:~!@#$%^&*()''"/,. table: ,空格： ."""print(str)5、转义符\：单引下,使用特殊字符要使用转义符,常用的转...
java中String值为空字符串与null的判断方法
热门推荐
wilson_m的博客
01-21 8万+
Java空字符串与null的区别 1、类型        null表示的是一个对象的值，而不是一个字符串。例如声明一个对象的引用，String a=null。        “”表示的是一个空字符串，也就是说它的长度为0。例如声明一个字符串String s=”“。 2、内存分配        String a=null；表示声明一个字符串对象的引用，但指向为null，也就是说还没
C++之空字符串
10-30 1万+
C#中定义一个空字符串，非常简单 C++中通过string定义空字符串也是非常简单 但是，，如果想通过char *定义一个空字符串，如何呢？ 突然被这个问题难道了。。。。。 下面这种方式可以么？ char * pA = ""; 结果编译出错 然后我又想写个空字符串，然后赋值给他，结果又编译出错 string strEmpty = ""; char * pA = str...
java中怎样建一个空字符串_java-空字符串的Optional实现
weixin_29231263的博客
02-26 4111
尝试一些事情来解决您的目标,然后意识到我会从VGR那里接受想法,因为与使用现有方法相比,实现这种用例是很多额外的工作.但是,在花一些时间查看实现之后,我可以添加的细节很少-作为实用程序,您可以实现一个静态实现,该实现将验证字符串输入的null和isEmpty条件,并相应地返回Optional.该代码可能看起来像-private static Optional ofEmptyable(String ...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 446
1.导入hutool的maven依赖。2.复制一下代码执行。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Zzt.opkk

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值