集合

集合

数组的长度是固定的, 当添加的元素超过了数组长度时,需要对数组重新定义, 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

栈和队列数据结构

栈

​ 先进后出

队列

​ 先进先出