1
2
3
4
5
6
7

┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┐

│   (\_(\     (\_/)     (\_/)     (\_/)      (\(\   │
    ( -.-)    (•.•)     (>.<)     (^.^)     (='.')
│  C(")_(")  (")_(")   (")_(")   (")_(")   O(_")")  │

└ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┘

1
2
3

String[] ss = new String[10]; // 可以持有10个String对象
ss[0] = "Hello"; // 可以放入String对象
String first = ss[0]; // 可以获取String对象

1

List<String> list = new ArrayList<>(); // 只能放入String类型

1
2
3
4

List<String> list = List.of("Apple", "Orange", "Pear");
for (String s : list) {
    System.out.println(s);
}

1
2
3
4

for (Iterator<String> it = list.iterator(); it.hasNext(); ) {
     String s = it.next();
     System.out.println(s);
}

1
2
3

for (int i=0; i<list.size(); i++) {
    Object value = list.get(i);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

public class Main {
    public static void main(String[] args) {
        ReverseList<String> rlist = new ReverseList<>();
        rlist.add("Apple");
        rlist.add("Orange");
        rlist.add("Pear");
        for (String s : rlist) {
            System.out.println(s);
        }
    }
}

class ReverseList<T> implements Iterable<T> {

    private List<T> list = new ArrayList<>();

    public void add(T t) {
        list.add(t);
    }

    @Override
    public Iterator<T> iterator() {
        return new ReverseIterator(list.size());
    }

    class ReverseIterator implements Iterator<T> {
        int index;

        ReverseIterator(int index) {
            this.index = index;
        }

        @Override
        public boolean hasNext() {
            return index > 0;
        }

        @Override
        public T next() {
            index--;
            return ReverseList.this.list.get(index);
        }
    }
}

1

public static boolean addAll(Collection<? super T> c, T... elements) { ... }

1
2

List<String> list1 = List.of("apple");
List<String> list2 = Collections.singletonList("apple");

1
2
3
4

List<String> list1 = List.of(); // empty list
List<String> list2 = List.of("apple"); // 1 element
List<String> list3 = List.of("apple", "pear"); // 2 elements
List<String> list4 = List.of("apple", "pear", "orange"); // 3 elements

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public class Main {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("apple");
        list.add("pear");
        list.add("orange");
        // 排序前:
        System.out.println(list);
        Collections.sort(list);
        // 排序后:
        System.out.println(list);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

public class Main {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        for (int i=0; i<10; i++) {
            list.add(i);
        }
        // 洗牌前:
        System.out.println(list);
        // 洗牌：
        Collections.shuffle(list);
        // 洗牌后:
        System.out.println(list);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public class Main {
    public static void main(String[] args) {
        List<String> mutable = new ArrayList<>();
        mutable.add("apple");
        mutable.add("pear");
        // 变为不可变集合:
        List<String> immutable = Collections.unmodifiableList(mutable);
        immutable.add("orange"); // UnsupportedOperationException!
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public class Main {
    public static void main(String[] args) {
        List<String> mutable = new ArrayList<>();
        mutable.add("apple");
        mutable.add("pear");
        // 变为不可变集合:
        List<String> immutable = Collections.unmodifiableList(mutable);
        mutable.add("orange");
        System.out.println(immutable);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

public class Main {
    public static void main(String[] args) {
        List<String> mutable = new ArrayList<>();
        mutable.add("apple");
        mutable.add("pear");
        // 变为不可变集合:
        List<String> immutable = Collections.unmodifiableList(mutable);
        // 立刻扔掉mutable的引用:
        mutable = null;
        System.out.println(immutable);
    }
}

1

public interface Collection<E> extends Iterable<E> {}

1

public abstract class AbstractCollection<E> implements Collection<E> {}

1

public interface List<E> extends Collection<E> {}

1

public interface Set<E> extends Collection<E> {}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// 是否存在下一个元素
// 每次next之前，先调用此方法探测是否迭代到终点
boolean hasNext();

// 获取下一个元素
// 返回当前迭代元素 ，同时，迭代游标后移
E next();

// 删除当前元素
void remove();

// 删除最近一次已近迭代出出去的那个元素。
// 只有当next执行完后，才能调用remove函数。
// 比如你要删除第一个元素，不能直接调用 remove()   而要先next一下( );
// 在没有先调用next 就调用remove方法是会抛出异常的。
// 这个和MySQL中的ResultSet很类似
void remove() {
    throw new UnsupportedOperationException("remove");
}

1
2
3
4

Iterator iter = hashMap.iterator(); 
while(iter.hashNext()) { 
  String s = iter.next(); 
} 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

List<Integer> li = new ArrayList<>();
li.add(1);
li.add(2);
li.add(3);
//不使用foreach 而手动迭代
Iterator<Integer> iter = li.iterator();    //获取ArrayList 的迭代器
while(iter.hasNext()) {                     //①先探测能否继续迭代
    System.out.println(iter.next());       //②后取出本次迭代出的元素
    //invoke  remove()                     //③最后如果需要，调用remove
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

private class Itr implements Iterator<E> {
    //AbstractList 中实现的迭代器，删除了一些细节。不影响理解,Itr为一个priavate成员内部类
    //马上等待被迭代元素的index
    int cursor = 0;
    //最近一次，已经被迭代出的元素的index，如果这个元素迭代后，被删除了，则lastRet重置为-1
    int lastRet = -1;
    public boolean hasNext() {
        //当前游标值 等于  集合的size()  说明已经不能再迭代了。
        return cursor != size();      
    }
    public E next() {
        int i = cursor;
        E next = get(i);
        //lastRet 保存的是最近一次已经被迭代出去的元素索引
        lastRet = i;     
        //cursor为马上等待被迭代的元素的索引
        cursor = i + 1;  
        return next;

    }
    public void remove() {
        //调用remove之前没有调用next
        if (lastRet < 0)                            
            //则抛异常。这就是为什么在使用remove前，要next的原因
            throw new IllegalStateException();     
        //从集合中删除这个元素
        OuterList.this.remove(lastRet);            
        //集合删除元素后，集合后面的元素的索引会都减小1，cursor也要同步后移
        if (lastRet < cursor)                      
            cursor--;
        //重置
        lastRet = -1;                                 
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

public class Main {
    public static void main(String[] args) {
        List<Person> li = new ArrayList<>();
        Person p = new Person("Tom");
        li.add(p);
        for (Person ap : li) {
            ap.setName("Jerry");
        }
        System.out.println(li.get(0).getName());     //Jerry  not Tom
    }
}
class Person {
    public Person(String name) {
        this.name = (name == null ? "" : name);

    }
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        if (name == null)
            name = "";
        this.name = name;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

public class Main {
    public static void main(String[] args) {
        MyString s = new MyString("1234567");
        for (char c : s) {
            System.out.println(c);
        }
    }
}

class MyString implements Iterable<Character> {
    private int length = 0;
    private String ineers = null;
    public MyString(String s) {
        this.ineers = s;
        this.length = s.length();
    }
    @Override
    public Iterator<Character> iterator() {
        class iter implements Iterator<Character>     //方法内部类
        {
            private int cur = 0;
            @Override
            public boolean hasNext() {
                return cur != length;
            }
            @Override
            public Character next() {
                Character c = ineers.charAt(cur);
                cur++;
                return c;
            }
            public void remove() {
                // do nothing
            }
        }
        return new iter();     //安装Iterable接口的约定，返回迭代器
    }

}

1

public interface Iterable<T>

1

public interface ListIterator<E> extends Iterator<E> {}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// ListIterator的API
// 继承于Iterator的接口
abstract boolean hasNext()
abstract E next()
abstract void remove()
// 新增API接口
abstract void add(E object)
abstract boolean hasPrevious()
abstract int nextIndex()
abstract E previous()
abstract int previousIndex()
abstract void set(E object)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

---|Collection:(包含list和set子接口)
	---|List: 有存储顺序, 可重复
		---|ArrayList：数组实现, 查找快, 增删慢
			由于是数组实现, 在增和删的时候会牵扯到数组
			增容, 以及拷贝元素. 所以慢。数组是可以直接
			按索引查找, 所以查找时较快
		---|LinkedList：链表实现, 增删快, 查找慢
			由于链表实现, 增加时只要让前一个元素记住自
			己就可以, 删除时让前一个元素记住后一个元
			素, 后一个元素记住前一个元素. 这样的增删效
			率较高但查询时需要一个一个的遍历, 所以效率
			较低
		---|Vector：和ArrayList原理相同, 但线程安全, 效率低
				
	---|Set: 无存储顺序, 不可重复
		---|HashSet:线程不安全，存取速度快，底层以哈希表实现
		---|TreeSet:红黑二叉树结构，默认对元素进行自然排序，
		---|LinkedHashSet:会保存插入的顺序

---| Map:键值对(不允许重复的键)null可以作为键，这样的键只有一个
	注:map和collection没有关系
		---|HashMap:根据键的hashCode值存储数据，根据键可以直接获取它的值，查询快(存入的值在取的时候也是随机的)
		---|TreeMap:取出来后是排序后的键值对(如果需要按照自然排序或自定义排序,用这个)
		---|HashTable:和hashMap实现原理一样,区别在于线程安全
		---|LinkedHashMap:输出的顺序和输入的顺序是相同的
		---|ConcurrentHashMap：采用了分段锁的设计，并发map

1
2
3
4
5

package java.util;
public interface Enumeration<E> {
    boolean hasMoreElements();
    E nextElement();
}

1
2
3
4
5
6

package java.util;
public interface Iterator<E> {
    boolean hasNext();
    E next();
    void remove();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Random;

/*
 * 测试分别通过 Iterator 和 Enumeration 去遍历Hashtable
 * @author skywang
 */
public class IteratorEnumeration {

    public static void main(String[] args) {
        int val;
        Random r = new Random();
        Hashtable table = new Hashtable();
        for (int i=0; i<100000; i++) {
            // 随机获取一个[0,100)之间的数字
            val = r.nextInt(100);
            table.put(String.valueOf(i), val);
        }

        // 通过Iterator遍历Hashtable
        iterateHashtable(table) ;

        // 通过Enumeration遍历Hashtable
        enumHashtable(table);
    }
    
    /*
     * 通过Iterator遍历Hashtable
     */
    private static void iterateHashtable(Hashtable table) {
        long startTime = System.currentTimeMillis();

        Iterator iter = table.entrySet().iterator();
        while(iter.hasNext()) {
            //System.out.println("iter:"+iter.next());
            iter.next();
        }

        long endTime = System.currentTimeMillis();
        countTime(startTime, endTime);
    }
    
    /*
     * 通过Enumeration遍历Hashtable
     */
    private static void enumHashtable(Hashtable table) {
        long startTime = System.currentTimeMillis();

        Enumeration enu = table.elements();
        while(enu.hasMoreElements()) {
            //System.out.println("enu:"+enu.nextElement());
            enu.nextElement();
        }

        long endTime = System.currentTimeMillis();
        countTime(startTime, endTime);
    }

    private static void countTime(long start, long end) {
        System.out.println("time: "+(end-start)+"ms");
    }
}