JavaSE

 (1)覆盖hashCode()方法大范围的保证相同的内容输出相同的哈希码，进行比较

  public int hashCode() {//6个对象比较15次，原因是6个对象哈希码都相同

//return 123;//固定值，所有对象都要比较
//return this.age;//相对优化：所有对象返回相同哈希码，达到了可以去掉重复的目的，但是，效率又很低（该比的比，不该比的不比）

return this.name.hashCode() + this.age.hashCode() + this.sex.hashCode() + this.score.hashCode();

(2)覆盖equals()方法进行判断，如果相同对象输出ture，不同对象，内容相同输入true拒绝插入

public boolean equals(Object obj) {
if(this == obj) return true;
if(obj == null) return false;
if(this.getClass() != obj.getClass()) return false;
Student s =(Student)obj;
if(this.name.equals(s.name) && this.age.equals(s.age) &&
this.sex.equals(s.sex) && this.score.equals(s.score)) return true;
return false;
}

MyClass<Integer> mc1 = new MyClass<Integer>();
MyClass<Double> mc2 = new MyClass<Double>();
MyClass<String> mc3 = new MyClass<String>();
class MyClass<E>{ //E代表一种通配，可以是任意类型，未指明类型前，为Object

•        public void m1(E e) {//泛型可以动态

•     }

       public void m2(Object o) {//固定写死，不能变
    }

}

interface Comparable<E>{//可比较，可排序
public int compareTo(E obj);//Object参数的通用，还是在具体业务场景中稍显麻烦
}
class MyStudent implements Comparable<MyStudent>{
int age;
     public int compareTo(MyStudent obj) {
          if(this.age > obj.age) {
            return -1;
       }
          return 0;
       }
}

//?代表任意泛型
//可接受的是所有的动物集合
/**
* ? extends Animal 泛型类型必须是Animal的子类
* ? extends Comparable 泛型类型必须是Comparable的实现类
* ? super Dog 泛型类型必须是Dog或Dog父类
*/
public static void m1(List<? super Dog> list) {
}

//<T extends Comparable> 只要List集合中的元素，实现了Comparable接口就行
//<T extends Comparable<Integer>> List集合中的元素，实现的Comparable接口，必须是Integer泛型的
//目标：集合中的所有对象，必须具备本类型的两个元素进行比较的方法

public static <T extends Comparable<T>> void m(List<T> list) {

//当LIst<T>被传入实参后，要求T所代表的类型，必须实现Comparable接口，同时，接口泛型必须是T类型

}

传入的实参必须是继承了number然后是Serializable 和 Comparable的实现类（才可以通过实参传入）
public static <T extends Number & Serializable & Comparable> void m1(T t) {//宽泛（特别宽泛，不存在约束）
}

/**
* 原案例：当LIst<T>被传入实参后，要求T所代表的类型，必须实现Comparable接口，同时，接口泛型必须是T类型（合理，但是过于严格）
* 1.如果要求Comparable<T>必须是自身类型，则导致，无法对一组父类引用的对象进行排序
* 2.故而加入<? super T> 实现Comparable接口时，无论是父类还是子类，都可以成为泛型参数
* 参数化类型，类型安全
*/
public static <T extends Comparable<? super T>> void m(List<T> list) {              //Arrays.sort( new Student[5] );
                      for(int i = 0 ; i < list.size() - 1 ; i++) {
                      Comparable c = (Comparable)list.get(i);// ClassCastException connot be convert Student to Comparable
                       int result = c.compareTo(list.get(i+1)); // 1 -1 0
           }
}

子类构造方法
SynchronizedList(List<E> list) {
super(list);
this.list = list;
}

public boolean addIfAbsent(E e) {
Object[] snapshot = getArray();//e插入的值，snapshot数组
return indexOf(e, snapshot, 0, snapshot.length) >= 0 ? false :
addIfAbsent(e, snapshot);//第四步的操作
}//调用indexOf()方法如果存在返回false，如果不存在返回新建的数组。

lock.lock();//获得锁

Object[] current = getArray();
int len = current.length;
if (snapshot != current) {
// Optimize for lost race to another addXXX operation
int common = Math.min(snapshot.length, len);
for (int i = 0; i < common; i++)
if (current[i] != snapshot[i] && eq(e, current[i]))
return false;
if (indexOf(e, current, common, len) >= 0)
return false;
}

Object[] newElements = Arrays.copyOf(current, len + 1); 
newElements[len] = e;
setArray(newElements);//和CopyOnWroteArrayList相同
return true;

lock.unlock();//释放锁

public boolean offer(E e) {
checkNotNull(e);
final Node<E> newNode = new Node<E>(e);
for (Node<E> t = tail, p = t;;) {
Node<E> q = p.next;
if (q == null) {
if (p.casNext(null, newNode)) {
if (p != t) // hop two nodes at a time
casTail(t, newNode); 
return true;
}
}
else if (p == q)
p = (t != (t = tail)) ? t : head;
else
p = (p != t && t != (t = tail)) ? t : q;
}
}

ArrayBlockingQueue:数组结构实现，有界队列（手工固定上限）

LinkedBlockingQueue：链表结构实现，无界队列。（默认上限Integer.MAX_VALUE）