Java集合笔记

1.概述

1.1引入集合

目前程序中，如果出现了多个数据需要存储，解决方案就是数组，但是数组的缺点却很明显：

– 长度固定，数组一旦创建长度不可改变

– 数组里元素的类型太单调，都是不统一的

– 数组的遍历方式太单一，用下标遍历

– 如果有大量的数据需要存储，可以使用集合

– 集合工具类，都在java.util.*包里

1.2继承结构

– Collection是顶级接口

​ – List接口：

​ --ArrayList实现类

​ --LinkedList实现类

​ – Set接口：

​ – HashSet实现类

​ – TreeSet实现类

– Map接口

2.Collection

2.1介绍

– Collection层次结构中的根接口，Collction表示一组对象，这些对象也称为collection的元素。一些collection允许有重复的元素，而另一些则不允许。一些collection是有序的，而另一些则是无序的。

2.2方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JZ38Asfx-1598109912072)(C:\Users\徐茂鑫\AppData\Roaming\Typora\typora-user-images\image-20200816140144989.png)]

2.3TestCollection

//测试 集合
public class TestCollection {
    public static void main(String[] args) {
        //1,创建对象
        Collection<Integer> c = new ArrayList<>();
        //2,常用方法
        c.add(1);
        c.add(2);
        c.add(3);
        c.add(5);
        c.add(4);
        //		c.clear();//清空集合
        System.out.println(c.contains(1) );//判断是否包含指定元素
        System.out.println(c.equals(1) );//判断集合是否和指定元素相等
        System.out.println(c.hashCode() );//获取集合在内存中的哈希码值
        System.out.println(c.isEmpty() );//判断集合是否为空
        System.out.println(c.remove(2) );//移除指定元素,返回布尔值
        System.out.println(c.size() );//获取集合的长度
        Object[] os = c.toArray() ;//把元素存入数组
        //[1, 3, 5, 4]
        System.out.println( Arrays.toString(os) );
        //----------集合间的操作
        Collection<Integer> c2 = new ArrayList<>();
        c2.add(1);
        c2.add(2);
        c2.add(3);
        System.out.println( c.addAll(c2) );//把c2添加到c里面 1354123
        System.out.println( c.containsAll(c2) );//判断c中是否包含c2
        //System.out.println( c.removeAll(c2) );//删除交集元素
        System.out.println( c.retainAll(c2) );//取差集 13123 
        System.out.println(c);
        //TODO 迭代/循环/遍历  集合
        //		Iterator<E> iterator()  --返回可以迭代集合的迭代器
        Iterator<Integer> it = c.iterator() ;
        while( it.hasNext() ) {//判断集合中是否有下一个元素,有就返回true
            Integer in = it.next() ;//获取下一个元素
            System.out.println(in);
        }
    }
}

运行结果：
true
false
29615296
false
true
4
[1, 3, 5, 4]
true
true
true
[1, 3, 1, 2, 3]
1
3
1
2
3

3.List

3.1List接口

3.1.1介绍

有序的collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确的控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。与set不同，列表通常允许重复的元素。列表本身允许null元素，通常它们允许多个null元素

3.1.2特点

– 元素有序

– 元素有下标

– 允许重复元素

– 可以存null元素

3.1.3常用方法

1.从超级接口Collection中继承来的

2.特有方法

void add(int index, E element) 
	在列表的指定位置插入指定元素（可选操作）。 
boolean addAll(int index, Collection<? extends E> c) 
    将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。 
E get(int index) 
	返回列表中指定位置的元素。 
int indexOf(Object o) 
	返回此列表中第一次出现的指定元素的索引； 
int lastIndexOf(Object o) 
	返回此列表中最后出现的指定元素的索引 
ListIterator<E> listIterator() 
	返回此列表元素的列表迭代器（按适当顺序）。 
E remove(int index) 
	移除列表中指定位置的元素（可选操作）。 
E set(int index, E element) 
	用指定元素替换列表中指定位置的元素（可选操作）。 返回以前在指定位置的元素 
List<E> subList(int fromIndex, int toIndex) 
	返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分

3.1.4TestList

