第48节：Java当中的集合框架

// 简书作者：达叔小生
Student[] stus = new Student[20];

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

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

// 简书作者：达叔小生
// 集合框架体系
Iterator
 ->Collection
 -> Map

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

Map
 -> 无序 HashMap
 -> 排序 TreeMap

// 简书作者：达叔小生
java.util
接口 Collection<E>
所有超级接口：
Iterable<E>

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

// 简书作者：达叔小生
Set 和 HashSet 为Set的实现类 使用
Iterator -> Collection -> Set -> HashSet
Iterator -> Collection -> List -> ArrayList

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

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

 -> Queue
  -> LinkedList
  -> PriorityQueue

 -> Map
  -> Hashtable
  -> HashMap
  -> TreeMap
  -> LinkedHashMap

// 简书作者：达叔小生
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);
 }
 }
}

// 简书作者：达叔小生
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();
 }
}

// 简书作者：达叔小生
Iterator - > Collection -> Set - > HashSet
hasNext() next()
it.hasNext() 是否还有元素
it.next() 取出元素

// 简书作者：达叔小生
hasNext() 判断是否还有下一个元素
next() 取出这个元素，然后把游标移动到下一位

// 简书作者：达叔小生
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);
 }
 }
}

// 简书作者：达叔小生
Iterator<E> iterator()
// 返回在此collection的元素上的迭代效果。

// 简书作者：达叔小生
public class IteratorDemo{
 public static void mian(String[] args){
  // 创建集合对象
  Collection collection  = new ArrayList();
 // 存储的是对象的引用
 // 集合存储不了基本数据类型
 // collection.add(12); == 内部效果 collection.add(Integer.valueOf(12); // 自动装箱
 // 即在jdk1.5后，存储的是基本数据类型包装类的对象
  collection.add("ab");
  collection.add("bbb");
  collection.add("cbbb");
  collection.add("dbbbb");
  // 获取迭代器 iterator()方法
  Iterator it = collection.iterator();
  while(it.hasNext(){
   System.out.println(it.next());
  }
  // 
   //可以转变为
   // for(Iterator it = collection.iterator(); it.hasNext(); ) {}
  //
  // 每个存储对象的长度
  for(Iterator it = collection.iterator(); it.hasNext(); ){
   // 取出对象
   Object object = it.next();
   // 向下转型，才能使用元素的特殊方法
   String str = (String)object;
   // 打印对象长度
   System.out.println(str.length());
  } 
 }
}

// 简书作者：达叔小生
// 可以使用这个，节省内存
for(java.util.Iterator iterator = collection.iterator(){
 Object object = (Object) iterator.next();
}

// 简书作者：达叔小生
// 创建一个Student类
public class Student{
 // 定义私有的String变量 name
 private String name;
 // 定义私有的int变量 age
 private int age;
 // 创建构造函数
 public Student(){
  super();
 }
 public Student(String name, int age){
  super();
  this.name = name;
  this.age = age;
 }
 // 创建toString()方法
 @Override
 public String toString(){
  return "Student [name=" + name + ", age=" + age + "]";
 }
 // 创建getXxx()，setXXX()方法
 public String getName(){
  return name;
 };
 public void setName(String name){
  this.name = name;
 }
 public int getAge(){
  return age;
 }
 public void setAge(int age){
  this.age = age;
 }
 // equals();
 @Override
 public boolean equals(Object obj){
  if(this == obj){
   return; 
  }
  if(! (obj instanceof Student) ){
   throw new ClassCastException("类型错误");
  }
   Student stu = (Student)obj;
   return this.name.equals(stu.name) && this.age == stu.age;
 }
}

// 简书作者：达叔小生
public class CollectionDemo {
 public static void main(String[] args){
  // 创建集合对象
 Collection collection = new ArrayList();
 // 添加元素 添加一个地址两次为重复
 Student stu = new Student( "a",12 );
 collection.add( stu );
 collection.add( new Student("b",13) );
 collection.add( new Student("c",14) );
 collection.add( new Student("d",15) );
 for(Iterator it = collection.iterator(); it.hasNext(); ){
  Student student = (Student) it.next();
  System.out.println(student.getName());
 }
 }
}

// 简书作者：达叔小生
java.util
Interface Map<K,V>
K - the type of keys maintained by this map
V - the type of mapped values

// 简书作者：达叔小生
import java.util.Map;
import java.util.HahMap;
public class Demo{
 public static void main(String args[]){
  HashMap<String,String> hasMap = new  HashMap<String,String>();
  Map<String,String> map = hasMap;
 // 向上转型
 // 同理 Map<Stirng,String> map = new HashMap<String,String>();
 // put() 用来存放键值对
 map.put("1","a");
 map.put("2","b");
 map.put("3","c");
// 获取长度
 int i = map.size();
// 获取键为2的值
 String s = map.get("2");
 }
}

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

// 简书作者：达叔小生
java.util
接口 List<E>
所有超级接口：Collection<E>，Iterable<E>
所有已知实现类：AbstractList，AbstractSequentialList，ArrayList，AttributeList，CopyOnWriteArrayList，LinkedList，RoleList，Vector，Stack。
可以用 ArrayList

// 简书作者：达叔小生
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));
 }
}