Java集合框架中底层文档的List与Set

// 简书作者：达叔小生
Collection
 -> Set 无序不重复 -> 无序HashSet，需要排序TreeSet
 -> List 有序可重复 -> 查，改ArrayList，增删LinkedList

// 简书作者：达叔小生
Collection
 -> Set
  -> HashSet
  -> LinkedHashSet
  -> TreeSet

 -> List
  -> ArrayList
  -> Vector
  -> LinkedList

// 简书作者：达叔小生
import java.util.List;
import java.util.ArrayList;

public class Demo{
 public static void main(String args[]){
 // 创建列表的实现类对象
  ArrayList<String> arrayList = new ArrayList<String>();
 // 添加数据
 arrayList.add("a");
 arrayList.add("b");
 arrayList.add("c");
// 移除
 arrayList.remove(1);
 // 获取数据
 String s = arrayList.get(1);
 System.out.println(s);
 // 获取长度
 int a = arrayList.size();
 // 打印所有元素
 for(int i=0; i<arrayList.size(); i++){
  String s = arrayList.get(i);
  System.out.println(s);
 }
 }
}

// 简书作者：达叔小生
public class ListDemo{
 public static void main(String[] args){
  // List
  List list = new ArrayList();
 // 添加元素
 list.add( new Student("a",12) );
 list.add( new Student("b",13) );
 list.add( new Student("c",14) );
 // 插入元素
 // list.add( 1, new Student("d",15) );
 // list.remove(44); 
 // 角标越界IndexOutOfBoundsException)
 // list.set( 2, new Student("dashucoding", 16) );
 // 循环出对象
 for(Iterator it = List.iterator(); it.hasNext(); ){
  Student stu = (Student) it.next();
  System.out.println(stu);
 }
 // 获取对象
 Object obj = list.get(1);
 System.out.println(obj);
 // 获取对象
 for(int i = 0; i<list.size(); i++){
  System.out.println(list.get(i));
 }
}

// 简书作者：达叔小生
import java.util.Set;
import java.util.HashSet;
public class Demo{
 public static void main(String args[]){
  HashSet<String> hashSet = new HashSet<String>();
 Set<String> set = hashSet;
 // 实现类向上转型为接口
 // 同理 Set<String> set = new HashSet<String>();
 // 添加元素
 set.add("a"); 
 set.add("b");
 set.add("c");
 set.add("d");
 // 获取集合中的元素长度
 int a = set.size();
 }
}

// 简书作者：达叔小生
import java.util.Set;
import java.util.HashSet;
import java.util.Iterator;
public class Demo{
 public static void main(String args[]){
  HashSet<String> hashSet = new HashSet<String>();
 Set<String> set = hashSet;
 // 实现类向上转型为接口
 // 同理 Set<String> set = new HashSet<String>();
 // 添加元素
 set.add("a"); 
 set.add("b");
 set.add("c");
 set.add("d");
 // 迭代器 iterator() 遍历整个set
// 通过迭代器取出集合中的对象
 Iterator<String> it = set.iterator<String>();
 while(it.hasNext){
  String s = it.next();
  System.out.println(s);
 }
 }
}

// 简书作者：达叔小生
public class ListIteratorDemo{
 // 创建List对象
 List list = new ArrayList();
 // 添加元素
 List.add("a");
 List.add("b");
 List.add("c");
 // 获取元素，iterator()方法进行迭代
 Iterator it = list.iterator();
// 获取元素
 while(it.hasNext()){
  System.out.println(it.next());
 }
}

// 简书作者：达叔小生
hasNext()
next()
remove()

// 简书作者：达叔小生
public interface Iterator<E>

// 简书作者：达叔小生
java.util
接口ListIterator<E>
超级接口：Iterator<E>

// 简书作者：达叔小生
public interface ListIterator<E> extends Iterator<E>

// 简书作者：达叔小生
while(it.hasNext()){
 Object obj = it.next();
 if("a".equals(obj)){
  list.add("aaaaa");
 }
}

// 简书作者：达叔小生
 // 创建List对象
 List list = new ArrayList();
 // 添加元素
 List.add("a");
 List.add("b");
 List.add("c");
// 列表迭代器
ListIterator it = list.listIterator();
while(it.hasNext()){
 Object obj = it.next();
 if("a".equals(obj)){
  // 添加 it.add("dashucoding");
  // 删除 it.set("dashucoding");
 }
}

// 简书作者：达叔小生
实现类：
AbstractList , ArrayList , LinkedList , Vector
AbstractSequentialList , AttributeList , CopyOnWriteArrayList , RoleList , RoleUnresolvedList , Stack

// 简书作者：达叔小生
ArrayList为数组结构，长度可以改变
java.util
类 ArrayList<E>
java.lang.Object
 -> java.util.AbstractCollection<E>
  -> java.util.AbstractList<E>
   -> java.util.ArrayList<E>

// 简书作者：达叔小生
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, Serializable

// 简书作者：达叔小生
java.util
类 LinkedList<E>
java.lang.Object
 -> java.util.AbstractCollection<E>
  -> java.util.AbstractList<E>
   -> java.util.AbstractSequentialList<E>
    -> java.util.LinkedList<E>

public class LinkedList<E>
extends AbstractSequentiaList<E>
implements List<E>, Deque<E>, Cloneable, Serializable

// 简书作者：达叔小生
public class LinkedListDemo{
 public static void main(String[] args){
  // 创建一个队列对象
  Queue queue = new Queue();
  // 队列添加元素
  queue.add("a");
  queue.add("b");
  queue.add("c");
  while(!queue.isNull){
   System.out.println(queue.myGet());
  }
 }
}

class Queue{
 // 封装了一个链表的数据结构
 private LinkedList link;
 Queue(){
  link = new LinkedList();
 }
 // 功能
 public void add(Object obj){
  // 内部，使用链表方法
  link.addFirst(obj);
 }
  // 先进先出
 public Object myGet(){
  return link.removeList();
 }
 // 判断队列中的元素是否为空
 public boolean isNull(){
  return link.isEmpty();
 }
}

// 去除重复元素
public static void getSingleElement(List list){
 // 临时容器
 List temp = new ArrayList();
 // 原容器
 for(Iterator it = list.iterator(); it.hasNext(); ){
  // 遍历原对象元素
  Object obj = it.next();
   if(temp.contains(obj)){
    // 判断是否存在
    temp.add(obj);
   }
 }
 list.clear();
 list.addAll(temp);
}

// 简书作者：达叔小生
public class ArrayListDemo{
 public static void main(String[] args){
  List list = new ArrayList();
  list.add("a");
  list.add("b");
  list.add("c");
  System.out.println(list);
 }
}

// 简书作者：达叔小生
public boolean equals(Object obj){
 if(this == obj){
 return true;
 }
 if(!(obj instanceof Student)){
  throw new ClassCastException();
 }
 Student stu = (Student) obj;
 return this.name.equals(stu.name) && this.age == stu.age;
}

// 简书作者：达叔小生
public boolean contains(Object o){
 return indexOf(o) >= 0;
}

// 简书作者：达叔小生
public int indexOf(Object o){
 if(o == null){
  for(int i = 0; i<size; i++){
   if(elementData[i] == null){
    return i;
   }
  }
 }else{
  for( int i = 0; i<size; i++){
   if(o.equals(elementData[i])){
    return i;
   }
  }
 }
 return -1;
}

// 简书作者：达叔小生
List 
 -> Vector
 -> ArrayList
 -> LinkedList

java.util
接口 Set<E>
参数E：此set所维护元素的类型

超级接口
Collection<E>，Iterable<E>
知道的子接口
NavigableSet<E>，SortedSet<E>
知道实现类
AbstractSet，ConcurrentSkipListSet，CopyOnWriteArraySet，EnumSet，HashSet，
JobStateReasons，LinkedHashSet，TreeSet

public class LinkedHashSetDemo{
 public static void main(String[] args){
  Set  set = new LinkedHashSet();
  set.add("a");
  set.add("b");
  set.add("c");
  for(Iterator it = set.iterator(); it.hesNext();){
   System.out.println(it.next());
  }
 }
}

public interface Set<E>
extends Collection<E>

public class SetDemo{
 public static void main(String[] args){
  Set set = new HashSet();
  set.add("a");
  set.add("b");
  set.add("c");
  // set.add(new Student("a",12));
  // set.add(new Student("b",13));
  // set.add(new Student("c",14));

  for(Iterator it = set.iterator(); it.hasNext(); ){
   Object object = (Object) it.next();
   System.out.println(it.next();
  }
 }
}

Set 
 -> HashSet
 -> TreeSet

java.lang.Object
 -> java.util.AbstractCollection<E>
  -> java.util.AbstractSet<E>
   -> java.util.HashSet<E>

类HashSet<E>
知道已实现的接口：
Serializable,Cloneable,Iterable<E>,Collection<E>,Set<E>
知道的子类：
JobStateReasons,LinkedHashSet

public class HashSet<E>
extends AbstractSet<E>
implements Set<E>,Cloneable,Serializable

// 简书作者：达叔小生
public int hashCode(){
 return 1;
}

public boolean equals(Object obj){
 if(this == obj)
  return true;
 if(obj == null)
  return false;
 if(getClass() != obj.getClass())
  return false;
 if(age != other.age)
  return false;
 if(name == null){
  if(other.name != null)
   return false;
 }else if(!name.equals(other.name))
  return false;
 return true;
 }
}

// 简书作者：达叔小生
public class TreeSetDemo{
 public static void main(String[] args){
  Set set = new TreeSet(new ComparatorLength() );
  set.add("a");
  set.add("b");
  set.add("c");
  for(Iterator it = set.iterator();it.hasNext(); ){
   System.out.println(it.next());
  }
 }
}

// 简书作者：达叔小生
public class ComparatorLength implements Comparator{
 public int compare(Object o1,Object o2){
  // 比较字符串，强转
  String s1=(String)o1;
  String s2=(String)o2;
  int temp = s1.length() - s2.length();
  return temp == 0? s1.compareTo(s2) : temp;
 }
}

// 简书作者：达叔小生
public class TreeSet<E>
extends AbstractSet<E>
implements NavigableSet<E>,Cloneable,Serialirable

// 简书作者：达叔小生
java.lang
接口 Comparable<T>
参数为可以与对象进行比较

// 定义一个类实现Comparator
public class ComparatorName implements Comparator{
 public int compare(Object o1,Object o2){
  Student s1 = (Student)o1;
  Student s2 = (Student)o2;
  int temp = s1.getName().compareTo(s2.getName());
  return temp==0? s1.getAge()-s2.getAge() : temp;
 }
}

// 简书作者：达叔小生
public int compareTo(Object o){
 if(!(o instanceof Student)){
  throw new ClassCastException();
 }
 Student stu = (Student) o;
 if(this.age>stu.age)
  return 1;
 if(this.age<stu.age)
  return -1;
return 0;
}

// 简书作者：达叔小生
public class TreeSetDemo{
 public static void main(String[] args){
  // Set set = new TreeSet();
  TreeSet set = new TreeSet();
  set.add("a");
  set.add("b");
  set.add("c");
  for(Iterator it = set.iterator(); it.hasNext(); ){
   System.out.println(it.next());
  }
 }
}

// 源码
public boolean add(E e){
 return m.put(e, PRESENT)==null;
}

// 简书作者：达叔小生
public class ForeachDemo{
 public static void main(String[] args){
  List list = new ArrayList();
  list.add("1");
  list.add("2");
  list.add("3");
  for(Object str : list){
   System.out.println(obj);
  }
 }
}

// 简书作者：达叔小生
public class EnumerationDemo{
 public static void main(String[] args)}
  Vector v = new Vector(); 
  v.addElement("a"); 
  v.addElement("b");
  v.addElement("c");
  for(Enumeration e = v.elements(); e.hasMoreElements();){
   System.out.println(e.nextElement());
  }
  // 不考虑，先考虑Iterator
  for(Object obj : v){
   System.out.println(obj);
  }
 }
}