1. 集合
1.1. 什么是集合
存储对象的容器，面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，存储对象，集合是存储对象最常用的一种方式。
集合的出现就是为了持有对象。集合中可以存储任意类型的对象, 而且长度可变。在程序中有可能无法预先知道需要多少个对象, 那么用数组来装对象的话, 长度不好定义, 而集合解决了这样的问题。
1.2. 集合和数组的区别
数组和集合类都是容器
数组长度是固定的，集合长度是可变的。数组中可以存储基本数据类型，集合只能存储对象数组中存储数据类型是单一的，集合中可以存储任意类型的对象。
集合类的特点
用于存储对象，长度是可变的，可以存储不同类型的对象。
1.2.1. 数组的缺点
存储类型单一的数据容器，操作复杂(数组一旦声明好不可变)CRUD
1.3. 集合的分类
集合做什么
1：将对象添加到集合
2：从集合中删除对象
3: 从集合中查找一个对象
4：从集合中修改一个对象就是增删改查
注意：集合和数组中存放的都是对象的引用而非对象本身
Java工程师对不同的容器进行了定义,虽然容器不同,但是还是有一些共性可以抽取最后抽取了一个顶层接口,那么就形成了一个集合框架。如何学习呢?当然是从顶层学起,顶层里边具有最共性,最基本的行为。具体的使用,就要选择具体的容器了。为什么? 因为不断向上抽取的东西有可能是不能创建对象的.抽象的可能性很大，并且子类对象的方法更多一些. 所以是看顶层,创建底层。那么集合的顶层是什么呢 叫做Collection集合框架体系
---|Collection: 单列集合
---|List: 有存储顺序, 可重复
---|ArrayList: 数组实现, 查找快, 增删慢
由于是数组实现, 在增和删的时候会牵扯到数组
增容, 以及拷贝元素. 所以慢。数组是可以直接
按索引查找, 所以查找时较快
---|LinkedList: 链表实现, 增删快, 查找慢
由于链表实现, 增加时只要让前一个元素记住自
己就可以, 删除时让前一个元素记住后一个元
素, 后一个元素记住前一个元素. 这样的增删效
率较高但查询时需要一个一个的遍历, 所以效率
较低
---|Vector: 和ArrayList原理相同, 但线程安全, 效率略低
和ArrayList实现方式相同, 但考虑了线程安全问
题, 所以效率略低
---|Set: 无存储顺序, 不可重复
---|HashSet
---|TreeSet
---|LinkedHashSet
---| Map: 键值对
---|HashMap
---|TreeMap
---|HashTable
---|LinkedHashMap1.4. 什么时候该使用什么样的集合
Collection |
我们需要保存若干个对象的时候使用集合。 |
| List |
如果我们需要保留存储顺序, 并且保留重复元素, 使用List. 如果查询较多, 那么使用ArrayList 如果存取较多, 那么使用LinkedList 如果需要线程安全, 那么使用Vector |
| Set |
如果我们不需要保留存储顺序, 并且需要去掉重复元素, 使用Set. 如果我们需要将元素排序, 那么使用TreeSet 如果我们不需要排序, 使用HashSet, HashSet比 TreeSet效率高. 如果我们需要保留存储顺序, 又要过滤重复元素, 那么使用LinkedHashSet |
2. 集合类(Collection)
Collection接口有两个子接口：
List(链表|线性表)
Set(集)
特点：
Collection中描述的是集合共有的功能(CRUD)
List可存放重复元素，元素存取是有序的
Set不可以存放重复元素，元素存取是无序的
java.util.Collection ---| Collection 描述所有接口的共性 ----| List接口 可以有重复元素的集合 ----| Set 接口 不可以有重复元素的集合 |
2：学习集合对象
学习Collection中的共性方法，多个容器在不断向上抽取就出现了该体系。发现Collection接口中具有所有容器都具备的共性方法。查阅API时，就可以直接看该接口中的方法。并创建其子类对象对集合进行基本应用。当要使用集合对象中特有的方法，在查看子类具体内容。
查看api 文档Collection在在java.util 中（注意是大写Collection）
注意在现阶段遇到的 E T 之类的类型,需要暂时理解为object 因为涉及到了泛型.
3：创建集合对象,使用Collection中的List的具体实现类ArrayList
1：Collection coll=new Arraylist();
1.1. Collection接口的共性方法
增加： 1：add() 将指定对象存储到容器中 add 方法的参数类型是Object 便于接收任意对象 2：addAll() 将指定集合中的元素添加到调用该方法和集合中 删除： 3：remove() 将指定的对象从集合中删除 4：removeAll() 将指定集合中的元素删除 修改 5：clear() 清空集合中的所有元素 判断 6：isEmpty() 判断集合是否为空 7：contains() 判断集合何中是否包含指定对象
8：containsAll() 判断集合中是否包含指定集合 使用equals()判断两个对象是否相等 获取: 9：int size() 返回集合容器的大小 转成数组10： toArray() 集合转换数组 |
1.1.1. 增加：
publicstaticvoid main(String[] args) { Collection list = new ArrayList(); // 增加：add() 将指定对象存储到容器中 list.add("计算机网络"); list.add("现代操作系统"); list.add("java编程思想"); System.out.println(list); // [计算机网络, 现代操作系统, java编程思想]
// 增加2 将list容器元素添加到list2容器中 Collection list2 = new ArrayList(); list2.add("java核心技术"); list2.addAll(list); list2.add("java语言程序设计"); System.out.println(list2); // [java核心技术, 计算机网络, 现代操作系统, java编程思想, java语言程序设计] } |
1.1.2. 删除：
// 删除1 remove boolean remove = list2.remove("java核心技术"); System.out.println(remove); // true System.out.println(list2); // //删除2 removeAll() 将list中的元素删除 boolean removeAll = list2.removeAll(list); System.out.println(removeAll);//true System.out.println(list2);//[java语言程序设计] |
1.1.3. 修改：
publicstaticvoid main(String[] args) { Collection list = new ArrayList(); // 增加：add() 将指定对象存储到容器中 list.add("计算机网络"); list.add("现代操作系统"); list.add("java编程思想"); list.add("java核心技术"); list.add("java语言程序设计"); System.out.println(list); // 修改 clear() 清空集合中的所有元素 list.clear(); System.out.println(list); //[] } |
1.1.4. 判断：
publicstaticvoid main(String[] args) { Collection list = new ArrayList(); // 增加：add() 将指定对象存储到容器中 list.add("计算机网络"); list.add("现代操作系统"); list.add("java编程思想"); list.add("java核心技术"); list.add("java语言程序设计"); System.out.println(list);
boolean empty = list.isEmpty(); System.out.println(empty);// false boolean contains = list.contains("java编程思想"); System.out.println(contains);// true Collection list2 = new ArrayList(); list2.add("水许传"); boolean containsAll = list.containsAll(list2); System.out.println(containsAll);// false
} |
1.1.5. 获取：
publicstaticvoid main(String[] args) { Collection list = new ArrayList(); // 增加：add() 将指定对象存储到容器中 list.add("计算机网络"); list.add("现代操作系统"); list.add("java编程思想"); list.add("java核心技术"); list.add("java语言程序设计"); System.out.println(list); // 获取 集合容器的大小 int size = list.size(); System.out.println(size); } |
List
---| Iterable 接口 Iterator iterator() ----| Collection 接口 ------| List 接口 元素可以重复，允许在指定位置插入元素，并通过索 引来访问元素 |
List集合特有方法
1：增加 void add(int index, E element) 指定位置添加元素 boolean addAll(int index, Collection c) 指定位置添加集合 2：删除 E remove(int index) 删除指定位置元素 3：修改 E set(int index, E element) 返回的是需要替换的集合中的元素 4：查找： E get(int index) 注意： IndexOutOfBoundsException int indexOf(Object o) // 找不到返回-1 lastIndexOf(Object o) 5：求子集合 List<E> subList(int fromIndex, int toIndex) // 不包含toIndex |
增加
publicstaticvoid main(String[] args) { List list = new ArrayList(); // 增加：add() 将指定对象存储到容器中 list.add("计算机网络"); list.add("现代操作系统"); list.add("java编程思想"); list.add("java核心技术"); list.add("java语言程序设计"); System.out.println(list); // add,在0角标位置添加一本书 list.add(0, "舒克和贝塔"); System.out.println(list); // 在list2集合的1角标位置添加list集合元素 List list2 = new ArrayList(); list2.add("史记"); list2.add("资治通鉴"); list2.add("全球通史"); boolean addAll = list2.addAll(1, list); System.out.println(addAll); //true System.out.println(list2); } |
删除
publicstaticvoid main(String[] args) { List list = new ArrayList(); // 增加：add() 将指定对象存储到容器中 list.add("计算机网络"); list.add("现代操作系统"); list.add("java编程思想"); list.add("java核心技术"); list.add("java语言程序设计"); System.out.println(list); // 删除0角标元素 Object remove = list.remove(0); System.out.println(remove); } |
修改：
publicstaticvoid main(String[] args) { List list = new ArrayList(); // 增加：add() 将指定对象存储到容器中 list.add("计算机网络"); list.add("现代操作系统"); list.add("java编程思想"); list.add("java核心技术"); list.add("java语言程序设计"); System.out.println(list); // 修改2角标位置的书，返回的原来2角标位置的书 Object set = list.set(2, "边城"); System.out.println(set); //java编程思想 System.out.println(list);
} |
查找
List list = new ArrayList(); // 增加：add() 将指定对象存储到容器中 list.add("计算机网络"); list.add("现代操作系统"); list.add("java编程思想"); list.add("java核心技术"); list.add("java语言程序设计"); System.out.println(list); // 查找： E get(int index) 注意角标越界 Object set = list.get(list.size() - 1); System.out.println(set); // java语言程序设计 System.out.println(list); list.get(list.size()); //IndexOutOfBoundsException } |
查找
publicstaticvoid main(String[] args) { List list = new ArrayList(); // 增加：add() 将指定对象存储到容器中 list.add("计算机网络"); list.add("现代操作系统"); list.add("java编程思想"); list.add("java核心技术"); list.add("java语言程序设计"); list.add("java编程思想"); System.out.println(list); // 查找： E get(int index) 注意角标越界 Object set = list.get(list.size() - 1); System.out.println(set); // java语言程序设计 System.out.println(list); // list.get(list.size()); //IndexOutOfBoundsException
// indexOf(Object o) 返回第一次出现的指定元素的角标 int indexOf = list.indexOf("java编程思想"); System.out.println(indexOf); // 2 // 没有找到，返回-1 int indexOf2 = list.indexOf("三国志"); System.out.println(indexOf2); // -1
// lastIndexOf 返回最后出现的指定元素的角标 int lastIndexOf = list.lastIndexOf("java编程思想"); System.out.println(lastIndexOf); // 5 } |
ArrayList
--| Iterable ----| Collection ------| List ---------| ArrayList 底层采用数组实现，默认10。每次增长 60%,（(oldCapacity * 3)/2 + 1） 查询快，增删慢。 ---------| LinkedList |
ArrayList:实现原理：
数组实现,查找快,增删慢
数组为什么是查询快?因为数组的内存空间地址是连续的.
ArrayList底层维护了一个Object[]用于存储对象，默认数组的长度是10。可以通过 new ArrayList(20)显式的指定用于存储对象的数组的长度。
当默认的或者指定的容量不够存储对象的时候，容量自动增长为原来的容量的1.5倍。
由于ArrayList是数组实现,在增和删的时候会牵扯到数组增容,以及拷贝元素.所以慢。数组是可以直接按索引查找,所以查找时较快
可以考虑,假设向数组的0角标未知添加元素,那么原来的角标位置的元素需要整体往后移,并且数组可能还要增容,一旦增容,就需要要将老数组的内容拷贝到新数组中.所以数组的增删的效率是很低的.
练习：去除ArrayList集合中重复元素
1：存入字符串元素
2：存入自定义对象元素（如Perosn对象）
原理：
循环遍历该集合，每取出一个放置在新的集合中，放置之前先判断新的集合是否以包含了新的元素。
思路: 存入人的对象. 1先定义person 类 2将该类的实例存入集合 3 将对象元素进行操作. 注意:自定义对象要进行复写toString 和 equals 方法. 为什么? 因为object 是person 的父类,object 中的toString 返回的是哈希值,object 类中equals 方法比较的是对象的地址值. 思路 1存入字符串对象 2存入自定义对象如person 2创建容器,用于存储非重复元素 3对原容器进行遍历,在遍历过程中进行判断遍历到的元素是否在容器中存在.(contains) 4如果存在,就不存入,否则存入. 5 返回新容器 |
LinkedList
--| Iterable ----| Collection ------| List ---------| ArrayList 底层采用数组实现，默认10。每次增长 60%,（(oldCapacity * 3)/2 + 1） 查询快，增删慢。 ---------| LinkedList 底层采用链表实现，增删快，查询慢。 |
LinkedList:链表实现, 增删快, 查找慢
由于LinkedList:在内存中的地址不连续,需要让上一个元素记住下一个元素.所以每个元素中保存的有下一个元素的位置.虽然也有角标,但是查找的时候,需要从头往下找,显然是没有数组查找快的.但是,链表在插入新元素的时候,只需要让前一个元素记住新元素,让新元素记住下一个元素就可以了.所以插入很快.
由于链表实现, 增加时只要让前一个元素记住自己就可以, 删除时让前一个元素记住后一个元素, 后一个元素记住前一个元素. 这样的增删效率较高。
但查询时需要一个一个的遍历,所以效率较低。
特有方法
1：方法介绍 addFirst(E e) addLast(E e) getFirst() getLast() removeFirst() removeLast() 如果集合中没有元素，获取或者删除元 素抛：NoSuchElementException 2：数据结构 1：栈 （1.6） 先进后出 push() pop() 2：队列（双端队列1.5） 先进先出 offer() poll() 3：返回逆序的迭代器对象 descendingIterator() 返回逆序的迭代器对象 |