在 Java 中检查字符串是否包含不区分大小写的子串

本教程介绍如何在 Java 中检查或查找字符串是否包含子字符串。

String 是一个字符序列,有时也称为字符数组。在 Java 中,String 是一个处理所有与字符串相关的操作并提供实用方法的类。

本文演示如何在字符串中查找子字符串。

子字符串是字符串的一部分,也是字符串。它可以有一个或多个字符。

不区分大小写的字符串是不关心字母的小写或大写的字符串。让我们通过一些例子来理解。

在 Java 中的字符串中查找不区分大小写的子字符串

在这个例子中,我们使用了 Pattern 类及其 compile()matcher()find() 方法来检查字符串是否包含子字符串。我们使用了 CASE_INSENSITIVE,它返回一个布尔值,truefalse

请参见下面的示例。

import java.util.regex.Pattern;
public class SimpleTesting{
	public static void main(String[] args){
		String str = "DelftStack";
		String strToFind  = "St";
		System.out.println(str);
		boolean ispresent = Pattern.compile(Pattern.quote(strToFind), Pattern.CASE_INSENSITIVE).matcher(str).find();
		if(ispresent)
			System.out.println("String is present");
		else System.out.println("String not found");
	}
}

输出:

DelftStack
String is present

在 Java 中使用 StringUtils 在字符串中查找不区分大小写的子字符串

使用 Apache 公共库,你可以使用 StringUtils 类及其 containsIgnoreCase() 方法来查找子字符串。请参见下面的示例。

你必须将 Apache 公共 JAR 添加到你的项目中才能执行此代码。

import org.apache.commons.lang3.StringUtils;
public class SimpleTesting{
	public static void main(String[] args){
		String str = "DelftStack";
		String strToFind  = "St";
		System.out.println(str);
		boolean ispresent = StringUtils.containsIgnoreCase(str, strToFind);
		if(ispresent)
			System.out.println("String is present");
		else System.out.println("String not found");
	}
}

输出:

DelftStack
String is present

在 Java 中使用 contains() 方法查找字符串中不区分大小写的子字符串

在这个例子中,我们使用了 String 类的 contains() 方法,如果子字符串存在则返回 true。我们使用 toLowerCase() 首先将所有字符转换为小写,然后传递给 contains() 方法。

请参见下面的示例。

public class SimpleTesting{
	public static void main(String[] args){
		String str = "DelftStack";
		String strToFind  = "St";
		System.out.println(str);
		boolean ispresent = str.toLowerCase().contains(strToFind.toLowerCase());
		if(ispresent)
			System.out.println("String is present");
		else System.out.println("String not found");
	}
}

输出:

DelftStack
String is present

在 Java 中使用 matches() 方法查找字符串中不区分大小写的子字符串

在这个例子中,我们使用了 String 类的 matches() 方法,如果子字符串存在则返回 true。它将正则表达式作为参数。

请参见下面的示例。

public class SimpleTesting{
	public static void main(String[] args){
		String str = "DelftStack";
		String strToFind  = "St";
		System.out.println(str);
		boolean ispresent = str.matches("(?i).*" + strToFind+ ".*");
		if(ispresent)
			System.out.println("String is present");
		else System.out.println("String not found");
	}
}

输出:

DelftStack
String is present

在 jQuery 中检查字符串是否包含子字符串

jQuery 中的 contains() 方法可以检查一个 DOM 元素是否包含另一个 DOM 元素。本教程演示了如何在 jQuery 中使用 contains() 方法。

使用 contains() 方法检查字符串是否包含 jQuery 中的子字符串

jQuery contains() 方法检查字符串是否包含子字符串或字符。此方法的语法是:

jQuery.contains( container, contained )

其中,

  1. container 是包含另一个 DOM 元素的 DOM 元素,并且
  2. 子元素中的 contained

该方法返回一个布尔值。

contains() 的语法也可以写成:

container:contains(contained)

让我们尝试一个例子:

