Python同Java同Js语言语法区别之四判断字符串列表字典是否相等

前言

作为一枚测开工程师，需要的技能是全栈的，项目中，经常需要切换语言进行开发，语言用多了，难免会经常用混淆，故趁有空整理下这系列笔记“Python同Java同Js语言语法区别‘，希望对大家有用。

Python

字符串or数字

使用== 比较或者is进行比较

    str1 = "@testxiaosheng"
    str4= "@test"+"xiaosheng"
    str5= "@testxiaosheng"
    str2 = "@test"
    str3 = str2 + "xiaosheng"
    # if str1 is str3: #判断是否同个对象
    if str1 == str3:
        print("一致")
    else:
        print("不一致")
    if str1 is str4:
        print("一致")
    else:
        print("不一致")
    if str1 is str5:
        print("一致")
    else:
        print("不一致")

思考下：为啥1跟5是一样的，但是1跟4却是不一样的

注意：“==” 比较的是值，is比较的是字符串的内存id。如果比较值的话，建议使用 “ == ”比较，而且不同的版本is判断还有区别。
比如在不同的版本下执行会有不同的结果。

str1 = "@testxiaosheng"
str3 ="@test"+"xiaosheng"
if  str1 is str3:
    print("一致")
else:
    print("不一致")

问题解答：python中，字符串是不可变对象，拼接代表着重新创建一个新的字符串对象。但是如果只是申明同样的变量值，python会自动优化，所以申明同样的字符串变量值，对象的地址也是一样得。

额外注意的是python已经创建好了小整数对象池，[-5~256]，都是固定的地址。如果数据超过这个范围就是不同的地址。比如两个遍历都赋值个257.结果这两个变量id就不同。
参考资料：https://blog.csdn.net/LANNY8588/article/details/103338961

列表

python 判断列表需要考虑列表中顺序不一样的问题。所以一般都需要排序后在进行比较，使用==或者eq函数都可以

list1 = ['b', 'dd', 'a', 'c']
list2 = ['a', 'b', 'c', 'dd']
#list2 = None
list3 = ['a', 'b', 'c', 'dd',['a','b']]
list4 = ['a', 'b', 'c', 'dd',['a','b']]
# 方法一：循环判断两个列表中的元素是否一样
# def a(list1,list2):
#     list1.sort()
#     list2.sort()
#     if len(list1) == len(list2):
#         for i in range(0, len(list1)):
#             if list1[i] != list2[i]:
#                 return False
#         return True
#     else:
#         return False
# print( a(list1,list2))


# 方法二：直接使用operator工具eq函数或者==

from operator import *
def b(list1,list2):
    list1.sort()
    list2.sort()
    return eq(list1, list2)
    # return list1==list2
print( b(list1,list2))

# 多维数据同样可以使用eq或者==判断，不过不能使用sort排序，需要自己实现排序，此处请读者自己实现多维排序
def c(list1,list2):
    return eq(list1, list2)
print( c(list3,list4))

字典

字典使用==或者eq函数都可以判断，不过不需要像列表一样排序

dict1 = {"a":"2","c":"3"}
dict2 = {"c":"3","a":"2"}

def d(dict1,dict2):
    print(id(dict1))
    print(id(dict2))
    return eq(dict1, dict1)
    # return dict1 == dict2
print( d(dict1,dict2))

注意如果是字典嵌套了字典，这个时候请使用"=="判断，eq判断不准

dict1 = {"a":"2","c":"3","bb":{"aa":3,"dd":111}}
dict2 = {"c":"3","a":"2","bb":{"aa":3,"dd":11}}

def d(dict1,dict2):
    print(id(dict1))
    print(id(dict2))
    #return eq(dict1, dict1)
     return dict1 == dict2
print( d(dict1,dict2))

总结

python3中可以使用判断字符串，数字、列表（需排序）、字典（不需要排序）是否相等，且None对象也可以比对。“” 比较的是值，is比较的是字符串的内存id

Java

java判断是否相等，要注意空指针问题，null值不能放在最前面

字符串

可以使用equals判断，也可以使用commons工具类的StringUtils.isEquals 判断，建议使用isEquals ，不需要考虑空指针问题

安装commons工具类

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.12.0</version>
            <scope>test</scope>
        </dependency>

import org.apache.commons.lang3.StringUtils;
public class Test {
    public static void main(String[] args) {
        String str1="fefe";
        String str2="fefe";
        String str3=null;
        System.out.println("str1 是否与 str2 相等?:" + str1.equals(str2));
        System.out.println("str1 是否与 str3 相等?:" + str1.equals(str3));
        System.out.println("str1 是否与 str2 相等?:" + StringUtils.equals(str1,str2));
    }
}

数组

可以使用equals判断，也可以使用commons工具类的ArrayUtils.isEquals 判断，但后者isEquals 已被官方弃用.