//测试 List接口
public class TestList {
    public static void main(String[] args) {
        //1,创建对象
        List<String> list = new ArrayList<>() ;

        //2,常用方法
        //TODO --继承自Collection接口的方法
        list.add("xiongda");
        list.add("xionger");
        list.add("guangtq");
        list.add(null);

        list.add("xiongda");
        list.add("xionger");
        //List特点:元素有序+元素可以重复+可以存null+元素都有下标
        System.out.println(list);
        //----List接口的特有方法们---都是根据下标操作数据的方式
        list.add(2,"美队") ;//在指定下标处,插入指定的元素
        System.out.println(list);
        System.out.println(list.get(2));//根据下标获取元素
        //获取指定元素第一次出现的索引值
        System.out.println( list.indexOf("xiongda") );
        //获取指定元素最后一次出现的索引值
        System.out.println( list.lastIndexOf("xiongda") );
        System.out.println( list.remove(2) );//按照索引删除元素并返回被删除的元素是谁
        System.out.println( list.set(1, "皮皮霞"));//把指定索引对应的值替换掉
        //截取前:[xiongda, 皮皮霞, guangtq, null, xiongda, xionger]
        List<String> list2 = list.subList(2, 4);//[2,4)含头不含尾的截取子List
        System.out.println(list2);//截取前:[guangtq, null]

        //TODO 迭代List接口的方式:
        //Iterator<E> iterator()
        Iterator<String> it = list.iterator() ;
        while(it.hasNext()) {//判断有下一个元素吗
            String s = it.next() ;//获取下一个元素
            System.out.println(s);
        }
        //Iterator<E> iterator()  --继承自Collection--返回父接口--向后遍历
        //ListIterator<E> listIterator() --子接口List--返回子接口--向后遍历/逆向遍历
        ListIterator<String> it2 = list.listIterator() ;
        while(it2.hasNext()) {//判断有下一个元素吗
            String s = it2.next() ;//获取下一个元素
            System.out.println(s);
        }
        //for循环
        for(int i = 0 ; i < list.size() ; i++) {
            System.out.println( list.get(i) );
        }
        //增强for/foreach -- for(数据的类型   变量名 : 要遍历的数据 ){  }
        for(String s : list) {
            System.out.println(s);
        }
    }
}

//运行结果：（除去最后四种遍历）
[xiongda, xionger, guangtq, null, xiongda, xionger]
[xiongda, xionger, 美队, guangtq, null, xiongda, xionger]
美队
0
5
美队
xionger
[guangtq, null]

3.2ArrayList实现类

3.2.1介绍

– List接口的大小可变数组的实现。每个ArrayList实例都有一个容量。该容量是指用来存储列表元素的数组的大小

3.2.2特点

– 元素有下标

– 元素可重复

– 元素有序

– 底层是一个数组，方便查询

3.2.3常用方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u6EgWnRr-1598109912082)(C:\Users\徐茂鑫\AppData\Roaming\Typora\typora-user-images\image-20200816160421754.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AvqYgdtn-1598109912085)(C:\Users\徐茂鑫\AppData\Roaming\Typora\typora-user-images\image-20200816160502166.png)]

3.2.4创建对象

new ArrayList();//构造一个初始容量为10的空列表,返回类型ArrayList，即ArrayList<> list = new ArrayList<>(); <>为泛型

3.2.5TestArrayList

//测试 ArrayList
public class TestArrayList {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        System.out.println(list);
        list.add("aaa");
        list.add("nnn");
        list.add("ttt");
        list.add("jjj");
        list.add("kkk");
        list.add("qqq");
        list.add("ccc");
        list.add("aaa");
        list.add("aaa");
        list.add("aaa");
        list.add("hhh");
        list.add("yyy");
        System.out.println(list.size());
        System.out.println(list);
        System.out.println(list.get(0));
        System.out.println(list.get(list.size()-1));
        System.out.println(list.remove(5));
        System.out.println(list);
        System.out.println(list.remove("aaa"));
        System.out.println(list);
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        //迭代器遍历
        for (Iterator it = list.iterator(); it.hasNext();) {
            String s = (String) it.next();
            System.out.println(s);
        }
        //foreach 简化的迭代器遍历
        for (String s : list) {
            System.out.println(s);
        }
    }
}

//运行结果：（除去遍历）
[]
12
[aaa, nnn, ttt, jjj, kkk, qqq, ccc, aaa, aaa, aaa, hhh, yyy]
aaa
yyy
qqq
[aaa, nnn, ttt, jjj, kkk, ccc, aaa, aaa, aaa, hhh, yyy]
true
[nnn, ttt, jjj, kkk, ccc, aaa, aaa, aaa, hhh, yyy]

3.3LinkedList实现类

3.3.1介绍

– 是List接口的链接列表实现

3.3.2特点

– 元素有下标

– 元素可重复

– 元素有序

– 底层是链表结构

3.3.3常用方法

1.继承自Collection的方法

2.继承自List的方法

3.自己特有的方法