<!DOCTYPE html>
<html>
<head>
    <title> jQuery Contains Method </title>
    <script src="https://code.jquery.com/jquery-3.4.1.js"></script>
    <script>
    $(document).ready(function(){
        $("p:contains(is)").css("background-color", "lightgreen");
    });
    </script>
</head>
<body>
    <h1>Welcome to Delfstack</h1>
    <p>DelftStack is a resource for everyone interested in programming,.</p>
    <p>embedded software, and electronics. It covers the programming languages like</p>
    <p> Python, C/C++, C#, and so on in this website's first development stage</p>
</body>
</html>

上面的代码将检查段落元素中的字符串是否包含子字符串或字符,并更改该段落的背景颜色。见输出:

在 jQuery 中检查字符串是否包含子字符串

这个方法还可以告诉我们某个 HTML 元素是否包含另一个元素。请参见下面的示例:

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <title>JQuery contains() method</title>
    <script src= "https://code.jquery.com/jquery-3.4.1.js"> </script>
</head>
<body>
    <h3>JQuery contains() method</h3>
    <b id="delftstack"></b>
    <script>
        $("#delftstack").append( "Does 'document.body' contains 'document.documentElement'? <br>"
            + $.contains(document.documentElement, document.body));
    </script>
</body>
</html>

上面的代码将检查文档正文是否包含某些元素,如果包含,该方法将返回 true。见输出:

在 jQuery 中检查字符串是否包含子字符串

在 JavaScript 中检查字符串是否包含子字符串

本教程讲解如何在 JavaScript 中检查字符串是否包含子字符串。

这是一个简单而常见的任务,但是不同的语言以不同的方式处理它。我们将看到 JavaScript 中的内置方法和自定义编写的方法来实现上述目标。

在 JavaScript 中使用正则表达式检查字符串是否包含子字符串

它是检查子字符串是否存在的最强大,最传统的方法之一。与内置方法相比,它为我们提供了很大的灵活性,因为使用 JavaScript 内置方法,我们只能检查常量字符串,而不能更改其行为的区分大小写。我们将使用 RegExp.test() 方法检查字符串中的子字符串。

let str = 'delftstack';
console.log(/stack/.test(str));

输出:

true

这里我们使用 .test() 函数来查看字符串 delftstack 中是否存在子字符串 stack 并得到 true 的结果。

但是正则表达式的优点在于我们可以执行不区分大小写的搜索,而内置的 JavaScript 方法是不可能做到的,我们甚至可以在不知道它是什么的情况下寻找固定长度的数字子字符串这样的模式。

let str = 'delftstack';
console.log(stack/i.test(str));

输出:

true

我们将 i 附加到表达式/stack/上,然后可以进行不区分大小写的搜索。

在 JavaScript 中使用 String.includes() 检查字符串是否包含子字符串

ES6 引入了 .includes() 函数,该函数可帮助我们检查字符串中是否存在给定的子字符串。它返回一个布尔值,以 truefalse 表示存在。这是区分大小写的方法,因此,如果子字符串 Ss 匹配,它将返回 false

此方法有 2 个参数:第一个是子字符串,第二个是我们要从其开始在字符串内搜索的索引。如果第二个参数在左边界之外,即小于 0,则 JavaScript 从索引 0 开始搜索。如果它大于字符串的长度,则直接返回 false。

const str = "delftstack";
const substr = "stack";
console.log(str.includes(substr));

输出:

true

在上面的代码中,我们将子字符串传递给函数,并且由于字符串 delftstack 中存在 stack,因此它返回 true

const str = "delftstack";
const substr = "stack";
console.log(str.includes(substr,4));

输出:

true

该代码从第五索引开始搜索 stack 一词。

使用 String.indexOf() 检查 JavaScript 中的字符串是否包含子字符串

在 ES6 引入 String.includes() 方法之前,唯一的内置方法是 .indexOf()。它与 String.includes() 方法非常相似。如果子字符串存在于给定的字符串内,则此方法将返回子字符串的第一个字符的索引,而不是返回布尔值;如果子字符串不存在,则返回 -1

const str = "delftstack";
const substr = "stack";
console.log(str.indexOf(substr)!=-1);

输出:

true

它可能很旧,但是更精确,因为它可以像 .includes() 一样使用,只需在函数的结果上添加检查以查看其是否等于 -1 即可。与 .includes() 不同,它向我们返回了子字符串开头的确切索引,并且可以有更多的实际意义。

所有主流浏览器均支持除 String.includes() 之外的所有上述方法。String.includes() 由 ES6 引入,但 Internet Explorer 仍不支持。实现此目的的另一种方法是使用 KMP(Knuth-Morris-Pratt)算法,这是一种具有广泛应用的 O(n) 算法。它本身就是一个巨大的话题,我们将在以后的文章中讨论。

在 JavaScript 中检查字符串是否为数字

编程语言中的数字是表示整数、浮点数等的数据类型。字符串表示所有字符而不仅仅是数值。字符串可以包含数值。

我们将在本文中检查给定的字符串是否为数字。

在 JavaScript 中使用 isNaN() 函数检查给定的字符串是否为数字

isNaN() 函数确定给定的值是数字还是非法数字(Not-a-Number)。该函数对于 NaN 值输出为 True,对于有效数值返回 False。

例子:

console.log(isNaN('195'))
console.log(isNaN('boo'))
console.log(isNaN('100px'))

输出:

false
true
true

如果我们想创建一个对有效值返回 true 的函数,我们总是可以通过创建一个对 isNaN() 函数的输出求反的函数来实现。

function isNum(val){
  return !isNaN(val)
}
console.log(isNum('aaa'));
console.log(isNum('13579'));
console.log(isNum('-13'));

输出:

false
true
true

现在这个名为 isNum() 的函数将为有效的数值返回 true

在 JavaScript 中使用 + 运算符检查给定字符串是否为数字

+ 运算符返回字符串的数值,如果字符串不是纯数字字符,则返回 NaN

例如,

console.log(+'195')
console.log(+'boo')

输出:

195
NaN

在 JavaScript 中使用 parseInt() 函数检查给定的字符串是否为数字

parseInt() 函数解析一个字符串,然后返回一个整数。当无法从字符串中提取数字时,它返回 NaN。

例如,

console.log(parseInt('195'))
console.log(parseInt('boo'))

输出:

195
NaN

在 JavaScript 中使用 Number() 函数检查给定的字符串是否为数字

Number() 函数将参数转换为表示对象值的数字。如果无法将值转换为数字,则返回 NaN。

我们也可以将它与字符串一起使用来检查给定的字符串是否为数字。

例如,

console.log(Number('195'))
console.log(Number('boo'))

输出:

195
NaN

在 JavaScript 中使用正则表达式检查给定字符串是否为数字

正则表达式是描述字符模式的对象。这些可用于搜索模式、对其进行更改、添加、删除等。

我们可以使用这样的模式来检查字符串是否包含数字。

例如,

function isNumeric(val) {
    return /^-?\d+$/.test(val);
}
console.log(isNumeric('aaa'));
console.log(isNumeric('13579'));
console.log(isNumeric('-13'));

输出:

false
true
true

在 JavaScript 中检查字符串中的字符是否大写

在本教程中,我们将演示如何检查包含各种字符的给定字符串是否具有大写格式的所有字符。

在 JavaScript 中检查字符串中的字符是否大写

在 JavaScript 中,没有内置函数来检查给定字符串中的每个字符是否为大写格式。所以,我们必须实现我们的函数。

在这里,我们将创建一个名为 isUpperCase() 的函数,一个匿名箭头函数,告诉我们字符串中的所有字符是否都是大写的。如果是这样,它会在控制台中打印一条消息。

如果字符串中的任何字符不是大写格式,它将在控制台窗口上打印它们。isUpperCase() 函数将采用单个参数 providedStr 作为输入。

在编写 isUpperCase() 函数的逻辑之前,让我们首先声明一些变量。首先,我们将声明两个字符串变量,str_1str_2,其中包含一些字符串值。

我们将把这两个变量作为检查大写格式的参数传递给 isUpperCase() 函数。

代码片段:

let str_1 = "AB% ^M";
let str_2 = "IO(|12c";
let allUpperCase = true;
let isUpperCase = providedStr => {
    for(i in providedStr){
        if(providedStr[i] !== providedStr[i].toUpperCase()){
            allUpperCase = false;
            console.log(`Letter ${providedStr[i]} is not uppercase.`);
        }
    }
    if(allUpperCase){
        console.log("All characters in a given string are uppercase...")
    }
}
isUpperCase(str_1);
isUpperCase(str_2);

然后,我们将声明另一个名为 allUpperCase 的变量,一个布尔变量。默认情况下,我们会将其值分配给 True。

我们假设提供的字符串中的所有字符都已经是大写格式。

isUpperCase() 函数中,我们将在 providedStr 变量上应用 for...in 循环。在每次迭代中,这个 for...in 循环将为我们提供字符串中每个字符的索引 i

现在我们有了字符串中单个字符的索引,我们可以获取这个 i 变量并使用 providedStr[i] 访问该字符。在这里,我们将使用 providedStr[i] 从字符串中获取字符,然后将其与 providedStr[i].toUpperCase() 进行比较。

toUpperCase() 函数将使该字符变为大写。所以,如果字符已经是大写格式,它不会做任何事情。

如果字符已经是大写格式,则不会执行 if 语句。如果字符串中的任何字符不是大写格式,程序将进入 if 语句。

它将使变量 allUpperCase 为假,这意味着我们找到了一个字符,而不是大写格式,然后我们将在控制台窗口上打印该字符。

遍历字符串中的所有字符后,我们将执行条件检查以了解 allUpperCase 变量中的值是否为真。如果为 true,则字符串中的所有字符均为大写格式。

输出:

在 JavaScript 中检查字符串中的字符是否大写

在这里,因为我们的第一个字符串变量 str_1 包含所有大写值 AB% ^M。因此,它所打印的所有字符都是大写的。

