java基础之集合_单列有序集合

集合

基础里的重头戏来喽

一. 集合概述

集合和数组的区别

• 概述

集合是java中用来存放多个 引用数据类型 数据的容器，它是解决了数组的一些弊端的一个多数据容器,他有 的操作集合的方法,(比如增加和删除方法)。 
    java中集合的体系使用接口和类进行体现使用的。d
1
2

• 相同点

都是存放对个数据的容器
1

• 不同点

数组：
1、可以存放任意数据类型数据 int[] Person[] String[] double[] 
2、创建后长度固定不变 new int[3]; 
3、创建后只能存放单一数据类型数据 int[] arr = new int[]; 
集合：
1、只能存放引用数据类型的数据 
2、集合长度可变的 
3、可以同时存放多种数据类型的数据 【实际开发的时候尽量不这么干】一个集合对象只存一种引用类型的据.
1
2
3
4
5
6
7
8

集合体系结构

二. 单列集合

Collection常用功能

• 概述

Collection是单列集合的顶层接口，定义了所有单列集合功能的行为声明，他的功能需要单列集合的实现类 去实现，他功能通过实现类对象来使用。今天对于Collection的功使用典型的实现类ArrayList实现。 也就是为了研究Collection中共性方法,使用Collection类型引用,指向ArrayList实现类对象.

• 创建Collection集合的对象

Collection是一个接口不能直接创建对象,使用实现类ArrayList来创建对象使用
大部分的集合创建对象用的都是空参构造

Collection c = new ArrayList(); // 一个集合对象就创建好了
1
2
3
4

• Collection集合常用方法

	1.boolean add(E e)  //添加元素
    2.boolean remove(Object o) //丛集合中
    3.boolean removeif(Object o) //根据条件移除元素
    4.void clear()  //清空集合元素
    5.boolean contains(Object o) //判断集合中是否存在指定的元素
    6.boolean isEmpty() //判断集合是否为空
    7.int size() //集合长度
        
1
2
3
4
5
6
7
8

单列集合遍历

• 1.迭代器遍历

迭代器：他本身就是一个定义了专门对集合进行遍历功能的一个接口

原理： 
集合对象通过相关方法得到迭代器的对象，迭代器的对象调用相关方法遍历集合 
获取迭代器对象功能：集合提供相关功能 
iterator():获取Iterator类型的迭代器实现类对象【属于Collection的功能】 
listIterator():获取ListIterator类型的迭代器对象【子接口中的迭代器 Collection没有的】 迭代器的功能： 
    Iterator： 
    hasNext():判断下个位置是否有元素 返回boolean类型的值 有返回true, 否则返回false 
    next():获取集合位置上的元素，同时移动迭代器指针到下个位置 
    remove():删除当前元素 ListIterator： 
    add(element):添加元素
1
2
3
4
5
6
7
8
9
10

注意增删操作:(并发修异常的产生原因和解决办法)

使用迭代器添加元素.删除元素

• 2.增强for遍历

增强for遍历也名foreach遍历，他的底层是使用迭代器遍历的一个全新格式。
增强for遍历本质是迭代器遍历。
1
2

• 格式:

格式:
for(数据类型 变量名 : 容器对象){ 
    对集合元素的操作逻辑 
}
解释： 
    数据类型：集合中存放的数据的数据类型 
    变量名：存放每次迭代到的元素的具体的值 
    集合名称：要遍历的集合容器
    它不只能遍历集合,还能数组
1
2
3
4
5
6
7
8
9

• 3.数组法遍历

把集合元素转存到一个数组中，遍历数组取出元素就是集合的元素, 这种遍历方式不是直接的遍历集合的方 式.而且间接的遍历方式.
    集合变数组:

1.toArray():把集合元素转变为一个Object数组
2.toArray(Object[] arr) :把集合的元素转换为指定类型数组 【前提：集合的数据类型指定】
    
1
2
3
4
5
6

• 注意事项:

注意事项： 
1、人为创建的数组长度和集合的长度以及数据类一致，系统不会创建数组 
2、人为创建的数组长度比集合的长度小：系统根据集合的长度以及数组的数据类型自动创建对应的数组 
3、人为创建的数组长度比集合的长度大：不会自动创建数组 多余的位置使用null补全
1
2
3
4

有序单列集合

• 概述