void addFirst(E e) 
	将指定元素插入此列表的开头。 
void addLast(E e) 
	将指定元素添加到此列表的结尾。 
E getFirst() 
	返回此列表的第一个元素。 
E getLast() 
	返回此列表的最后一个元素。
E removeFirst() 
	移除并返回此列表的第一个元素。 
E removeLast() 
	移除并返回此列表的最后一个元素。 
boolean offer(E e) 
	将指定元素添加到此列表的末尾（最后一个元素）。 
boolean offerFirst(E e) 
	在此列表的开头插入指定的元素。 
boolean offerLast(E e) 
	在此列表末尾插入指定的元素。 
E peek() 
	获取但不移除此列表的头（第一个元素）。 
E peekFirst() 
	获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。 
E peekLast()
    检索但不删除此列表的最后一个元素，如果此列表为空，则返回 null 。
E poll() 
	获取并移除此列表的头（第一个元素） 
E pollFirst() 
	获取并移除此列表的第一个元素；如果此列表为空，则返回 null。 
E pollLast() 
	获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。 

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-x0ExAFeI-1598109912093)(C:\Users\徐茂鑫\AppData\Roaming\Typora\typora-user-images\image-20200816160839414.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u2ITu9at-1598109912168)(C:\Users\徐茂鑫\AppData\Roaming\Typora\typora-user-images\image-20200816160904770.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qktV4fnp-1598109912170)(C:\Users\徐茂鑫\AppData\Roaming\Typora\typora-user-images\image-20200816160938164.png)]

3.3.4创建对象

LinkedList<> list = new LinkedList<>();//创建一个空列表

3.3.5TestLinkedList

//测试 LinkedList
public class TestLinkedList {
    public static void main(String[] args) {
        //1,创建对象--底层是链表结构
        LinkedList<Integer> list = new LinkedList<>();
        //2,常用方法
        //TODO 继承自List接口的方法
        //TODO 继承自Collection接口的方法
        list.add(1);
        list.add(2);
        list.add(3);
        System.out.println(list);
        //--实现类自己的特有方法--针对首尾元素进行操作
        list.addFirst(99);//添加首元素
        list.addLast(100);//添加尾元素
        System.out.println(list);//[99, 1, 2, 3, 100]
        System.out.println( list.getFirst());//获取首元素
        System.out.println( list.getLast());//获取尾元素

        System.out.println( list.removeFirst());//移除首元素
        System.out.println( list.removeLast());//移除尾元素
        System.out.println(list);//[1, 2, 3]

        System.out.println(list.offer(50));//在末尾添加元素
        System.out.println(list);
        System.out.println(list.offerLast(51));//在末尾添加元素
        System.out.println(list);
        System.out.println(list.offerFirst(52));//在末尾添加元素
        System.out.println(list);
    }
}

//运行结果：
[1, 2, 3]
[99, 1, 2, 3, 100]
99
100
99
100
[1, 2, 3]
true
[1, 2, 3, 50]
true
[1, 2, 3, 50, 51]
true
[52, 1, 2, 3, 50, 51]

4.Set

4.1Set接口

4.1.1介绍

– 一个不包含重复元素的Collection，最多包含一个null元素

4.1.2特点

– 元素无序

– 元素没有下标

– 元素不能重复

4.1.3方法

全都是继承自Collection的方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HD4Tr8UK-1598109912173)(C:\Users\徐茂鑫\AppData\Roaming\Typora\typora-user-images\image-20200816165329440.png)]

4.1.4TestSet

//测试 Set接口
public class TestSet {
    public static void main(String[] args) {
        //1,创建对象 -- set通常用来给数据去重!!!
        Set<String> set = new HashSet<>();
        //TODO 2,常用方法
        //全都是 继承自Collection接口的方法
        set.add("2a");
        set.add("1b");
        set.add("d");
        set.add("c");
        set.add("jack");
        set.add(null);

        set.add("2a");
        set.add("1b");
        set.add("d");
        //set是无序的+可以添加一个null+元素不能重复!!!
        System.out.println(set);
        //迭代set集合里的元素
        //方式1:Iterator<E> iterator()
        Iterator<String> it = set.iterator() ;
        while(it.hasNext()) {//判断,有元素就返回true
            String s = it.next() ;//获取元素
            System.out.println(s);
        }
        //方式2:foreach
        for(String s : set) {
            System.out.println(s);
        }
    }
}

//运行结果：
[null, 1b, c, d, jack, 2a]
null
1b
c
d
jack
2a
null
1b
c
d
jack
2a

4.2HashSet

4.2.1介绍

