/**
* 比如collection接口的設計一樣，可能會定義一個容器需要的相關方法，但是他在提供一個AbstractCollection的抽象方法，把相關能通用的方法進行封裝實現，
* 後面的容器直接繼承AbstractCollection，將需要重寫的方法實現，其他abstractCollection實現的方法就不用再次實現：但是注意AbstractCollection的add方法因爲考慮到線程安全問題是直接拋出的異常
* 必須重寫的方法，因爲在繼承的AbstractCollection中，方法是用的Abstract修飾的，沒有方法體。
*/
//public class ArrayList_1 {
/** ArrayList --extends --- AbstractArrayList： 抽象的類，此類也是實現了Lsit接口，對其中簡單的方法進行了實現
* ArrayList -- implements -- List: 接口，其實在AbstractArrayList已經實現了該List接口，但是這樣再次實現一次的好處在於使用代理模式的時候，
* 能夠直接基於List接口去新建一個代理類，不然是會報錯的，詳情見：
* http://www.cnblogs.com/bluejavababy/p/4320545.html
*
* List -- implements -- collection:
* AbstractArrayList -- extends -- AbstractCollections: 所以對於容器的基本實現和方法，在AbstractCollection就已經實現，不用再次編寫。
*
* 注意：ArrayList是一個線程不安全的類，在實現的時候不能保證其原子性，具體的實現可以通過同步鎖（synchronized)或者collections類的方法
*
* 假定是自己來對一個動態數組容器ArrayList進行實現：
* 1、新增（首部、尾部、任意位置）：
* public void add(int index, E element) 因爲是數組默認數據是插入在數組首部的，尾部就用size - 1來表示;注意插入的元素的類型，特別是字符型和char類型
* 2、刪除（首部、尾部、任意位置）
* public boolean remove(int index) ,根據指定位置進行刪除
* public boolean remove(Object o) ,根據指定值進行刪除，刪除的時候有多個重複的，則刪除第一個
* 3、修改（任意位置）
* public E set(int index), 修改指定位置的值，把修改以前的值返回回來，當下標不存在報錯
* 4、查詢（循環）
* public E get(int index) , 查詢某個ArrayList的下標對應的值
* 5、複製（複製collection）
*
* 6、比較（內容大小）
* 7、排序
* Comparator: public void ArrayList.sort(Comparator<? super E> c): 排序一共有兩種方式：
* 1、自定義一個內部內： Comparator comparator = new Comparator(){
* public int compare(Object o1, Object o2) {
* return
* }
* }
* Collections.sort(list, comparator);
* 2、使用ArrayList.sort()方法：
* ArrayList.sort(new Comparator(){
* public int compare(Object o1, Object o2) {
* return o1.getAge() - o2.getAge();
* }
* })
* 8、查找元素所在位置
* public int indexOf(E e);
* 9、是否包含某個元素
* public boolean contains(E e);
* 10、循環
* 1、for
* 2、forEach
* 3、iterator
* 對於爲什麼需要三種遍歷方式的理解：
* * 1、爲什麼需要iterator:
* * a: for循環已經能夠對集合進行遍歷，但是這個遍歷的前提是我們不需知道集合裏元素的具體細節或者說元素的長度等信息，而iterator就是爲了隱藏集合的內部細節，
* * 讓集合的內容對使用者完全透明
* * b: 在使用for的過程中是可以刪除和新增的，但是這會造成list的size變化，很容易造成不必要的bug.
* * c: foeEach其實是對iteartor的一層封裝，但是在forEach的循環中是不允許刪除和新增元素的。在看是ForEach的時候，就相當於鎖住了list的size
* * d：iterator的使用中相當於使用指針
* 2、對性能的比較暫時沒有出結果，可能是自己的比較方式有問題（）
*
* @param args
*/
public static void main(String[] args) {
List list = new ArrayList();
{
//新增
list.add('a');
list.add("你");
list.add('5');
list.add('5');
list.add(1, 'd');
System.out.println("ArrayList--add(int index, E element) :" + list);// ArrayList--add(int index, E element) :[a, d, 你, 5, 5]
}
{
//刪除
Object result = list.remove(new Character('你'));
System.out.println("public boolean remove(E element) : " + list + "--:" + result);// public boolean remove(E element) : [a, d, 你, 5, 5]--:false
list.remove(1);
System.out.println("public boolean remove(int index) : " + list);// public boolean remove(int index) : [a, 你, 5, 5]
}
{
//修改
Object result = list.set(1, "b");
System.out.println("public E set(int index) : " + list + "-- result :" + result);// public E set(int index) : [a, b, 5, 5]-- result :你
}
{
//查詢
Object o = list.get(2);
System.out.println("public E get(int index) : " + o); //public E get(int index) : 5
}
{
//循環
List list_for = new ArrayList();
list_for.add(2);
list_for.add(3);
list_for.add(4);
list_for.add(5);
list_for.add(6);
System.out.println("list_for----:" + list_for);
//1、for
for(int i = 0; i < list_for.size(); i++) {
System.out.println("-----i：" + list_for.get(i));
}
//2、forEach
for(Object a : list_for) {
System.out.println("----list_for:" + (Integer)a);
}
//3、iterator
Iterator<Integer> iterator = list_for.iterator();
while(iterator.hasNext()) {
Integer a = iterator.next();
if( a == 2) {
iterator.remove();
}
System.out.println("list_for---iterator:" + a);
}
System.out.println("list_for---iterator的刪除以後:" + list_for);
//list_for---iterator:2
//list_for---iterator:3
//list_for---iterator:4
//list_for---iterator:5
//list_for---iterator:6
/**
* 對於爲什麼需要三種遍歷方式的理解：
* 1、爲什麼需要iterator:
* a: for循環已經能夠對集合進行遍歷，但是這個遍歷的前提是我們不需知道集合裏元素的具體細節或者說元素的長度等信息，而iterator就是爲了隱藏集合的內部細節，
* 讓集合的內容對使用者完全透明
* b: 在使用for的過程中是可以刪除和新增的，但是這會造成list的size變化，很容易造成不必要的bug.
* c: foeEach其實是對iteartor的一層封裝，但是在forEach的循環中是不允許刪除和新增元素的。在看是ForEach的時候，就相當於鎖住了list的size
* d：iterator的使用中相當於使用指針
*/
/*list_for.clear();
for(int i = 0; i < 10000; i++) {
list_for.add(i);
}
//1、for
Long begin_for = System.currentTimeMillis();
for(int i = 0; i < list_for.size(); i++) {
}
Long end_for = System.currentTimeMillis();
System.out.println("for 循環 耗時：" + (end_for - begin_for));
//2、forEach
Long begin_forEach = System.currentTimeMillis();
for(Object a : list_for) {
}
Long end_forEach = System.currentTimeMillis();
System.out.println("end_forEach 循環 耗時：" + (end_forEach - begin_forEach));
//3、iterator
Long begin_iterator = System.currentTimeMillis();
Iterator<Integer> iterator1 = list_for.iterator();
while(iterator1.hasNext()) {
iterator1.next();
}
Long end_iterator = System.currentTimeMillis();
System.out.println("iterator 循環 耗時：" + (end_iterator - begin_iterator));*/
}
{
//list存儲對象的對象屬性比較
User zs = new User("張三", 23);
User ls = new User("李四", 24);
User ww = new User("王五", 25);
List list_user = new ArrayList();
list_user.add(zs);
list_user.add(ww);
list_user.add(ls);
System.out.println("list--的排序前：" + list_user);
//1、
/* Comparator<User> comparator = new Comparator<User>() {
@Override
public int compare(User user1, User user2) {
return user1.getAge() - user2.getAge();
}
};
Collections.sort(list_user, comparator);
System.out.println("list--的排序後：" + list_user);*/
//2、
list_user.sort(new Comparator<User>() {
@Override
public int compare(User o1, User o2) {
return o1.getAge() - o2.getAge();
}
});
System.out.println("list--的排序後：" + list_user);
}
{
//一些查詢是否包含的api
List list_c = new ArrayList();
list_c.add(1);
list_c.add(2);
list_c.add(3);
list_c.add(4);
Boolean result = list_c.contains(2);
System.out.println("---contains:" + result); //---contains:true
int a = list_c.indexOf(2);
System.out.println("list_c--indexOf:" + a);// list_c--indexOf:1
}
}
//}