import java.util.ArrayList;
import java.util.List;
import org.apache.commons.lang3.ArrayUtils;
public class Test {
    public static void main(String[] args) {
        List<String> arry =new ArrayList();
        arry.add("testxiaosheng");
        List<String> arry1 =new ArrayList();
        arry1.add("testxiaosheng");
        List<String> arry2 =new ArrayList();
        arry2.add("testxiaosheng");
        int[] array3 = { 1, 3, 5, 7, 9 };
        String aa="fefe";
        List arry5 = null;
        System.out.println("数组arr是否与数组arr1相等?:" + arry.equals(arry1));
        System.out.println("数组arr是否与数组arr1相等?:" + ArrayUtils.isEquals(arry,arry1));
        System.out.println("数组arr是否与数组arr2相等?:" + arry.equals(arry2));
        System.out.println("数组arr是否与数组arr3相等?:" + arry.equals(array3));
        System.out.println("数组arr是否与数组arr4相等?:" + arry.equals(aa));
        //System.out.println("数组arr是否与数组arr5相等?:" + arry5.equals(arry));空指针异常

    }
}

但equals只针对顺序一致的数组，如果数据不一致，得先排序然后再比对。可以直接使用集合工具类isEqualCollection,自动帮你排好序比较

       List<String> arry =new ArrayList();
        arry.add("12");
        arry.add("testxiaosheng");
        List<String> arry1 =new ArrayList();
        arry1.add("testxiaosheng");
        arry1.add("12");
//        arry.sort(Comparator.reverseOrder()); 升序
//        arry1.sort(Comparator.reverseOrder());
        System.out.println("数组arr是否与数组arr1相等?:" + arry.equals(arry1));
        System.out.println("arry是否与arry1相等?:" + CollectionUtils.isEqualCollection(arry,arry1));

Map

直接使用equals判断

import java.util.HashMap;
import java.util.Map;
public class Test {
    public static void main(String[] args) {
        Map<String,String> m1= new HashMap<String,String>();
        m1.put("aa","123");
        m1.put("testxiaosheng","666");
        Map<String,String> m2= new HashMap<String,String>();
        m2.put("testxiaosheng","666");
        m2.put("aa","123");
        System.out.println("m1是否与m2相等?:" + m1.equals(m2));
    }
}

总结

java中不管是字符串还是数组还是map都可以使用equal关键字判断，不同类型也可以 判断，除了null空指针，注意null必须放在判断最右边 ，要不然会报错。equals 判断数组需要排序，map不需要，使用工具类 CollectionUtils判断，则不需要排序。
请注意equals 与” == “的区别，equals重写后判断的是值内容，equals不能判断基本类型，Java中”==“基本类型使用判断的值，引用类型判断的是内存地址，而python中是判断的内容。python none对象可以放在左边，而java不可以。这两类语法写多了也是很容易混淆的

JS

字符串

JS中判断字符相等一般使用===严格等于，会先判断类型，在判断值，==会自动转换类型比较

var str1 = 123456 ; // 整型
var str2 = "123456" ; // 字符串
console.log(str1==str2);
console.log(str1===str2);

数组

JS中判断数组不能使用===判断，也没有内置得方法可以判断，需要自己写
使用tostrig判断,这种方法有坑，就是数组中含有字符串数字，会认为是一样的

var a = ['1', '3', '2'];
var b = ['3', '1', 2];
var c = a.length === b.length && a.sort().toString() === b.sort().toString();
console.log(c); // true

同样要排好序才能 比价

var arrayEquals = function(array1,array2) {
    array1.sort();
    array2sort();
return array1.length==array2.length && array1.every(function(v,i) { return v === array2[i]});
}
console.log(arrayEquals(a,b))

对象

同样不能用===判断，判断起来也是非常麻烦,此处是网友写的代码，仅供参考

let obj1 = {
	a: 1,
	b: {c: 2}
}
let obj2 = {
	b: {c: 3},
	a: 1
}
function isObjectValueEqual(a, b) {
	// 判断两个对象是否指向同一内存，指向同一内存返回 true
	if (a === b) return true // 获取两个对象键值数组
	let aProps = Object.getOwnPropertyNames(a)
	let bProps = Object.getOwnPropertyNames(b)
	// 判断两个对象键值数组长度是否一致，不一致返回 false
	if (aProps.length !== bProps.length) return false // 遍历对象的键值
	for (let prop in a) {
		// 判断 a 的键值，在 b 中是否存在，不存在，返回 false
		if (b.hasOwnProperty(prop)) {
		// 判断 a 的键值是否为对象，是则递归，不是对象直接判断键值是否相等，不相等返回 false
			if (typeof a[prop] === 'object') {
				if (!isObjectValueEqual(a[prop], b[prop])) return false
			} else if (a[prop] !== b[prop]) {
				return false
			}
		} else {
			return false
		}
	}
	return true
}
console.log(isObjectValueEqual(obj1, obj2)) // false

总结

JS判断数组以及对象，都比较麻烦，所以这些逻辑尽量后端能做就后端做。