– 此类实现Set接口，由哈希表（实际上是一个HashMap实例）支持。他不保证set的迭代顺序。

– 通过hashCode()计算出元素的存储位置，并将这些元素正确地分布在桶中。对此set进行迭代所需的时间与HashSet的实例的大小（元素数量）和底层HashMap实例（桶的数量）的“容量”的和成正比。因此，如果迭代性能很重要，则不要将初始容量设置太高（或将加载因子设置的太低）

4.2.2特点

– 元素没有下标

– 元素不能重复

– 元素无序

– 底层是哈希表/散列表

4.2.3创建对象

HashSet<> set = new HashSet<>();
//创建一个空的set，其底层HashMap实例的默认初始容量是16，加载因子是0.75

4.2.4方法

继承自Set接口

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IGnvtZRU-1598109912178)(C:\Users\徐茂鑫\AppData\Roaming\Typora\typora-user-images\image-20200816171406490.png)]

4.2.5TestHashSet

//测试 HashSet
public class TestHashSet {
    public static void main(String[] args) {
        //TODO 1,创建对象--桶--性能:初始值+加载因子
        //我们创建的是HashSet对象,但是底层实际上是创建了一个HashMap对象
        HashSet<Double> set = new HashSet<>();

        //TODO 2,常用方法
        //我们是向HashSet中添加数据,但是底层实际上是向HashMap中添加的
        set.add(1.1);
        set.isEmpty();//判断是否为空 false
        set.add(2.0);
        set.add(1.5);
        set.add(2.5);
        System.out.println(set);
        System.out.println(set.size());//大小
        Object set2 = set.clone();
        System.out.println(set2);
        set.clear();
        System.out.println(set);
    }
}

//运行结果：
[2.0, 2.5, 1.5, 1.1]
4
[2.0, 1.5, 1.1, 2.5]
[]

5.Map

5.1Map接口

5.1.1介绍

– 将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

– Map接口提供三种collection视图，允许以键集、值集或键值映射关系集的形式查看某个映射的内容。映射顺序定义为迭代器在映射的collection视图上返回其元素的顺序。某些映射实现可明确保证其顺序，如TreeMap类；另一些映射实现则不保证顺序，如HashMap类

5.1.2特点

– 每个键对应一个值

– 其中键不能重复

– 存的数据是键值对格式

– HashMap是无序的，TreeMap是有序的

5.1.3创建对象

接口无法创建对象，只能创建实现类对象

6.Collections工具类

6.1介绍

– 提供了大量的针对collection集合的静态方法

6.2常用方法

static <T> boolean addAll(Collection<? super T> c, T... elements) 
	将所有指定元素添加到指定 collection 中。 
static T  max(Collection<? extends T> coll) 
	根据元素的自然顺序，返回给定 collection 的最大元素。 
static T  min(Collection<? extends T> coll) 
	根据元素的自然顺序 返回给定 collection 的最小元素。 
static void reverse(List<?> list) 
	反转指定列表中元素的顺序。 
static void  sort(List<T> list) 
	根据元素的自然顺序 对指定列表按升序进行排序。 
static void swap(List<?> list, int i, int j) 
	在指定列表的指定位置处交换元素。

6.3TestCollections

//测试 集合工具类Collections
public class TestCollections {
    public static void main(String[] args) {
        //TODO 创建List集合,并添加元素
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(7);
        list.add(9);
        list.add(3);
        System.out.println(list);//[1, 7, 9, 3]

        //static <T> boolean addAll(Collection<? super T> c, T... elements)
        Collections.addAll(list, 2,4,6,8);//向指定集合中,一次性添加多个数据
        System.out.println(list);//[1, 7, 9, 3, 2, 4, 6, 8]

        //static T  max(Collection<? extends T> coll)
        //获取list集合里的最大值
        System.out.println( Collections.max(list) );

        //static T  min(Collection<? extends T> coll)
        //获取list集合里的最小值
        System.out.println( Collections.min(list) );

        //static void reverse(List<?> list)
        Collections.reverse(list);//指定的list集合中的数据进行反转
        System.out.println(list);//[8, 6, 4, 2, 3, 9, 7, 1]

        //static void  sort(List<T> list)
        Collections.sort(list);//指定的list集合中的数据进行排序
        System.out.println(list);//[1, 2, 3, 4, 6, 7, 8, 9]

        //static void swap(List<?> list, int i, int j)
        Collections.swap(list, 1, 6);//把list中,指定下标的两个元素进行位置交换
        System.out.println(list);//[1, 8, 3, 4, 6, 7, 2, 9]
    }
}