目录

List接口

 常见的List接口的实现类

List接口中的特殊方法

对象相等判定使用的是equals方法

常见的List接口的实现类

总结List的三种实现类

List接口中的sort方法

最佳匹配原则

Set集合

无序，不允许重复

按照hashCode值进行比较，

潜规则：

 实现类：

HashSet

TreeSet

LinkedHashSet

 Java中采用补码的方式存储整数  [原码  反码  补码]

---

List接口

有序 允许重复public interface List extends Collection
继承自Collection接口的方法
boolean add(E e);向集合末尾追加元素e对象  
boolean remove(Object obj)删除第一个和obj相等的元素，
如果没有和obj相等元素，则报异常IndexOutOfBoundsException 

 常见的List接口的实现类

 ArrayList：数组实现，查询快，增删慢，轻量级；(线程不安全)
 LinkedList：双向链表实现，增删快，查询慢 (线程不安全)
 Vector：数组实现，重量级 (线程安全、使用少)

List接口中的特殊方法
 

void add(int index, E element); 向指定索引位置index上添加元素element，
原始数据自动后移

E get(int index);  获取指定索引号对应的元素,index应该在[0,size-1]

E set(int index, E element);  用于给指定索引位置上进行赋值，这个位
置上必须有对应的数据(已经赋过值)，这里实际上是修改操作，否则
IndexOutOfBoundsException

E remove(int index);删除指定位置的元素，可以返回原始位置上存储的元素
int indexOf(Object o); 查找从左向右第一个o元素的下标索引,如果元素
不存在返回-1
 
int lastIndexOf(Object o);从右向左查找

对象相等判定使用的是equals方法

sort方法按照自定义比较器对集合中的所有元素进行排序，默认自然序
 default void sort(Comparator c) {
        Object[] a = this.toArray();  //将List集合对象转换为数组
        Arrays.sort(a, (Comparator) c);  //调用Arrays工具类中的排序方法对数组进行排序
        ListIterator i = this.listIterator();  //获取List集合对象中特殊的Iterator迭代器对象
        for (Object e : a) {  //foreach结构遍历数组中的所有元素
            i.next();
            i.set((E) e); //修改集合List中迭代器指定的当前位置上的元素
        }
    }

  list.sort(new Comparator() {
            public int compare(A2 o1, A2 o2) {
                // 自定义比较规则，按照id从小到大，如果id相等则按照name从大到小
                int res = o1.getId().compareTo(o2.getId());
               if (res == 0)
                    res = (o1.getName().compareTo(o2.getName())) * -1;
                return res;
            }
        });

调用方法时要求传入参数为自定义比较器

常见的List接口的实现类

ArrayList：数组实现，查询快，增删慢，轻量级；(线程不安全)
LinkedList：双向链表实现，增删快，查询慢 (线程不安全)
Vector：数组实现，重量级 (线程安全、使用少)

总结List的三种实现类

List接口中的sort方法

package com.yan2;
 
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
 
/*
 * List接口中的sort方法
 */
public class Test2 {
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add(new A2(99L, "zhangsan"));
		list.add(new A2(77L, "lisi"));
		list.add(new A2(99L, "wangwu"));
		list.sort(new Comparator() {
			public int compare(A2 o1, A2 o2) {
				// 自定义比较规则，按照id从小到大，如果id相等则按照name从大到小
				int res = o1.getId().compareTo(o2.getId());
				if (res == 0)
					res = (o1.getName().compareTo(o2.getName())) * -1;
				return res;
			}
		});
		list.forEach(System.out::println);
	}
}
 
class A2 {
	private Long id;
	private String name;
 
	public A2(Long id, String name) {
		this.id = id;
		this.name = name;
	}
 
	// ===================================
	public Long getId() {
		return id;
	}
 
	public void setId(Long id) {
		this.id = id;
	}
 
	public String getName() {
		return name;
	}
 
	public void setName(String name) {
		this.name = name;
	}
 
	@Override
	public String toString() {
		return "A2 [id=" + id + ", name=" + name + "]";
	}
 
}

最佳匹配原则

package com.yan2;
 
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Random;
 
public class Test6 {
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add(100);
		for (int i = 0; i < 5; i++)
			list.add(i);
		list.remove(4);//最佳匹配原则
		list.remove(Integer.valueOf(100));   //参数是Object
		for (int i = 0; i < list.size(); i++)
			System.out.println(list.get(i));
	}
}

Set集合

无序，不允许重复

public interface Set extends Collection
没有新方法
boolean add(E e);向集合中追加元素e对象，如果出现重复则后添加数据直接丢弃如果进行对象相等比较：
首先调用当前对象所属类中的hashCode方法获取当前对象的hashCode值

按照hashCode值进行比较，

如果hashCode值不相等，则不会调用equals方法，直接得出结论两个对象不相等
如果hashCode值相等，才调用equals方法进行进一步判断
如果equals为真则判断两个对象相等

潜规则：

 java要求当两个对象的equals为true时，要求两个对象的hashCode值相等。
        hashCode值相等并不一定equals为true

 实现类：

HashSet

TreeSet

LinkedHashSet

package com.yan3;
 
import java.util.HashSet;
import java.util.Objects;
import java.util.Set;
 
public class Test1 {
	public static void main(String[] args) {
		Set set = new HashSet();
		set.add(new A1(99L, "zhangsan"));
		set.add(new A1(88L, "lisi"));
		set.add(new A1(99L, "wangwu"));
		set.forEach(System.out::println);
	}
}
 
class A1 {
	private Long id;
	private String name;
	@Override
	public int hashCode() {
		System.out.println(this+"::hashcode()");
		return id.hashCode();
	}
	//比较规则为：按照id进行比较，如果id相等则对象相等
	public boolean equals(Object obj) {
		System.out.println(this+"::equals()");
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		A1 other = (A1) obj;
		return Objects.equals(id, other.id);
	}
 
	public A1(Long id, String name) {
		super();
		this.id = id;
		this.name = name;
	}
 
	public Long getId() {
		return id;
	}
 
	public void setId(Long id) {
		this.id = id;
	}
 
	public String getName() {
		return name;
	}
 
	public void setName(String name) {
		this.name = name;
	}
 
	@Override
	public String toString() {
		return "A1 [id=" + id + ", name=" + name + "]";
	}
 
}

 Java中采用补码的方式存储整数  [原码  反码  补码]

package com.yan4;
 
public class Test1 {
public static void main(String[] args) {
	// Java中采用补码的方式存储整数  [原码  反码  补码]
	
	//位运算   <<左移位   >>右移位
	
	int kk=12; //00000000 00000000 00000000 001100
	System.out.println(Integer.toBinaryString(kk));
	int k1=kk>>3;//00000000 00000000 00000000 000001   --1  相当于计算12/2的3次方
	System.out.println(k1);
	System.out.println(Integer.toBinaryString(k1));
	
	
	int kk1=3;
	int kk2=kk1<<4; //相当于是3*2的4次方
	System.out.println(kk2);
	
	int kk3=Integer.MAX_VALUE-1;
	System.out.println(kk3+10); //-2147483640
}
}