请注意,此字符串中也有一个空格字符。在第二个字符串变量 str_2 中,从所有字符 IO(|12c 中,我们只有字符 c,它不是大写格式,所以它在控制台窗口上打印这个字符。

在 JavaScript 中检查字符串是否相等

在 JavaScript 中,有四种运算符可用于检查字符串是否相等。这些运算符称为比较运算符。

  1. 严格相等(===):严格相等(也称为三重相等运算符)检查变量的值及其数据类型。如果这两个东西相等,那么它只返回 true,否则返回 false
  2. 严格不等于 (!==):这与严格等于相反。如果值或数据类型不匹配,则返回 true;否则,false
  3. 等号(==):双等号只检查变量的值。如果值匹配,则返回 true,否则返回 false。它不关心变量类型。
  4. 不相等(!=):这与相等(==)相反。仅当变量内的值不匹配时才返回 true,而不管它们的数据类型如何。如果值彼此匹配,则返回 false

这些运算符不仅用于检查字符串的相等性,还用于检查其他数据类型的相等性。在这四个运算符中,让我们根据用例找出检查字符串相等性的最佳运算符。

你可能已经看过第三个和第四个运算符,即 ==!=,它们在其他编程语言中也很常见。但是它在 JavaScript 中的工作方式与其他语言略有不同。

何时在 JavaScript 中使用运算符进行字符串相等

与 JavaScript 相关,以下是一些用例,你可以在其中使用 ===== 运算符。

  • 如果比较值可能是 truefalse 值,请使用 === 而不是 ==
  • 如果比较值可能是这些特定值中的任何一个(0""[] – 空数组),请使用 === 而不是 ==
  • 在任何其他情况下,你都可以安全地使用 ==。它不仅安全,而且还简化了代码并提高了可读性。

使用严格不等于 (!==) 和不等于 (!=) 运算符时,上述规则同样适用。要了解有关具体规则的更多信息,你可以阅读 ES5 规范的 11.9.3 部分。

通过示例了解 JavaScript 中的字符串相等性

让我们举一些例子,详细了解这些东西。

在这个例子中,我们采用了两个变量,name_1name_2。它们都以 "adam" 作为字符串值。现在让我们应用上述每个运算符并查看我们得到的输出。

在这里,我们使用了四个 ifelse 语句,每个语句代表不同的比较运算符。由于 name_1name_2 变量的值和数据类型相同,三重等于或严格等于运算符 (===) 将打印 True 作为输出。双等号 == 也将打印 True,因为两个变量具有相同的值。

let name_1 = "adam";
let name_2 = "adam";
// Strict Equal
if(name_1 === name_2) console.log("True");
else console.log("False");
// Equal
if(name_1 == name_2) console.log("True");
else console.log("False");
// Strict not equal
if(name_1 !== name_2) console.log("True");
else console.log("False");
// Not equal
if(name_1 != name_2) console.log("True");
else console.log("False");

输出:

True
True
False
False

当使用 Strict 不等于 (!==) 运算符和不等于 (!=) 运算符时,它们都会打印 False 作为输出,因为两个变量中的值本身是相同的。

下面是另一个示例,我们将字符串与整数进行比较。在这里,我们有一个变量 str,其值为 "80",一个字符串值。我们还有另一个变量 num,它包含一个整数值 80 。由于这两个变量具有不同数据类型的相同值,让我们看看对它们使用各种比较运算符时会发生什么。

let str = "80";
let num = 80;
// Strict Equal
if(str === num) console.log("True");
else console.log("False")
// Equal
if(str == num) console.log("True");
else console.log("False")
// Strict not equal
if(str !== num) console.log("True");
else console.log("False")
// Not equal
if(str != num) console.log("True");
else console.log("False")

输出:

False
True
True
False

和第一个例子一样,我们也有四个 ifelse 语句,每个语句代表不同的比较运算符。

当我们使用严格等于或三重等于 (===) 时,我们将得到 False 作为输出。原因是即使值相同,数据类型也不同。但是当我们使用双等号 (==) 时,我们得到 True 作为输出,因为双等号只检查值而不是类型。

当我们使用 Strict not equal (!==) 时,我们得到 True 作为输出,因为字符串值 "80" 不等于整数值 80;因此,它返回 True

最后,不等于 (!=) 运算符仅比较两个变量的值。这些值需要不同才能打印 True。由于在这种情况下值相同,因此返回 False

在 JavaScript 中检查字符串是否是有效的 JSON 字符串

本文将介绍如何在不使用 JavaScript 中的 try...catch 的情况下检查给定字符串是否是有效的 JSON 或 JavaScript Object Notation 字符串。让我们从 JSON 字符串的定义开始,以及它如何帮助我们简化工作流程。

JSON 是一种独立于语言的文本格式,用于结构化数据,与 XML 非常相似;它可以由字符串、整数、浮点数等、布尔值、数组或用大括号括起来的 Java 对象(键值对)组成。

JSON 和 Javascript 对象之间的区别

JavaScript 中的对象是这样的:

object = {name:"Haseeb", age:31, city:"New York",male:true}

当该对象以 JSON 格式保存时,它看起来像这样:

{"name":" Haseeb ", "age":31, "city":"New York", "male":true}

当我们从文本文件中检索对象时,它会被转换为 JSON 字符串格式:

{"name":" Haseeb ", "age":31, "city":"New York", "male":true}

我们可以看到 JSON 格式如何是人类可读的并且更容易被语言操作。

除此之外,它还有很多优点; JSON 除了易于读写之外,还可以与所有语言集成,并且由于其详细的结构,现在可以方便地使用解析。

JSON 通常用于应用程序编程接口 (API),因为它主要用于将数据传输到服务器或从服务器传输到 Web 或移动应用程序,反之亦然。

通过使用 JSON 的 parse 函数,我们现在可以从 JSON 字符串创建对象,这是一个如何完成的示例:

string = '{"name":"John", "age":31, "city":"New York", "male":true}';
object = JSON.parse(string);
console.log(object);

输出:

{ 
    name: 'John', 
    age: 31, 
    city: 'New York', 
    male: true 
}

正如预期的那样,解析函数将所有内容缩减为对象的键和值(JSON 对象),这就是 JSON 字符串现在已成为在系统之间传输数据的约定的原因。

在 JavaScript 中检查 JSON 字符串的有效性

try...catch 用于处理可能在给定 JSON 字符串中弹出的任何潜在错误,而不会停止程序的执行。字符串可能有错误的语法、缺少参数,或者可能是错误的拆分参数。

下面是我们如何使用 try...catch 检查 JSON 字符串的有效性:

try {
    object = JSON.parse(json);
} catch (error) {
    is_json = false;
    console.log("Invalid JSON string");
}

让我们尝试给我们的代码这个字符串:

json = '{"name":"John","city""New York"}';

输出:

Invalid JSON string

正如我们所看到的,我们的 try...catch 并没有告诉我们字符串有什么问题。它只是告诉我们存在一些问题。

为了深入了解 JSON 字符串中的问题,我们可以使用自定义函数来检测(如果不是全部)在不使用 try...catch 的情况下在字符串中弹出的一些错误。

isJSON = function(json) {

    //Nested Count function only to be used for counting colons and commas
    countCharacter = function(string,character) {
        count = 0;
        for (var i = 0; i < string.length; i++) {
            if (string.charAt(i) == character) { //counting : or ,
                count ++;
            }
        }
        return count;
    }
  
    json = json.trim(); // remove whitespace, start and end spaces

    //check starting and ending brackets
    if (json.charAt(0) != '{' || json.charAt(json.length-1) != '}') {
        console.log("Brackets {} are not balanced")
        return false
    }
    //else this line will check whether commas(,) are one less than colon(:)
    else if ( !(countCharacter(json,':')-1 == countCharacter(json, ',')) ){

        console.log("comma or colon are not balanced");
        return false;

    } else {

        json = json.substring(1, json.length-1); //remove first and last brackets
        json = json.split(','); //split string into array, and on each index there is a key-value pair

        //this line iterate the array of key-value pair and check whether key-value string has colon in between
        for (var i = 0; i < json.length; i++) {
        
            pairs = json[i];

            if (pairs.indexOf(':') == -1) { //if colon not exist in b/w

                console.log("No colon b/w key and value");
                return false;
            }
        }
    }
    return true;
};

让我们使用这两个 JSON 字符串并找出它们的错误。

json = ' {"name":"John","city""New York"} ';
json2 = ' {"name":"John","city":"New York" ';

输出:

comma or colon are not balanced
false
Brackets {} are not balanced
false

这段代码很弱,因为它对于一些错误的情况是正确的,所以我们找到了一种混合方法来合并上层函数和 try...catch 代码,以通过一些调试获得绝对答案。

isJSON = function(json) {

    is_json = true; //true at first

    //Try-catch and JSON.parse function is used here.

    try {
        object = JSON.parse(json);
    } catch (error) {
        is_json = false;
        console.log("might be a problem in key or value's data type");
    }

    if (!is_json) {
        countCharacter = function(string,character) {
            count = 0;
            for (var i = 0; i < string.length; i++) {
                if (string.charAt(i) == character) { //counting : or ,
                    count ++;
                }
            }
            return count;
        }
    
        json = json.trim(); // remove whitespace, start and end spaces
    
        if (json.charAt(0) != '{' || json.charAt(json.length-1) != '}') {
            console.log("Brackets {} are not balanced")
    
        }
    
        else if ( !(countCharacter(json,':')-1 == countCharacter(json, ',')) ){
    
            console.log("comma or colon are not balanced");
    
        } else {
    
            json = json.substring(1, json.length-1); //remove first and last brackets
            json = json.split(',');
    
    
            for (var i = 0; i < json.length; i++) {
            
                pairs = json[i];
                if (pairs.indexOf(':') == -1) { //if colon not exist in b/w
                    console.log("No colon b/w key and value");
                }
            }
        }
    }
    return is_json;
};
json = ' {"name":"John", "birth":"1986-12-14", "city":5a0} ';

输出:

might be a problem in key or value's data type
false

这个函数被赋予了与前一个函数相同的调试级别,但这次的答案将是绝对的。