有序集合指的是Collection的分支，有序集合的顶层接口是List，List除了继承Collection接口的所有 功能和方式外具有自己的特有功能和遍历方式

• 特点:

1、有序：对集合的存取数据的顺序一致 
2、有索引：存放数据的位置有编号【原理和数组的元素索引一样的】
3、元素可重复：同一个集合中可以同时存放多个相同的元素
1
2
3

• List集合的特有方法

1.void add(int index,E element)  //在此集合中的指定位置插入指定的元素
2.E remove(int index)  //删除指定索引处的元素，返回被删除的元素
3.E set(int index,E element)  //修改指定索引处的元素，返回被修改的元素
4.E get(int index) //返回指定索引处的元素
    
    
    //举个栗子
List list = new ArrayList();  // List是一个接口,不能实例化,所以要指向他的实现类ArrayList
list.add(0,"a");
list.add(1,"b");
System.out.println(list) //[a,b]  有序
Object o = list.remove(0) //a  返回被删除的元素
1
2
3
4
5
6
7
8
9
10
11
12

数据结构

• 概述

数据结构是计算机存储,组织数据的方式,通常情况下, 精心选择的数据结构可以带来更高的运行和存储效率
1

• 栈

栈: stack,又称堆栈,简称栈，它是运算受限的线性表，其限制是仅允许在标记的一端进行插入和删除操作， 不允许在其他任何位置进行添加、查找、删除等操作。 

特点: 先进后出 (FILO LIFO),（即，存进去的元素，要在后它后面的元素依次取出后，才能取出该元 素）。例如，子弹压进弹夹，先压进去的子弹在下面，后压进去的子弹在上面，当开枪时，先弹出上面的子弹，然后才能弹出下面的子弹
1
2
3

压栈：就是存元素。即，把元素存储到栈的顶端位置，栈中已有元素依次向栈底方向移动一个位置。
弹栈：就是取元素。即，把栈的顶端位置元素取出，栈中已有元素依次向栈顶方向移动一个位置。
1
2

• 队列

queue,简称队，它同堆栈一样，也是一种运算受限的线性表，其限制是仅允许在表的一端进行插入，而在表 的另一端进行删除

特点: 
1. 先进先出(FIFO, LILO)（即，存进去的元素，要在后它前面的元素依次取出后，才能取出该元素）。 例如，小火车过山洞，车头先进去，车尾后进去；车头先出来，车尾后出来。
2. 队列的入口、出口各占一侧。例如，下图中的左侧为入口，右侧为出口
1
2
3
4
5

• 数组

Array:是有序的元素序列，数组是在内存中开辟一段连续的空间，并在此空间存放元素。就像是一排出租 屋，有100个房间，从0到99每个房间都有固定编号，通过编号就可以快速找到租房子的人。 
    数组特点:查改快, 增删慢
    
    特点:
特点查改找元素快: 起始地址 + 索引*每个元素所占空间大小 
    只需要经过一次寻址就可以找到元素 通过可以快速访问指定位置的元素
    
增加元素慢: 指定索引位置增加元素：需要创建一个新数组，将指定新元素存储在指定索引位置，再把原数组元素根据 索引，复制到新数组对应索引的位置。
1
2
3
4
5
6
7
8

• 链表

链表:linked list, 由一系列结点node（链表中每一个元素称为结点）组成，结点可以在运行时动态生 成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。我们常说的链表结构有单向链表与双向链表，
1

(一)有序单列集合实现类

1. ArrayList

ArrayList是List的典型实现类，没有自己的特有功能，功能都是List接口中的功能。 底层采用数组结构构建的一个实现类集合
    
    1. 在创建ArrayList集合对象的时候,会维护一个长度为10的Object类型的数组. 
    2. 当插入数据10个长度不够,这时候以1.5倍的形式进行扩容
1
2
3
4

2.LinkedList

LinkedList是List的另一个常用实现类集合，底层采用的是双向链表结构构建而成有自己的特有功能，特有功能基本上是对集合首尾元素的操作功能，实际开发中主要使用它的特有功能方便元素添加、删除。
1

提供这两个属性原因就是为了方便查找元素, 当我们根据索引查找一个元素的时候, 计算这
个索引距离头部近还是尾部近, 距离那个近就从那开始查,尽量提供查询的的效率.
1
2

