List使用

目录

一、场景1：List中是否存在某个元素

---

一、场景1：List中是否存在某个元素

这里会用到List中的contains方法

1、源码分析：

contains源码

	//传入当前需要查看比较的对象Object
	public boolean contains(Object o) {
		//调用indexOf()，当返回值大于等于0的时候返回true,表示存在(true)；返回值=-1，表示不存在(false)
        return indexOf(o) >= 0;
    }
		
	public int indexOf(Object o) {
		//如果当前对象是null
	     if (o == null) {
	    	 //for循环判断下标在哪，并返回下标
	         for (int i = 0; i < size; i++)
	             if (elementData[i]==null)
	                 return i;
	     } else {
	     	//当前对象不为null，继续for循环判断
	         for (int i = 0; i < size; i++)
	             if (o.equals(elementData[i]))
	                 return i;
	     }
	     return -1;
	 }

Object类中equals源码：

    public boolean equals(Object obj) {
        return (this == obj);
    }

==说明：基本数据类型（byte,short,char,int,long,float,double,boolean）比较的是他们的值；引用数据类型比较的是他们在内存中的存放地址（堆内存地址）。所有的类都继承Object类，所以一般equals方法都相当于==，但是String、Integer、Date等类复写了equals方法，比较的是实际的值。

特殊情况：

String s1= "abc";
String s2 = "abc";
System.out.println(s1==s2);
System.out.println(s1.equals(s2));

结果: true. true. 因为在常量池中，一个常量只会对应一个地址，因此不管是再多的 "abc", 这样的数据都只会存储一个地址. 所以所有他们的引用都是指向的同一块地址，因此基本数据类型和String常量是可以直接通过==来直接比较的

2、可直接用contains或其他方式判断

public class Test {

	private static List<String> nameList = new ArrayList<String>();
	static {
		nameList.add("zhangsan");
		nameList.add("lisi");
		nameList.add("wangwu");
		nameList.add("zhaoliu");
		nameList.add("zhaosi");
		nameList.add("liuneng");
		nameList.add("xiaoqiang");
		nameList.add("zhaoyun");
	}
	
	public static void main(String[] args) {
		//1. contains   底层采用for循环去比较
		boolean nameExist = nameList.contains("lisi");
		System.out.println(nameExist);
		
		//2.forEach
		boolean nameExist = false;
		for(String name :nameList) {
			if("liuneng".equals(name)) {
				nameExist = true;
			}
		}
		System.out.println(nameExist);
		
		//3.lambda
		boolean nameExist = nameList.stream().anyMatch(name -> "zhaoyun".equals(name));
		System.out.println(nameExist);

		//4.迭代器
		boolean nameExist = false;
		Iterator<String> iterator = nameList.iterator();
		while (iterator.hasNext()) {
			if("zhaosi".equals(iterator.next())) {
				nameExist = true;
			}
		}
		System.out.println(nameExist);
		
		//5.for循环
		boolean nameExist = false;
		Iterator<String> iterator = 
		for(int i = 0; i< nameList.size(); i++) {
			if("liuneng".equals(nameList.get(i))) {
				nameExist = true;
			}
		}
		System.out.println(nameExist);
	}
}

3、不可直接用contains

如果待判断元素是一个类，直接用contains方法会对类的内存地址进行比较，这是不对的。所以需要重新定义该类的equals()和hashCode()方法。hashCode是jdk根据对象的地址或者字符串或者数字计算该对象的哈希码值的方法。

之所以复写hashCode是为了维护hashCode()方法的equals协定，该协定指出：如果根据 equals()方法，两个对象是相等的，那么对这两个对象中的每个对象调用 hashCode方法都必须生成相同的整数结果；而两个hashCode()返回的结果相等，两个对象的equals()方法不一定相等。另外，复写equals()方法时，也复写hashcode()方法，使相等的两个对象获取的HashCode值也相等，这样当此对象做Map类中的Key时，两个equals为true的对象其获取的value都是同一个，比较符合实际。

    @Override
    public boolean equals(Object o) {
        //自反性
        if (this == o) return true;
        //任何对象不等于null，比较是否为同一类型
        if (!(o instanceof Person)) return false;
        //强制类型转换
        Person person = (Person) o;
        //比较属性值
        return getId() == person.getId() &&
                Objects.equals(getName(), person.getName()) &&
                Objects.equals(getSex(), person.getSex());
    }

重写hashCode()方法需要遵循hashCode()协定：

• 一致性：在Java应用程序执行期间，在对同一对象多次调用hashCode方法时，必须一致地返回相同的整数，前提是将对象进行hashcode比较时所用的信息没有被修改。
• equals：如果根据equals()方法比较，两个对象是相等的，那么对这两个对象中的每个对象调用hashCode()方法都必须生成相同的整数结果，注：这里说的equals()方法是指Object类中未被子类重写过的equals()方法。
• 附加：如果根据equals()方法比较，两个对象不相等，那么对这两个对象中的任一对象上调用hashCode方法不一定生成不同的整数结果。但是，程序员应该意识到，为不相等的对象生成不同整数结果可以提高哈希表的性能。

重写代码如下：

    @Override
    public int hashCode() {
        return Objects.hash(getId(), getName(), getSex());
    }

重写之后就可以直接用contains判断该类是否在List中了。