集合
集合
数组的长度是固定的, 当添加的元素超过了数组长度时,需要对数组重新定义, java内部提供了集合类, 能存储任意对象, 长度是可以改变的, 随着元素的增加而增加, 随着元素的减少而减少
数组和集合的区别
-
区别一:
- 数组既可以存储基本数据类型,又可以存储引用数据类型(基本数据类型存储的是值, 引用数据类型存储的是地址值)
- 集合中只能存储引用数据类型(对象),集合中也可以存储基本数据类型,但是在存储的时候会自动装箱变成对象
-
区别二:
- 数组长度是固定的,不能自动增长
- 集合的长度是可变的
graph TD
A(Collection 单列集合的根接口)
A --> B(List 有序存取的顺序一致,有索引可以存储重复)
A --> C(Set 无序存取顺序不一致,无索引不可以存储重复)
B --> E1(ArrayList 数组实现)
B --> E2(LinkedList 链表实现)
B --> E3(Vector 数组实现)
C --> F1(HashSet 哈希算法)
C --> F2(TreeSet 二叉树算法)
import java.util.ArrayList;
import java.util.Collection;
import com.mephisto.bean.Student;
@SuppressWarnings({ "rawtypes", "unchecked" })
public class DemoCollection2 {
/*
* add 方法如果是List集合一直都返回true,因为List集合可以存储重复元素的
* 如果是Set集合,当有重复元素时, 返回false
*
* ArrayList的父类的父类重写了toString方法()
*/
public static void main(String[] args) {
demo1();
Collection collection = new ArrayList();
collection.add("a");
collection.add("b");
// collection.remove("a"); // 删除集合中的元素
// collection.clear(); // 清空集合
System.out.println(collection.contains("b")); // 判断是否包含
System.out.println(collection.isEmpty()); // 判断是否空
System.out.println(collection.size()); // 获取元素的个数
System.out.println(collection.toString());
}
private static void demo1() {
// 父类引用指向子类对象
Collection collection = new ArrayList();
boolean b1 = collection.add("Mephisto");
boolean b2 = collection.add(2);
boolean b3 = collection.add(true);
boolean b4 = collection.add(new Student("张三",18));
boolean b5 = collection.add("abc");
System.out.println(b1);
System.out.println(b2);
System.out.println(b3);
System.out.println(b4);
System.out.println(b5);
/*
public String toString() {
Iterator<E> it = iterator();
if (! it.hasNext())
return "[]";
StringBuilder sb = new StringBuilder();
sb.append('[');
for (;;) {
E e = it.next();
sb.append(e == this ? "(this Collection)" : e);
if (! it.hasNext())
return sb.append(']').toString();
sb.append(',').append(' ');
}
}
*/
System.out.println(collection.toString());
}
}
import java.util.ArrayList;
import java.util.Collection;
import com.mephisto.bean.Student;
@SuppressWarnings({ "rawtypes", "unchecked" })
public class Demo3 {
public static void main(String[] args) {
// demo1();
// demo2();
// demo3();
// demo4();
// demo5();
Collection c1 = new ArrayList();
c1.add("a");
c1.add("b");
c1.add("c");
c1.add("d");
Collection c2 = new ArrayList();
// c2.add("a");
// c2.add("b");
c2.add("c");
c2.add("d");
c2.add("e");
// 取交集, 如果调用的集合改变就返回true, 如果调用的集合不改变就改变false
boolean b = c1.retainAll(c2);
System.out.println(b);
System.out.println(c1);
}
private static void demo5() {
Collection c1 = new ArrayList();
c1.add("a");
c1.add("b");
c1.add("c");
c1.add("d");
Collection c2 = new ArrayList();
c2.add("a");
c2.add("b");
// 判断是否包含
boolean b = c1.containsAll(c2);
System.out.println(b);
}
private static void demo4() {
Collection c1 = new ArrayList();
c1.add("a");
c1.add("b");
c1.add("c");
c1.add("d");
Collection c2 = new ArrayList();
c2.add("a");
c2.add("b");
// 删除交集
boolean b = c1.removeAll(c2);
// 如果没有交集不删, 返回false
System.out.println(b);
System.out.println(c1);
}
private static void demo3() {
Collection c1 = new ArrayList();
c1.add("a");
c1.add("b");
c1.add("c");
c1.add("d");
Collection c2 = new ArrayList();
c2.add("a");
c2.add("b");
c2.add("c");
c2.add("d");
// 将c2中的元素添加到c1中
// c1.addAll(c2);
// 蒋c2集合添加到c1中
c1.add(c2);
System.out.println(c1);
}
private static void demo2() {
Collection collection = new ArrayList<>();
collection.add(new Student("张三",18));
collection.add(new Student("李四",20));
collection.add(new Student("王五",13));
Object [] arr = collection.toArray();
for (int i = 0; i < arr.length; i++) {
// 向下转型
Student student = (Student)arr[i];
System.out.println(student.getName() + " " + student.getAge());
}
}
private static void demo1() {
Collection collection = new ArrayList<>();
collection.add("a");
collection.add("b");
collection.add("c");
collection.add("d");
// 将集合转换成数组
Object [] arr = collection.toArray();
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
迭代器
迭代器 === 遍历
迭代器原理
迭代器是对集合进行遍历而每一个集合内部的存储结构都是不同的, 所以每一个集合存和取都是不一样的,呢么就需要在每一个类中定义hasNext()和next()方法,但是会让整个集合体系变得过于臃肿,迭代器是将这样的方法向上抽取出接口,然后在每个类的内部,定义自己迭代的方式,规定了整个集合体的遍历方式都是hasNext()和next(),代码底层实现
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import com.mephisto.bean.Student;
@SuppressWarnings({ "rawtypes", "unchecked" })
public class demo4 {
public static void main(String[] args) {
// demo();
Collection collection = new ArrayList();
collection.add(new Student("张三",19));
collection.add(new Student("李四",10));
collection.add(new Student("王五",23));
Iterator iterator = collection.iterator();
while (iterator.hasNext()) {
Student s = (Student) iterator.next();
System.out.println(s.getName() + " " + s.getAge());
}
}
private static void demo() {
Collection collection = new ArrayList();
collection.add("a");
collection.add("b");
collection.add("c");
collection.add("d");
// 对集合中的元素迭代
Iterator iterator = collection.iterator();
/*
// 判断集合中是否有元素, 有就返回true
boolean b1 = iterator.hasNext();
Object object1 = iterator.next();
System.out.println(b1);
System.out.println(object1);
boolean b2 = iterator.hasNext();
Object object2 = iterator.next();
System.out.println(b2);
System.out.println(object2);
*/
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
List
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Demo1 {
public static void main(String[] args) {
// demo1();
// demo2();
// demo3();
List list = new ArrayList();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.set(1, "e");
System.out.println(list);
}
private static void demo3() {
List list= new ArrayList();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
// Object obj = list.get(1);
// System.out.println(obj);
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
Iterator iterator = list.iterator();
while(iterator.hasNext())
System.out.println(iterator.next());
}
private static void demo2() {
List list = new ArrayList();
list.add("a");
list.add("b");
list.add("c");
list.add(111);
// 删除的时候不会自动装箱 java.lang.IndexOutOfBoundsException
// 把111当做索引
list.remove(111);
System.out.println(list);
}
private static void demo1() {
List list = new ArrayList();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add(4,"e"); // index <= size 都不会报错
// list.add(10,"z"); // 当存储的使用的索引不存在时 java.lang.IndexOutOfBoundsException
Object obj1 = list.remove(1); // 通过索引删除元素, 将被删除的元素返回
System.out.println(obj1);
System.out.println(list);
}
}
并发修改
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class Demo2 {
public static void main(String[] args) {
List list = new ArrayList();
list.add("a");
list.add("b");
list.add("c");
list.add("mephisto");
list.add("e");
/*
Iterator iterator = list.iterator();
while(iterator.hasNext()) {
String string = (String)iterator.next();
if("mephisto".equals(string)) {
// 遍历的同时在修改增加元素,并发修改异常 java.util.ConcurrentModificationException
list.add("lee");
}
}
*/
ListIterator iterator = list.listIterator();
while(iterator.hasNext()) {
String string = (String)iterator.next();
if("mephisto".equals(string))
iterator.add("lee");
}
System.out.println(list);
}
}
Vector类
Vertor的迭代
import java.util.Enumeration;
import java.util.Vector;
public class Demo5 {
public static void main(String[] args) {
Vector vector = new Vector();
vector.addElement("a");
vector.addElement("b");
vector.addElement("c");
vector.addElement("d");
Enumeration enumeration = vector.elements(); // 获取枚举
while (enumeration.hasMoreElements()) {
System.out.println(enumeration.nextElement());
}
}
}
集合框架
- 数组
- 查询快,修改也快
- 增删慢
- 链表
- 查询慢,修改也慢
- 增删快
List三个子类的特点
- ArrayList:
- 底层数据结构是数组查询快,增删慢
- 线程不安全, 效率高
- Vector:
- 底层数据结构是数组,查询快,增删慢
- 线程安全, 效率低
- Vector相对ArrayList查询慢(线程安全)
- Vector相对于LinkedList增删慢(数据结构)
- LinkedList:
- 底层数据结构是链表,查询慢,增删快
- 线程不安全,效率高
- Vector和ArrayList区别
- Vector是线程安全的, 效率低
- ArrayList是线程不安全的
- 都是数组实现的
- ArrayList和LinkedList区别
- ArrayList底层数据是数组, 查询和修改快
- Linkedlist底层是数据结构,增删比较快,查询修改慢
- 都是线程不安全的
- 使用
- 查询多使用ArrayList
- 增删多使用LinkedList
- 查询增删都多使用ArrayList
栈和队列数据结构
栈
先进后出
队列
先进先出
