Java集合框架

Created2021-12-19Updated2021-12-19

集合体系结构

    单列集合 collection
       可重复list
           ArrayList LinkedList
       不可重复set
          HashSet TreeSet
    双列集合 map
           HashMap

Collection 集合概述

    1.是单例集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素
    2.JDK不提供此接口的任何直接实现，它提供更具体的子接口（如Set和List）实现
    创建Collection对象
    1.多态的方式
    2.具体的实现类ArrayList

1
2
3
4
5
6
7
8
9
10
11
12
13
import java.util.ArrayList;
import java.util.Collection;

public class day2collection集合概述和引用 {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<String>();
        //添加元素 ：boolean add(E e)
        c.add("hello");
        c.add("world");
        c.add("java");
        System.out.println(c);
    }
}

集合常用方法

Collection集合常用方法
boolean add(E e) 添加元素
boolean remove(Object o) 从集合中移除指定的元素
void clear() 清空集合中的元素
boolean contains(Object o) 判断集合中是否包含指定元素
boolean isEmpty() 判断集合是否为空
int size() 集合的长度，也就是集合中元素的个数
alt+7快捷键打开一个窗口 能够看到类的信息

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
import java.util.ArrayList;
import java.util.Collection;

public class day3Collection集合常用方法 {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> c = new ArrayList<>();
        //boolean add(E e) 添加元素
        /*System.out.println(c.add("hello"));
        System.out.println(c.add("world"));
        System.out.println(c.add("world"));*/
        c.add("hello");
        c.add("world");
        c.add("java");
        //boolean remove(Object o) 从集合中移除指定的元素
        System.out.println(c.remove("world"));
        System.out.println(c.remove("jaba"));
        //void clear() 清空集合中的元素
        c.clear();
        //boolean contains(Object o) 判断集合中是否包含指定元素
        System.out.println(c.contains("world"));
        //boolean isEmpty() 判断集合是否为空
        System.out.println(c.isEmpty());
        //int size() 集合的长度，也就是集合中元素的个数
        System.out.println(c.size());
        //输出集合对象
        System.out.println(c);
    }
}

Collection集合的遍历

Iterator: 迭代器，集合的专用遍历方式
 *Iterator<E> iterator(): 返回此集合中元素的迭代器，通过集合的iterator()方法得到
*迭代器是通过集合的iterator()方法得到的，所以我们说他是依赖于集合而		存在的
Iterator中的常用方法
E next():返回迭代中的下一个元素
boolean hasNext(): 如果迭代具有更多元素，则返回true

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
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class day4Collection集合的遍历 {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> c = new ArrayList<>();
        //添加元素
        c.add("hello");
        c.add("world");
        c.add("java");
        //Iterator<E> iterator():返回此集合中元素的迭代器，通过集合的iterator()方法得到
        Iterator<String> it = c.iterator();
        /*public Iterator<E> iterator() {
            return new ArrayList.Itr();
        }
        private class Itr implements Iterator<E> {
            }*/
        /*System.out.println(it.next());
        System.out.println(it.next());
        System.out.println(it.next());*/
//        if (it.hasNext()){
//            System.out.println(it.next());
//        }if (it.hasNext()){
//            System.out.println(it.next());
//        }if (it.hasNext()){
//            System.out.println(it.next());
//        }if (it.hasNext()){
//            System.out.println(it.next());
//        }
        while(it.hasNext()){
//            System.out.println(it.next());
            String s = it.next();
            System.out.println(s);
        }
    }
}

集合使用步骤

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class day5集合使用步骤 {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<>();
        c.add("hello");
        c.add("world");
        c.add("java");
        Iterator<String> it = c.iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
    }
}

Collection存储学生对象并遍历

需求：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

思路：
①定义学生类
②创建Collection对象
③创建学生对象
④把学生添加到集合
⑤遍历集合（迭代器方式）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class day6Collection存储学生对象并遍历 {
    public static void main(String[] args) {
        //创建Collection集合对象
        Collection<day6Student> c = new ArrayList<>();
        //创建学生对象
        day6Student s1 = new day6Student("杨要想",19);
        day6Student s2 = new day6Student("率秀气",18);
        day6Student s3 = new day6Student("张帅",20);
        //把学生添加到集合
        c.add(s1);
        c.add(s2);
        c.add(s3);
        //遍历集合（迭代器方法）
        Iterator<day6Student> it = c.iterator();
        while(it.hasNext()){
            day6Student s = it.next();
            System.out.println(s.getName() + "," + s.getAge());
        }
    }
}