• LinkedList的常用功能

	1.public void addFirst(E e): //将指定元素插入此列表的开头。 
    2.public void addLast(E e): //将指定元素添加到此列表的结尾。 
    3.public E getFirst(): //返回此列表的第一个元素。 
    4.public E getLast(): //返回此列表的最后一个元素。 
    5.public E removeFirst(): //移除并返回此列表的第一个元素。 
    6.public E removeLast(): //移除并返回此列表的最后一个元素。 
    7.public E pop(): //从此列表所表示的堆栈处弹出一个元素。 
    8.public void push(E e): //将元素推入此列表所表示的堆栈。
1
2
3
4
5
6
7
8

(二)无序单列集合

1. set集合

• 概述

Set集合也是Collection的分支，他没有自己独有的功能和遍历方式，他的功能和遍历方式全部来自于 Collection 
只不过功能更加的严谨了。
Set集合是无序集合的顶层接口,学习的时候学习典型的实现类HashSet。 Set s = new HashSet();
1
2
3

• 特点 ( )

1、无序：存取顺序不一致 
2、没有索引 
3、元素唯一：set集合只能存放单一元素
1
2
3

• Set实现类

1.HashSet  //存取的顺序不一致且唯一；
     Set<String> s = new HashSet();
        //无序
        s.add("a");
		set.add("a");
        s.add("c");
        s.add("b");
        s.add("d");
		System.out.println(s);//[a, b, c, d]

2.LinkedHashSet  //对数据进行了去重的同时还要保证数据原有的顺序
    //举例
    HashSet<String> set = new HashSet<>();
       set.add("a");
	   set.add("a");
       set.add("c");
       set.add("b");
       set.add("d");
       System.out.println(set);//[a, b, c, d]
    
3.TreeSet //TreeSet是Set集合的常用实现类，使用的时候自动对集合内部的元素进行排序
    //举例
    TreeSet<String> set = new TreeSet<>();
        set.add("abc");
        set.add("a");
        set.add("acs");
        System.out.println(set);//[a, abc, acs]
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

TreeSet 的自然排序和比较器排序

• TreeSet集合的概述

TreeSet是Set集合的常用实现类，使用的时候自动对集合内部的元素进行排序 3 2 1 ---> 1 2 3 使用和和两个构造方法有关系 
    TreeSet()：默认升序排序【自然排序】 
    TreeSet(Comprator c):按照指定的排序原则进行排序【比较器排序】
1
2
3

HashSet集合的元素唯一性原理分析

• 哈希值

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

三. 双列集合

(一) Map接口的常用功能

• 概述

Map<K,V>是一个接口,是双列集合的顶层接口，定义了所有双列集合的功能功能和遍历方式

双列集合：就是一个用来存放多个键值对数据的容器 
键值对：一对一的映射关系的一对数据, 映射的意思就是可以通过一个值找到另一值意思,在Map集合中含义 就是可以通过Key值找到Value值.

比如：age=18 age就是:key 18就是value.
name="小翔" name:键 "小翔":值 键值对.
1
2
3
4
5
6
7

• 特点

1、存放的是键值对数据 
2、无序集合 (存取顺序不一致) 
3、键要唯一(key唯一)
1
2
3

• Map常用的实现类介绍

HashMap<K,V>:存储数据采用的哈希表结构(HashSet底层就是HashMap)，元素的存取顺序不能保证一致。
要保证键的唯一、不重复

LinkedHashMap<K,V>:HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。
通过链表结构可以保证元素的存取顺序一致

HashMap和Hashtable的区别： 
1、出现时机不一样 HashMap是jdk1.2出现的 Hashtable是jdk1.0出现
2、线程安全不一样 HashMap是线程不安全的 Hashtable是线程安全的 
3、效率不一样 HashMap效率高 Hashtable效率低
4、存放数据要求不一样 HashMap是支持null值和null键的 Hashtable是不支持null数据的
1
2
3
4
5
6
7
8
9
10
11

• Map接口中常用的方法

1.public V put(K key, V value):  //把指定的键与指定的值添加到Map集合中。 
2.public V remove(Object key): //把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素 的值。 
3.public V get(Object key): //根据指定的键，在Map集合中获取对应的值。 
4.boolean containsKey(Object key):  //判断集合key中是否包含指定的元素。
5.boolean containsValue(Object value):  //判断集合value中是否包含指定的元素。 

