/**
* ArrayList
* 优点: 底层数据结构是数组，查询快，增删慢。
* 缺点: 线程不安全，效率高
*/
public static void ArrayLst(){
ArrayList list = new ArrayList<>();
//添加
list.add(1);
list.add("这是一个字符串");
System.out.println(list);
//清空集合
list.clear();
System.out.println(list);
}
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
public void clear() {
modCount++;
// clear to let GC do its work
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
/**
* LinkedList
* 优点: 底层数据结构是链表，查询慢，增删快。
* 缺点: 线程不安全，效率高
*/
public static void LinkedList(){
LinkedList list = new LinkedList<>();
list.add(1);
list.add("这是一个字符串");
System.out.println(list);
list.clear();
System.out.println(list);
}
public boolean add(E e) {
linkLast(e);
return true;
}
void linkLast(E e) {
final Node<E> l = last;
final Node<E> newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}
public void clear() {
// Clearing all of the links between nodes is "unnecessary", but:
// - helps a generational GC if the discarded nodes inhabit
// more than one generation
// - is sure to free memory even if there is a reachable Iterator
for (Node<E> x = first; x != null; ) {
Node<E> next = x.next;
x.item = null;
x.next = null;
x.prev = null;
x = next;
}
first = last = null;
size = 0;
modCount++;
}
/**
* 不仅不能保证元素插入的顺序，而且在元素在以后的顺序中也可能变化（这是由HashSet按HashCode存储对象（元素）决定的，对象变化则可能导致HashCode变化）
* HashSet是线程非安全的
* HashSet元素值可以为NULL
* 实现Set接口的HashSet，依靠HashMap来实现的。
* 我们应该为要存放到散列表的各个对象定义hashCode()和equals()。
*/
public static void HashSet(){
HashSet set = new HashSet<>();
set.add(1);
set.add("这是一个字符串");
set.clear();
System.out.println(set);
}
public HashSet() {
map = new HashMap<>();
}
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
public void clear() {
Node<K,V>[] tab;
modCount++;
if ((tab = table) != null && size > 0) {
size = 0;
for (int i = 0; i < tab.length; ++i)
tab[i] = null;
}
}
/**
* TreeSet是一个有序的集合，它的作用是提供有序的Set集合。它继承了AbstractSet抽象类，实现了NavigableSet<E>，Cloneable，
* Serializable接口。TreeSet是基于TreeMap实现的，TreeSet的元素支持2种排序方式：自然排序或者根据提供的Comparator进行排序。
*
*/
public static void TreeSet() {
TreeSet<Object> set = new TreeSet<>();
set.add(1);
set.add(3);
set.add(2);
set.add(10);
set.add(4);
System.out.println(set);
set.clear();
System.out.println(set);
//输出结果
// [1, 2, 3, 4, 10]
//[]
public class Student implements Comparable {
private String name;
private int age;
@Override
public int compareTo(Object o) {
//如果将compareTo()返回值写死为0，元素值每次比较，都认为是相同的元素，这时就不再向TreeSet中插入除第一个外的新元素。
// 所以TreeSet中就只存在插入的第一个元素。
return 0;
//如果将compareTo()返回值写死为1，元素值每次比较，都认为新插入的元素比上一个元素大，于是二叉树存储时，
// 会存在根的右侧，读取时就是正序排列的。
return 1;
//如果将compareTo()返回值写死为-1，元素值每次比较，都认为新插入的元素比上一个元素小，于是二叉树存储时，
// 会存在根的左侧，读取时就是倒序序排列的。
return -1;
}
}
/**
* 底层数据结构是链表和哈希表。(FIFO插入有序,唯一)
* 1.由链表保证元素有序
* 2.由哈希表保证元素唯一
*/
public static void LinkedHashSet(){
LinkedHashSet<Object> linkedHashSet = new LinkedHashSet<>();
linkedHashSet.add(111);
linkedHashSet.add("这是一个字符串");
//使用迭代器遍历
Iterator<Object> it = linkedHashSet.iterator();
while (it.hasNext()){
System.out.println(it.next());
}
}
/**
* HashMap是一个散列桶（数组和链表），它存储的内容是键值对(key-value)映射
* HashMap采用了数组和链表的数据结构，能在查询和修改方便继承了数组的线性查找和链表的寻址修改
* 当向HashMap中put一对键值时，它会根据key的hashcode值计算出一个位置，该位置就是此对象准备往数组中存放的位置
* HashMap是非synchronized，所以HashMap很快
* HashMap可以接受null键和值，而Hashtable则不能（原因就是equlas()方法需要对象，因为HashMap是后出的API经过处理才可以）
* 如果该位置没有对象存在，就将对象直接放进数组当中；如果该位置已经有对象存在了，则顺着此存在的对象的链开始寻找（Entry 类有一个Entry类型的next成员变量，指向了该对象的下一个对象），如果此链上有对象的话，再去使用equal方法进行比较，如果对此链上的某个对象的equals方法比较为false，则将该对象放到数组当中，该位置以前存在的那个对象链接到此对象的后面
*/
public static void HashMap(){
HashMap<Object, Object> map = new HashMap<>();
map.put(1,"这是一个数字1");
map.put("张三","18岁了");
System.out.println(map);
//使用迭代器遍历
Iterator<Object> iterator = map.keySet().iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
//输出结果
// {1=这是一个数字1, 张三=18岁了}
//1
//张三
}