List集合概述和特点

List集合概述
 ·有序集合（也称为序列），用户可以精准控制列表中每个元素的插入位置。用户可以	通过整数索引访问元素，并搜索列表中的元素。
·与Set集合不同，列表通常允许重复的元素

List集合特点
·有序：存储和取出的元素顺序一致
 ·可重复：存储的元素可以重复

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class day1List集合概述和特点 {
    public static void main(String[] args) {
        //创建集合元素
        List<String> list = new ArrayList<>();
        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("world");
        //直接输出集合对象
        System.out.println(list);
        //遍历集合
        Iterator<String> it = list.listIterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

List集合特有方法

void add(int index,E element) 在此集合的指定位置插入指定的元素
E remove(int index) 删除指定索引处的元素，返回被删除的元素
E set(set index,E element) 修改指定索引处的元素，返回被修改的元素
E get(int index) 返回指定索引处的元素

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
import java.util.ArrayList;
import java.util.List;

public class day2List特有方法 {
    public static void main(String[] args) {
        //创建集合元素
        List<String> list = new ArrayList<>();
        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        //void add(int index,E element) 在此集合的指定位置插入指定的元素
        list.add(1,"javaee");
        //list.add(11,"als") 越界异常
        //E remove(int index) 删除指定索引处的元素，返回被删除的元素
        list.remove(1);
        //E set(set index,E element) 修改指定索引处的元素，返回被修改的元素
        list.set(2,"lzy");
        //E get(int index) 返回指定索引处的元素
        System.out.println(list.get(1));
        //输出集合对象
        System.out.println(list);
        //遍历集合
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

需求：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合

①定义学生类
②创建list对象
③创建学生对象
④把学生添加到集合
⑤遍历集合（迭代器方式，for循环方式）

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
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class day3List集合存储学生对象并遍历 {
    public static void main(String[] args) {
        //创建list集合对象
        List<day3Student> list  = new ArrayList<>();
        //创建学生对象
        day3Student s1 = new day3Student("张三",66);
        day3Student s2 = new day3Student("李四",96);
        day3Student s3 = new day3Student("王五",86);
        //把学生添加到集合
        list.add(s1);
        list.add(s2);
        list.add(s3);
        //遍历集合
        Iterator<day3Student> it = list.listIterator();
        while(it.hasNext()){
            day3Student s = it.next();
            System.out.println(s.getName() + "," + s.getAge());
        }
        for (int i = 0; i < list.size(); i++) {
            day3Student c = list .get(i);
            System.out.println(c.getName() + "," + c.getAge());
        }
    }
}

并发修改异常

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
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

//遍历集合 得到每一个元素 看有没有world这个元素 如果有 我就添加一个 javaee 元素
//ConcurrentModificationExceptionh 当不允许这样的修改时，可以通过检测到对象的并发修改的方法来抛出此异常

public class day4并发修改异常 {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list = new ArrayList<>();
        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        //遍历集合 得到每一个元素 看有没有world这个元素 如果有 我就添加一个 javaee 元素
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String s = it.next();
            if (s.equals("world")){
                list.add("javaee");
            }
        }
//        for (int i = 0; i < list.size(); i++) {
//            String s = list.get(i);
//            if (s.equals("world")){
//                list.add("javaee");
//            }
//        }
        //输出集合对象
        System.out.println(list);
    }
}

ListIterator:列表迭代器

·通过LIst集合的listIterator()方法得到，所以说它是List集合特有的迭代器
·用于允许程序员沿任一方向遍历列表的的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置

ListIterator中的常用方法

·E next():返回迭代中的下一个元素
·boolean hasNext():如果迭代具有更多元素，则返回true
·E previous():返回列表中的上一元素
·boolean hasPrevious():如果此迭代器在相反方向遍历列表时具有更多元素，则返回true
·void add(E e):将指定的元素插入列表`

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
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

public class day5列表迭代器 {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list = new ArrayList<>();
        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        //通过list集合的listiterator()方法得到
//        ListIterator<String> lit = list.listIterator();
//        while (lit.hasNext()){
//            String s = lit.next();
//            System.out.println(s);
//        }
//        while (lit.hasPrevious()){
//            String s = lit.previous();
//            System.out.println(s);
//        }
        //获取列表迭代器
        ListIterator<String> it = list.listIterator();
        while(it.hasNext()){
            String s= it.next();
            if (s.equals("world")){
                it.add("javaee");
            }
        }
        System.out.println(list);
    }
}

增强for循环

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
//增强for：简化数组和Collection集合的遍历
//·实现Iterator接口的类允许其对象成为增强型for语句的目标
//·它是JDK5之后出现的，其内部原理是一个Iterator迭代器

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

//增强for的格式
//·格式：
//  for(元素数据类型变量名:数组或者Collection集合){
//      在此处使用变量即可，该变量就是元素
//  }
public class day6增强for循环 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        for (int i :arr){
            System.out.println(i);
        }
        System.out.println("--------------------");
        String[] strArray = {"hello","world","java"};
        for (String s:strArray){
            System.out.println(s);
        }
        System.out.println("--------------------");
        List<String> list = new ArrayList<>();
        list.add("hello");
        list.add("world");
        list.add("java");
        for (String s:list){
            System.out.println(s);
        }
        //内部原理是一个Iterator迭代器
        for (String s:list){
            if (s.equals("world")){
                list.add("javaee");
            }
        }
        System.out.println("--------------------");
        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        System.out.println("-------------------");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("-------------------");

    }
}

List集合的子类特点

List集合常用子类:ArrayList，LinkedList
ArrayList:底层数据结构是数组，查询快，增删慢
LinkedList:底层数据结构是链表，查询慢，增删快

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
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

public class day9List集合的子类特点 {
    public static void main(String[] args) {
        List<String> array = new ArrayList<>();
        array.add("hello");
        array.add("world");
        array.add("java");
        //迭代器
        Iterator<String> it = array.listIterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(s);
        }
        //for循环
        for (int i = 0; i < array.size(); i++) {
            System.out.println(array.get(i));
        }
        //增强for
        for(String s : array){
            System.out.println(s);
        }
        System.out.println("----------------");
        List<String> linkedstring = new LinkedList<>();
        linkedstring.add("hello");
        linkedstring.add("world");
        linkedstring.add("java");
        //增强for
        for(String s : linkedstring){
            System.out.println(s);
        }
    }
}

LinkedList集合的特有功能

public void addFirst(E e) 在该列表开头插入指定的元素
public void addLast(E e) 将制定元素追加到此列表的末尾
public E getFirst() 返回此列表中的第一个元素
public E getLast() 返回此列表中的最后一个元素
public E removaFirst() 从此列表中删除并返回第一个元素
public E removaLast() 从此列表中删除并返回最后一个元素

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
import java.util.LinkedList;

public class day10LinkedList集合的特有功能 {
    public static void main(String[] args) {
        //创建集合对象
        LinkedList<String> linkedlist = new LinkedList<>();

        linkedlist.add("hello");
        linkedlist.add("world");
        linkedlist.add("java");
        //public void addFirst(E e) 在该列表开头插入指定的元素
        linkedlist.addFirst("javase");
        //public void addLast(E e) 将制定元素追加到此列表的末尾
        linkedlist.addLast("javaee");
        //public E getFirst() 返回此列表中的第一个元素
        System.out.println(linkedlist.getFirst());
        //public E getLast() 返回此列表中的最后一个元素
        System.out.println(linkedlist.getLast());
        //public E removaFirst() 从此列表中删除并返回第一个元素
        System.out.println(linkedlist.removeFirst());
        //public E removaLast() 从此列表中删除并返回最后一个元素
        System.out.println(linkedlist.removeLast());
        System.out.println(linkedlist);
    }
}

Set

Set集合概述和特点
Set集合特点：
  不包含重复元素的集合
  没有带索引的方法，所以不能使用普通for循环遍历

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.util.HashSet;
import java.util.Set;

public class day1Set集合概述和特点 {
    public static void main(String[] args) {
        //创建集合对象
        Set<String> set = new HashSet<>();
        //添加元素
        set.add("hello");
        set.add("world");
        set.add("java");
        //不包含重复元素
        set.add("world");
        //遍历
        for (String s : set){
            System.out.println(s);
        }
    }
}

哈希值:

是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值

Object类中有一个方法可以获取对象的哈希值
  public int hashCode();返回对象的哈希码值

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
public class day2哈希值 {
    public static void main(String[] args) {
        //创建学生对象
        day2Student s1 = new day2Student("林青霞",30);
        //同一个对象多次调用hashCode()这个方法返回的哈希值是相同的
        System.out.println(s1.hashCode());//1956725890
        System.out.println(s1.hashCode());//1956725890
        System.out.println("---------------------------");
        //默认情况下，不同对象的哈希值是不相同的
        //通过方法重写，可以实现不同对象的哈希值是相同的
        day2Student s2 = new day2Student("林青霞",30);
        System.out.println(s2.hashCode());//356573597

        System.out.println("-------------------------");

        System.out.println("hello".hashCode());//99162322
        System.out.println("world".hashCode());//113318802
        System.out.println("java".hashCode());//3254818

        System.out.println("world".hashCode());//113318802

        System.out.println("重地".hashCode());//1179395
        System.out.println("通话".hashCode());//1179395
    }
}



HashSet集合概述和特点

  底层数据结构是哈希表
  对集合的迭代顺序不保证，也就是说不保证存储和取出的元素顺序一致
  没有带索引的方法，所以不能使用普通for循环遍历
  由于是set集合，所以是不包含重复元素的集合

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import java.util.HashSet;

public class day3HashSet集合概述和特点 {
    public static void main(String[] args) {
        //创建集合对象
        HashSet<String> hs = new HashSet<>();
        //添加元素
        hs.add("hello");
        hs.add("world");
        hs.add("java");

        hs.add("world");
        //遍历
        for (String s : hs){
            System.out.println(s);
        }
    }
}

HashSet集合保证元素唯一性源码分析

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
//创建集合对象
HashSet<String> hs = new HashSet<>();
//添加元素
hs.add("hello");
hs.add("world");
hs.add("java");
------------------------------------

public boolean add(E e) {
        return map.put(e, PRESENT)==null;
}
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
publi c V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    //如果哈希表未初始化，就对其进行初始化
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    //根据对象的哈希值计算对象的存储位置，如果该位置没有元素，就存储元素
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        /*
            存入的元素和以前的元素比较哈希值
                如果哈希值不同，会继续向下执行，把元素添加到集合
                如果哈希值相同，会调用对象的equals()方法比较
                    如果返回false，会继续向下执行，把元素添加到集合
                    如果返回true，说明元素重复，不存储
        */
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

哈希表

JDK8之前，底层采用数组+链表实现，可以说是一个元素为链表的数组
JDK8之后，在长度比较长的时候，底层实现了优化

//需求:创建一个存储学生对象的系统，存储多个学生对象，使用程序实现在控制台遍历
//要求:学生对象的成员变量相同，我们就认为是同一个对象
//
//思路:
//1.定义学生类
//2.创建HashSet集合对象
//3.创建学生对象
//4.把学生添加到集合
//5.遍历集合(加强for循环)
//6.在学生类中重写两个方法 hashcode()和equals() 自动生成即可 alt+insert

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
import java.util.HashSet;

public class day6HashSet集合存储学生对象并遍历 {
    public static void main(String[] args) {
        //创建hashset集合对象
        HashSet<day6Student> hs = new HashSet<>();
        //创建学生对象
        day6Student s1 = new day6Student("林青霞",30);
        day6Student s2 = new day6Student("张曼玉",35);
        day6Student s3 = new day6Student("王祖贤",33);

        day6Student s4 = new day6Student("王祖贤",33);

        //把学生添加到集合
        hs.add(s1);
        hs.add(s2);
        hs.add(s3);

        hs.add(s4);

        //遍历集合
        for (day6Student s : hs){
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}


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
package 集合框架.Set;

import java.util.Objects;

public class day6Student {
    private String name;
    private int age;

    public day6Student(){

    }
    public day6Student(String name,int age){
        this.name = name;
        this.age = age;
    }
    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;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        day6Student that = (day6Student) o;
        return age == that.age && Objects.equals(name, that.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

LinkedHashSet集合特点

1
2
3
4
5
//1.哈希表和链表实现的Set接口，具有可预测的迭代次序
//2.由链表保证元素有序，也就是说元素的存储和取出顺序是一致的
//3.由哈希表保证元素唯一，也就是说没有重复的元素
//
//练习:存储字符串并遍历
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import java.util.LinkedHashSet;

public class day7LinkedHashSet集合概述和特点 {
    public static void main(String[] args) {
        //创建集合对象
        LinkedHashSet<String> lsk = new LinkedHashSet<>();
        //添加元素
        lsk.add("hello");
        lsk.add("world");
        lsk.add("java");
        lsk.add("world");
        //遍历集合
        for (String s : lsk){
            System.out.println(s);
        }
    }
}

TreeSet集合概述和特点

1.元素有序，这里的顺序不是指存储和取出的顺序，而是按照一定的规则进行排序，具体排序方式取决于构造方法
TreeSet():根据其元素的自然顺序进行排序
TreeSet(Comparator comparator):根据指定的比较器进行排序
2.没有带索引的方法，所以不能使用普通for循环进行遍历
3.由于是set集合，所以不包含重复元素的集合

TreeSet集合练习:存储整数并遍历

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import java.util.TreeSet;

public class day8TreeSet集合概述和特点 {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Integer> ts = new TreeSet<>(); //所有基本类型引用时需要用包装类
        //添加元素
        ts.add(10);
        ts.add(40);
        ts.add(30);
        ts.add(50);
        ts.add(20);

        ts.add(30);
        //遍历
        for (Integer i : ts){
            System.out.println(i);
        }
    }
}

自然排序Comparabale的使用

存储学生对象并遍历，创建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
import java.util.TreeSet;

public class day9自然排序Comparabale的使用 {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<day9Student> ts = new TreeSet<>();
        //创建学生对象
        day9Student s1 = new day9Student("xishi",29);
        day9Student s2 = new day9Student("wangzhaojun",28);
        day9Student s3 = new day9Student("diaochan",30);
        day9Student s4 = new day9Student("yangyuhuan",33);
        day9Student s5 = new day9Student("linqingxia",33);
        day9Student s6 = new day9Student("linqingxia",33);
        //把学生添加到集合
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);
        //遍历集合
        for (day9Student s : ts){
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}

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
package 集合框架.Set;

public class day9Student implements Comparable<day9Student>{
    private String name;
    private int age;

    public day9Student(){

    }
    public day9Student(String name,int age){
        this.name = name;
        this.age = age;
    }
    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;
    }

    @Override
    public int compareTo(day9Student s) {
//        return 0;
//        return 1;
//        return -1;
        //按照年龄进行排序
//        int num = s.age - this.age; 升序
        int num = this.age - s.age;
        int num2  = num==0?this.name.compareTo(s.name):num;
        return num2;
    }
}

比较器排序Comparator的使用

存储学生对象并遍历，创建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
import java.util.Comparator;
import java.util.TreeSet;

public class day10比较器排序Comparator的使用 {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<day10Student> ts = new TreeSet<>(new Comparator<day10Student>() {
            @Override
            public int compare(day10Student s1, day10Student s2) {
                //this.age - s.age
                //s1,s2
                int num = s1.getAge()-s2.getAge();
                int num2 = num==0?s1.getName().compareTo(s2.getName()):num;
                return num2;
            }
        });
        //创建学生对象
        day10Student s1 = new day10Student("xishi",29);
        day10Student s2 = new day10Student("wangzhaojun",28);
        day10Student s3 = new day10Student("diaochan",30);
        day10Student s4 = new day10Student("yangyuhuan",33);

        day10Student s5 = new day10Student("linqingxia",33);
        day10Student s6 = new day10Student("linqingxia",33);
        //把学生添加到集合
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);
        //遍历集合
        for (day10Student s : ts){
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}

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
package 集合框架.Set;

public class day10Student {
    private String name;
    private int age;

    public day10Student(){

    }
    public day10Student(String name,int age){
        this.name = name;
        this.age = age;
    }
    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;
    }
}

需求:用TreeSet集合存储多个学生信息(姓名，语文成绩，数学成绩)，并遍历该集合
要求:按照总分从高到低出现

思路:
①定义学生类
②创建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
import java.util.Comparator;
import java.util.TreeSet;

public class day11案例成绩排序 {
    public static void main(String[] args) {
        //创建TreeSet集合对象，通过比较器排序进行排序
        TreeSet<day11Student> ts = new TreeSet<>(new Comparator<day11Student>() {
            @Override
            public int compare(day11Student s1, day11Student s2) {
                //int num = (s2.getChinese() + s2.getMath())-(s1.getChinese()-s2.getMath());
                int num = s2.getSum()-s1.getSum();
                int num2 = num==0?s1.getChinese()-s2.getChinese():num;
                int num3 = num2==0?s1.getName().compareTo(s2.getName()):num2;
                return num3;
            }
        });
        //创建学生对象
        day11Student s1 = new day11Student("林青霞",98,100);
        day11Student s2 = new day11Student("张曼玉",95,95);
        day11Student s3 = new day11Student("王祖贤",100,93);
        day11Student s4 = new day11Student("柳岩",100,97);
        day11Student s5 = new day11Student("风清扬",98,98);
        day11Student s6 = new day11Student("左冷禅",97,99);
        //day11Student s7 = new day11Student("左冷禅",97,99);
        day11Student s7 = new day11Student("赵云",97,99);
        //把学生添加到集合
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
        ts.add(s6);
        ts.add(s7);
        //遍历集合
        for (day11Student s: ts){
            System.out.println(s.getName()+","+s.getChinese()+","+s.getMath()+","+s.getSum());
        }
    }
}

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
package 集合框架.Set;

public class day11Student {
    private String name;
    private int chinese;
    private int math;

    public day11Student(){

    }
    public day11Student(String name,int chinese,int math){
        this.name = name;
        this.chinese = chinese;
        this.math = math;
    }


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getChinese() {
        return chinese;
    }

    public void setChinese(int chinese) {
        this.chinese = chinese;
    }

    public int getMath() {
        return math;
    }

    public void setMath(int math) {
        this.math = math;
    }
    public int getSum(){
        return this.chinese+this.getMath();
    }

}

需求:编写一个程序，获取10个1-20之间的随机数，要求随机数不能重复，并在控制台输出
①创建set集合
②创建随机数对象
③判断集合的长度是不是小于10
是:产生一个随机数，添加到集合
回到3继续
④遍历集合

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
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
import java.util.TreeSet;

public class day12案例不重复的随机数 {
    public static void main(String[] args) {
        //创建set集合
        //Set<Integer> set = new HashSet<>(); 不会排序
        Set<Integer> set = new TreeSet<>();  //会排序
        //创建随机数对象
        Random r = new Random();
        //判断集合的长度是不是小于10
        while (set.size()<10){
            //产生一个随机数，添加到集合
            int number = r.nextInt(20)+1;
            set.add(number);
        }
        //遍历集合
        for (Integer i : set){
            System.out.println(i);
        }
    }
}

Map

Map集合概述:
·Interface Map<K,V> K:键的类型;V:值的类型
·将键映射到值的对象;不能包含重复的键;每个键可以映射最多一个值
·举例:学生的姓名和学号
itheima001 林青霞
itheima002 张曼玉
itheima003 王祖贤

创建Map集合的对象
·多态的方式
·具体的实现类HashMap

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class day1Map集合概述和使用 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<>();
        //添加元素
        //V put(K key, V value) 将指定的值与此映射中的指定键关联（可选操作）。
        map.put("itheima001","林青霞");
        map.put("itheima002","张曼玉");
        map.put("itheima003","王祖贤");
        map.put("itheima003","柳岩");
        //输出集合对象
        System.out.println(map);
    }
}
1
2
3
4
5
6
7
V put(K key, V value) 添加元素
V remove(Object key) 根据键删除值对元素
void clear() 移除所有的键值对元素
boolean containsKey(Object key) 判断集合是否包含指定的键
boolean containsValue(Object value) 判断集合是否包含指定的值
boolean isEmpty() 判断集合是否为空
int size() 集合的长度也就是集合中键值对的个数
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
import java.util.HashMap;
import java.util.Map;

public class day2Map集合的基本功能 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<>();
        //V put(K key, V value) 添加元素
        map.put("张无忌","赵敏");
        map.put("郭靖","黄蓉");
        map.put("杨过","小龙女");
        //V remove(Object key) 根据键删除值对元素
        System.out.println(map.remove("郭靖"));
        System.out.println(map.remove("郭想"));
        //void clear() 移除所有的键值对元素
        //map.clear();
        //boolean containsKey(Object key) 判断集合是否包含指定的键
        System.out.println(map.containsKey("郭靖"));
        System.out.println(map.containsKey("张无忌"));
        //boolean isEmpty() 判断集合是否为空
        System.out.println(map.isEmpty());
        //int size() 集合的长度也就是集合中键值对的个数
        System.out.println(map.size());
        //输出集合对象
        System.out.println(map);
    }
}

1
2
3
4
V get(Object key) 根据键获取值
Set<k>keySet() 获取所有键的集合
Collection<V>values() 获取所有值的集合
Set<Map.Entry<K,V>>entrySet() 获取所有键值对对象的集合
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
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class day3Map集合的获取功能 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<>();
        //添加元素
        map.put("张无忌","赵敏");
        map.put("郭靖","黄蓉");
        map.put("杨过","小龙女");
        //V get(Object key) 根据键获取值s
        System.out.println(map.get("张无忌"));
        System.out.println(map.get("张三丰"));
        //Set<k>keySet() 获取所有键的集合
        Set<String> keySet = map.keySet();
        for (String key: keySet){
            System.out.println(key);
        }
        //Collection<V>values() 获取所有值的集合
        Collection<String> values = map.values();
        for (String value : values){
            System.out.println(value);
        }
    }
}

我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合
遍历思路
1.把所有的丈夫集合起来
2.遍历丈夫的集合，获取每一个丈夫
3.根据丈夫去找对应的妻子

转换为Map集合中的操作
1.获取所有键的集合。用keySet()方法实现
2.遍历键的集合，获取每一个键。用增强for实现
3.根据键去找值。用get(Object key)方法实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class day4Map集合的遍历1 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<>();
        //添加元素
        map.put("张无忌","赵敏");
        map.put("郭靖","黄蓉");
        map.put("杨过","小龙女");
        //1.获取所有键的集合。用keySet()方法实现
        Set<String> keySet = map.keySet();
        //2.遍历键的集合，获取每一个键。用增强for实现
        for (String key:keySet){
            //3.根据键去找值。用get(Object key)方法实现
            String value = map.get(key);
            System.out.println(key+","+value);
        }
    }
}

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
//我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合
//遍历思路
//1.获得所有结婚证的集合
//2.遍历结婚证的集合，得到每一个结婚证
//3.根据结婚证获取丈夫和妻子

//转换为Map集合中的操作:
//获取所有键值对对象的集合
//Set<Map.Entry<K,V>>entrySet():获取所有键值对对象的集合
//遍历键值对对象的集合，得到每一个键值对对象
//用增强for实现，得到每一个Map.Entry
//根据键值对对象获取每一个键值对对象
//用getKey()得到键
//用getValue()得到值

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class day5Map集合的遍历2 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<>();
        //添加元素
        map.put("张无忌","赵敏");
        map.put("郭靖","黄蓉");
        map.put("杨过","小龙女");
        //获取所有键值对对象的集合
        Set<Map.Entry<String,String>> entrySet = map.entrySet();
        //遍历键值对对象的集合，得到每一个键值对对象
        for(Map.Entry<String,String> me : entrySet){
            //根据键值对对象获取每一个键值对对象
            String key = me.getKey();
            String value = me.getValue();
            System.out.println(key+","+value);
        }
    }
}

需求:
键盘录入一个字符串，要求统计字符串中每个字符出现的次数。
举例:键盘录入 “aababcabcdabcde” 在控制台输出:“a(5)b(4)c(3)d(2)e(1)”

分析:
①我们可以把结果分成几个部分来看:a(5),b(4),c(3),d(2),e(1)
②每一个部分可以看成是:字符和字符对应的次数组成
③这样的数据，我们可以通过HashMap集合来存储，键是字符，值是字符出现的次数
注意:键是字符，类型应该是Character；值是字符出现的次数，类型应该是Integer

思路:
键盘录入一个字符串
创建HashMap集合，键是Character，值是Integer
遍历字符串，得到一个字符
拿得到的每一个字符作为键到HashMap集合中去找对应的值，看起返回值
如果返回值是null：说明该字符在HashMap集合中不存在，就把该字符作为键，1作为值存储
如果返回值不是null：说明该字符在集合中存在，把值加1，然后重新存储该字符和对应的值
遍历HashMap集合，得到键和值，按照要求进行拼接
输出结果

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
import java.util.HashMap;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;

public class day10统计字符串中每个字符出现的次数 {
    public static void main(String[] args) {
        //键盘录入一个字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = sc.nextLine();
        //创建HashMap集合，键是Character，值是Integer
        //HashMap<Character,Integer> hm = new HashMap<Character,Integer>();
        TreeMap<Character,Integer> hm = new TreeMap<Character,Integer>();
        //遍历字符串，得到一个字符
        for (int i = 0; i < line.length() ;i++) {
            char key = line.charAt(i);
            //拿得到的每一个字符作为键到HashMap集合中去找对应的值，看起返回值
            Integer value = hm.get(key);
            if (value == null){
                //  如果返回值是null：说明该字符在HashMap集合中不存在，就把该字符作为键，1作为值存储
                hm.put(key,1);
            }else{
                //  如果返回值不是null：说明该字符在集合中存在，把值加1，然后重新存储该字符和对应的值
                value++;
                hm.put(key,value);
            }
        }
        //遍历HashMap集合，得到键和值，按照要求进行拼接
        StringBuilder sb = new StringBuilder();
        Set<Character> keySet = hm.keySet();
        for (Character key : keySet){
            Integer value = hm.get(key);
            sb.append(key).append("(").append(value).append(")");
        }
        String result = sb.toString();
        //输出结果
        System.out.println(result);
    }
}

Collections

Collections类的常用方法
·public static <T extends Comparable <?super T>> void sort(List list):将指定的列表按升序排序
·public static void reverse(List <?>list):反转指定列表中元素的顺序
·public static void shuffle(List<?> list):使用默认的随机源随机排列指定的列表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class day1Collections概述和使用 {
    public static void main(String[] args) {
        //创建集合对象
        List<Integer> list = new ArrayList<>();
        //添加元素
        list.add(30);
        list.add(20);
        list.add(50);
        list.add(10);
        list.add(40);
        //·public static <T extends Comparable <?super T>> void sort(List<T> list):将指定的列表按升序排序
        Collections.sort(list);
        //·public static void reverse(List <?>list):反转指定列表中元素的顺序
        Collections.reverse(list);
        //·public static void shuffle(List<?> list):使用默认的随机源随机排列指定的列表
        Collections.shuffle(list);
        System.out.println(list);
    }
}

需求:ArrayList存储学生对象，使用Collections对ArrayList进行排序
要求:按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序进行排序

思路:
①定义学生类
②创建ArrayList集合对象
③创建学生对象
④把学生添加到集合
⑤使用Collections对ArrayList集合排序
⑥遍历集合

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

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class day2ArrayList集合存储学生并排序 {
    public static void main(String[] args) {
        //创建ArrayList集合对象
        ArrayList<day2Student> array = new ArrayList<>();
        //创建学生对象
        day2Student s1 = new day2Student("linqingxia",30);
        day2Student s2 = new day2Student("zhangmanyu",35);
        day2Student s3 = new day2Student("wangzuxian",33);
        day2Student s4 = new day2Student("liuyan",33);
        //把学生添加到集合
        array.add(s1);
        array.add(s2);
        array.add(s3);
        array.add(s4);
        //使用Collections对ArrayList集合排序
        Collections.sort(array, new Comparator<day2Student>() {
            @Override
            public int compare(day2Student s1, day2Student s2) {
                int num = s1.getAge() - s2.getAge();
                int num2 = num==0?s1.getName().compareTo(s2.getName()):num;
                return num2;
            }
        });
        //遍历集合
        for (day2Student s : array){
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}