三种遍历方式:
键遍历 6.public Set<K> keySet():  //获取Map集合中所有的键，存储到Set集合中。 
值遍历 7.public Collection<V> values(): //获取Map集合中所有值，存放到Collection集合中 
键值对遍历 8.public Set<Map.Entry<K,V>> entrySet()://获取到Map集合中所有的键值对对象的集合(Set集合)。


//举例
Map<String, Integer> map = new HashMap<>();
map.put("max", 100); 
map.put("min", 0); 
map.put("mid", 50);
map.put("max", 1000); // 当添加的时候有相同key值出现,就会替换之前key的value值.
map.put(null, null); // key和value允许为null

Integer value = map.remove("min");//remove
Integer mid = map.get("mid");  // get
boolean b1 = map.containsKey("max1"); // containsKey()
boolean b2 = map.containsValue(50); //containsValue()

三种遍历方式:
键遍历: Set<String> keys = map.keySet();//keySet() 获取Map集合中所有的键,存储到Set集合中。

//values()  获取Map集合中所有值,存放到Collection集合中
值遍历: Collection<Integer> values = map.values(); 

键值对遍历: Set<Map.Entry<Character, Integer>> set = map.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
30
31
32
33
34
35

• HashMap和HashSet的关系

HashMap没有特别的方法需要研究,因为方法在Map接口中介绍完了. 
我们只需要研究HashMap保持键值对唯一的原因即可. 
HashSet集合底层是由HashMap构建的【HashSet维护了一个HashMap】 
HashSet集合的数据添加在HashMap集合中的。 
HashSet的存值原理其实也是HashMap的存值原理。
1
2
3
4
5

LinkedHashMap

LinkedHashMap<K,V>:HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。
    通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的 hashCode()方法、equals()方法。
    特点：有序的Map集合 都可以存放键的值为null
    
    LinkedHashMap<String, Integer> map = new LinkedHashMap<>(); 
map.put("height", 173); 
map.put("age", 80); 
map.put("age", 18); 
System.out.println(map);//{height=173, age=18}
1
2
3
4
5
6
7
8
9

TreeMap

该映射根据其键的自然顺序进行排序，或者根据创建映射时提供的 Comparator 进行排序，具体取决于使用的构造方法。
1

四. Collections 工具类

可变参数的使用和注意事项

• 概述

可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了
使用场景: 方法的参数类型已经确定, 个数不确定, 我们可以使用可变参数. 
【相同类型的多个形参的方法的参数列表变形】
1
2
3

• 格式

修饰符 返回值类型 方法名(数据类型… 变量名) { } 
调用带有可变参数的方法时,可以传入0~n个实参给可变参数赋值.
1
2

• 注意事项

1.这里的变量其实是一个数组 
2.如果一个方法有多个参数，包含可变参数，可变参数要放在最后
3.一个方法中只能使用一个可变参数
1
2
3

Collections常用功能

• 概述

Collections类是和一个工具类,在类中封装类很多常用的操作集合的方法. 它不止能操作单列集合,也能操 作双列集合. 
1.不能创建对象 
2.类中内容都是静态的(静态属性和静态方法)
1
2
3

• 常用方法

1.public static void sort(List list)  //将指定的列表按升序排序
2.public static void reverse(List<?> list)  //反转指定列表中元素的顺序
3.public static void shuwle(List<?> list)  //使用默认的随机源随机排列指定的列表
    
    
    //举例
List<Integer> list = new ArrayList<>(); 
list.add(100); 
list.add(50); 
list.add(70);
System.out.println(list); // [100, 50, 70]

Collections.sort(list); 
System.out.println(list); //[100,70,50]

Collections.reverse(list); 
System.out.println(list);//[50,70,100]

Collections.shuffle(list); 
System.out.println(list);//[70,50,100]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

//将指定的列表按升序排序
2.public static void reverse(List<?> list)  //反转指定列表中元素的顺序
3.public static void shuwle(List<?> list)  //使用默认的随机源随机排列指定的列表
    
    
    //举例
List<Integer> list = new ArrayList<>(); 
list.add(100); 
list.add(50); 
list.add(70);
System.out.println(list); // [100, 50, 70]

Collections.sort(list); 
System.out.println(list); //[100,70,50]

Collections.reverse(list); 
System.out.println(list);//[50,70,100]

Collections.shuffle(list); 
System.out.println(list);//[70,50,100]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20