Java集合操作

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

Collection中的方法
1.add(o: E) 添加
2.addAll(c: Collection<? extends E>)
3.clear() 清空
4.contains(o: Object) 是否包含

5.equal(o: object) 是否等于另一个集合
6.hashCode() 该集合的散列码
7.isEmpty() 是否为空
8.iterator: Iterator<E> 迭代器
9.remove(o: object) 按照值对象删除，有多个只删除一个
10.removeAll(c: Collection<?>) 从集合中删除c中所有元素
11.retainAll(c: Collection<?>) 保留c和该集合都有的元素
12.size()             集合中元素个数
13.toArray(): Object[] 转为对象数组

Iterator
hasnext() 
next()
remove() 删除使用next方法获取的最后一个元素

1
2
3
4
5
6
7

支持从线性表两端提取，插入和删除元素
addFirst(o: E) 将对象添加到列表头
addLast(o: E)  将对象添加到列表尾
getFirst() 获取列表第一个元素
getLast()  获取列表最后一个元素
removeFirst() 返回和删除列表第一个元素
removeLast()  返回和删除列表最后一个元素

 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

/*
List<E>方法
1.add(index: int, element: E)                  添加一个新元素 
2.addAll(index: int, c: Collection<? extends E>) 添加c中所有元素  
3.get(index: int)               根据下标查找
4.set(index: int, element: E) 根据下标设置obj
5.indexOf(elemen: object)      元素第一个匹配的下标
6.lastIndexOf(element: Object) 元素在最后一个匹配的下标
6.remove(index: int)            根据下标删除

*/
public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    list.add("apple");
    list.add("pear");
    System.out.println(list.size());
    //for
    for(int i = 0; i < list.size(); i++){
        String s = list.get(i);
        System.out.println(s);
    }
		//迭代器
    for(Iterator<String> it = list.iterator(); it.hasNext();){
        String s = it.next();
        System.out.println(s);
    }

1
2
3
4
5
6

//HashSet无序
Set<String> set = new HashSet<>();
//LinkedHashSet 按照插入顺序排序
Set<String> set = new LinkedHashSet;
//TreeSet有序, 根据元素对象排序, 需要对象实现了Comparable
Set<String> set = new TreeSet<>();

 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
66
67
68
69
70
71
72
73

/*
HashMap
LinkedHashMap 可以按insert order或者access order排序
TreeMap 根据key来排序

1.clear() 清除
2.containsKey(key: Object)
3.containsValue(value: Object)
4.entrySet(): Set<Map.Entry<K, V>> 返回一个包含map中条目的set
5.get(key: Object): v 
6.isEmpty()
7.put(key: K, value: V): V
8.putAll(m: Map<? extends K,? extends V>)
9.remove(key: object)
10.size()
11.values(): Collection<V>
*/

public class Student{
    public String name;
    public int score;

    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", score=" + score +
                '}';
    }
    public static void main(String[] args) {
    	 //HashMap无序
    	 //Map<String, Integer> map = new HashMap<>();
    	 //TreeMap有序, 指定排序规则
	    Map<Student, Integer> map = new TreeMap<>(new Comparator<Student>() {
	            public int compare(Student o1, Student o2) {
	                if (o1.score == o2.score){
	                    return 0;
	                }
	                return o1.score > o2.score ? -1: 1;
	            }
	        });
	    map.put(new Student("wk", 12), 1);
	    map.put(new Student("test", 123), 2);
	    
	    //遍历key
	    for(Student key: map.keySet()){
	        Integer value = map.get(key);
	        System.out.println();
	    }
	    
	    //遍历value
	    for(Integer value: map.values()){
           System.out.println(value);
        }
        
	    //遍历entry，效率较高，比遍历key后获取value
	    for(Map.Entry<Student, Integer> entry: map.entrySet()){
	        Student key = entry.getKey();
	        Integer value = entry.getValue(); 
	    }
	    
	    //使用Iterator遍历
	    Iterator<Map.Entry<Student, Integer>> entities = map.entrySet().iterator();
	    while (entities.hasNext()){
            Map.Entry<Student, Integer> entry = entities.next();
            System.out.println(entry.getKey() + "=" + entry.getValue());
      }
	}

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

// FIFO
// offer插入
// add插入 比offer多丢了个异常,跟容量相关,offer返回null
// pool取出并删除
// remove取出并删除 与poll的差别是当队列是空的时候，这个要报异常, pool返回null
// peek获取
// element获取 当队列空的时候异常, peek返回null
Queue<String> q = new LinkedList<>();
q.offer("a");
q.offer("b");
q.add("c");
q.poll();
q.poll();

 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

public class Main {
    public static void main(String[] args) {
        Queue<User> q = new PriorityQueue<>(new UserComparator());
        // 添加3个元素到队列:
        q.offer(new User("Bob", "A1"));
        q.offer(new User("Alice", "A2"));
        q.offer(new User("Boss", "V1"));
        System.out.println(q.poll()); // Boss/V1
        System.out.println(q.poll()); // Bob/A1
        System.out.println(q.poll()); // Alice/A2
        System.out.println(q.poll()); // null,因为队列为空
    }
}

class UserComparator implements Comparator<User> {
    public int compare(User u1, User u2) {
        if (u1.number.charAt(0) == u2.number.charAt(0)) {
            // 如果两人的号都是A开头或者都是V开头,比较号的大小:
            return u1.number.compareTo(u2.number);
        }
        if (u1.number.charAt(0) == 'V') {
            // u1的号码是V开头,优先级高:
            return -1;
        } else {
            return 1;
        }
    }
}
class User {
    public final String name;
    public final String number;

    public User(String name, String number) {
        this.name = name;
        this.number = number;
    }

    public String toString() {
        return name + "/" + number;
    }
}

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

Deque<String> deque = new LinkedList<>();
将元素添加到队尾或队首：
addLast()
offerLast()
addFirst()
offerFirst()
从队首／队尾获取元素并删除：
removeFirst()
pollFirst()
removeLast()
pollLast()
从队首／队尾获取元素但不删除：
getFirst()
peekFirst()
getLast()
peekLast()
总是调用xxxFirst()/xxxLast()以便与Queue的方法区分开

 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

public interface Stack<T> {
    public T pop();
    public void push(T element);
    public boolean isEmpty();
    public T peek();
}

import java.util.*;

public class StackList<T> implements Stack<T> {
    private List<T> list ; //用容器实现
    StackList(){
        list = new ArrayList<T>();
    }
    //弹栈
    public T pop(){
        if(this.isEmpty() == true){
            throw new EmptyStackException();
        }

        return list.remove(list.size()-1);
    }
    //压栈
    public void push(T element){
        list.add(element);
    }
    //判断是否为空
    public boolean isEmpty(){
        return list.size() == 0;
    }
    //返回栈顶元素
    public T peek(){
        if(this.isEmpty() == true){
            throw new EmptyStackException();
        }
        return list.get(list.size()-1);
    }
}

1
2
3
4
5
6
7

 Collections.sort(list); // 排序
 Collections.reverse(list);//  list集合次序反转
 Collection.max(list) // 集合最大元素，元素必须实现Comparable接口
 Collection.min(list) // 集合最小元素
 Collection.frequency(list, element) //元素出现次数
 Collections.shuffle(list); //list集合随机顺序排序
 Collections.replaceAll(list, "oldVal", "newVal"); //一个新值换所有的旧值