目录
1、List
1.1 List集合特有方法
1.1.1 增加
1.1.2 删除
1.1.3 修改
1.1.4 查找
1.2 ArrayList
1.3 LinkedList
1.4 Vector
1、List
| ---| Iterable 接口 Iterator iterator() ----| Collection 接口 ------| List 接口 元素可以重复，允许在指定位置插入元素，并通过索 引来访问元素 |
1.1 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 |
1.1.1 增加
| public static void 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); } |
1.1.2 删除
| public static void 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); } |
1.1.3 修改
| public static void 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); } |
1.1.4 查找
| public static void 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 } |
1.2 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 返回新容器 |
| public class Demo6 { public static void main(String[] args) { ArrayList arr = new ArrayList(); Person p1 = new Person("jack", 20); Person p2 = new Person("rose", 18); Person p3 = new Person("rose", 18); arr.add(p1); arr.add(p2); arr.add(p3); System.out.println(arr); ArrayList arr2 = new ArrayList(); for (int i = 0; i < arr.size(); i++) { Object obj = arr.get(i); Person p = (Person) obj; if (!(arr2.contains(p))) { arr2.add(p); } } System.out.println(arr2); } } class Person { private String name; private int age; public Person() { } public Person(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 hashCode() { return this.name.hashCode() + age * 37; } @Override public boolean equals(Object obj) { if (!(obj instanceof Person)) { return false; } Person p = (Person) obj; return this.name.equals(p.name) && this.age == p.age; } @Override public String toString() { return "Person@name:" + this.name + " age:" + this.age; } } |
在实际的开发中ArrayList是使用频率最高的一个集合。
1.3 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() 返回逆序的迭代器对象 |
基本方法
| import java.util.Iterator; import java.util.LinkedList; public class Demo3 { public static void main(String[] args) { LinkedList list = new LinkedList(); list.add("西游记"); list.add("三国演义"); list.add("石头记"); list.add("水浒传"); list.add("全球通史"); list.addFirst("史记"); list.addLast("呐喊"); // list.addFirst(null); // list.addLast(null); System.out.println(list); // 获取指定位置处的元素。 String str = (String) list.get(0); // 返回此列表的第一个元素。 String str2 = (String) list.getFirst(); System.out.println(str.equals(str2)); // 获取指定位置处的元素。 String str3 = (String) list.get(list.size() - 1); // 返回此列表的最后一个元素。 String str4 = (String) list.getLast(); System.out.println(str3.equals(str4)); // 获取但不移除此列表的头（第一个元素）。 Object element = list.element(); System.out.println(element); int size = list.size(); System.out.println(size); } |
迭代
| mport java.util.Iterator; import java.util.LinkedList; public class Demo3 { public static void main(String[] args) { LinkedList list = new LinkedList(); list.add("西游记"); list.add("三国演义"); list.add("石头记"); list.add("水浒传"); list.add("全球通史"); Iterator it = list.iterator(); while (it.hasNext()) { String next = (String) it.next(); System.out.println(next); } } } |
逆序迭代
| import java.util.Iterator; import java.util.LinkedList; public class Demo6 { public static void main(String[] args) { LinkedList list = new LinkedList(); list.add("aa"); list.add("bb"); list.add("cc"); Iterator dit = list.descendingIterator(); while (dit.hasNext()) { System.out.println(dit.next()); } } } |
注意：可以使用该集合去模拟出队列(先进先出) 或者堆栈(后进先出) 数据结构。
堆栈(后进先出)
| //堆栈(后进先出) 数据结构 public class Demo3 { public static void main(String[] args) { LinkedList list = new LinkedList(); // 压栈，先进后出 list.push("西游记"); list.push("三国演义"); list.push("石头记"); list.push("水浒传"); System.out.println(list); // 弹栈 String str1 = (String) list.pop(); System.out.println(str1); String str2 = (String) list.pop(); System.out.println(str2); String str3 = (String) list.pop(); System.out.println(str3); String str4 = (String) list.pop(); System.out.println(str4); System.out.println(list.size());// 0 System.out.println(list); //[] } } |
队列，先进先出
| import java.util.LinkedList; public class Demo3 { public static void main(String[] args) { LinkedList list = new LinkedList(); // 队列，先进先出 list.offer("西游记"); list.offer("三国演义"); list.offer("石头记"); list.offer("水浒传"); System.out.println(list); // 出队列 System.out.println(list.poll()); System.out.println(list.poll()); System.out.println(list.poll()); System.out.println(list.poll()); System.out.println(list.size()); System.out.println(list.peek()); // 获取队列的头元素，但是不删除 System.out.println(list.peekFirst()); // 获取队列的头元素，但是不删除 System.out.println(list.peekLast()); // 获取队列的最后一个元素但是不删除 } } |
ArrayList 和 LinkedList的存储查找的优缺点：
1、ArrayList 是采用动态数组来存储元素的，它允许直接用下标号来直接查找对应的元素。但是，但是插入元素要涉及数组元素移动及内存的操作。总结：查找速度快，插入操作慢。
2、LinkedList 是采用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快
问题：有一批数据要存储，要求存储这批数据不能出现重复数据，ArrayList、LinkedList都没法满足需求。解决办法：使用 set集合。
1.4 Vector
Vector: 描述的是一个线程安全的ArrayList。
ArrayList： 单线程效率高
Vector ： 多线程安全的，所以效率低
| 特有的方法： void addElement(E obj) 在集合末尾添加元素 E elementAt( int index) 返回指定角标的元素 Enumeration elements() 返回集合中的所有元素，封装到Enumeration对象中 Enumeration 接口： boolean hasMoreElements() 测试此枚举是否包含更多的元素。 E nextElement() 如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。 |
| public static void main(String[] args) { Vector v = new Vector(); v.addElement("aaa"); v.addElement("bbb"); v.addElement("ccc"); System.out.println( v ); System.out.println( v.elementAt(2) ); // ccc // 遍历Vector遍历 Enumeration ens = v.elements(); while ( ens.hasMoreElements() ) { System.out.println( ens.nextElement() ); } } |
![[leetcode]jump-game-iv](http://pic.xiahunao.cn/[leetcode]jump-game-iv)
