Java--集合框架--对象数组、集合、 数据结构

对象数组
集合
数据结构

集合框架(集合的由来)

A:集合的由来
	面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，Java就提供了集合类。
B:数组和集合的区别
	(1): 长度区别:
		数组的长度是固定的而集合的长度是可变的
	(2): 存储数据类型的区别:
		数组可以存储基本数据类型 , 也可以存储引用数据类型; 而集合只能存储引用数据类型
	(3): 内容区别:
		数组只能存储同种数据类型的元素 ,集合可以存储不同类型的元素

集合框架(Collection集合的功能概述)

A:Collection的功能概述(通过API查看即可得到)
	a:添加功能
		boolean add(Object obj):添加一个元素
		boolean addAll(Collection c):添加一个集合的元素  (给一个集合添加进另一个集合中的所有元素)
	b:删除功能
		void clear():移除所有元素
		boolean remove(Object o):移除一个元素
		boolean removeAll(Collection c):移除一个集合的元素(移除一个以上返回的就是true) 删除的元素是两个集合的交集元素 
		如果没有交集元素 则删除失败 返回false
	c:判断功能
		boolean contains(Object o)：判断集合中是否包含指定的元素	
		boolean containsAll(Collection c)：判断集合中是否包含指定的集合元素(这个集合 包含 另一个集合中所有的元素才算包含 才返回true)
		比如：1，2，3 containsAll 12=true   1,2,3 containsAll 2,3,4=false
		boolean isEmpty()：判断集合是否为空
	d:获取功能
		Iterator<E> iterator()(重点)
		e:长度功能
			int size():元素的个数
			面试题：数组有没有length()方法呢?字符串有没有length()方法呢?集合有没有length()方法呢?
		f:交集功能
			//例如：A集合对B集合取交集，获取到的交集元素在A集合中。返回的布尔值表示的是A集合是否发生变化 
			boolean retainAll(Collection c):获取两个集合的交集元素(交集：两个集合都有的元素)
		g:把集合转换为数组
			Object[] toArray()

集合框架(Collection集合的基本功能测试)

A:案例演示	
	boolean add(E e)
	boolean remove(Object o)
	void clear()
	boolean contains(Object o)
	boolean isEmpty()
	int size()

public class MyTest {
    public static void main(String[] args) {
       Collection collection = new ArrayList();
       collection.add("张三");
        collection.add("李四");
        collection.add("王五");
        System.out.println(collection);

        Collection collection1 = new ArrayList();
        collection1.add(100);
        collection1.add(200);
        collection1.add(300);
        System.out.println(collection1);

        Collection collection2 = new ArrayList();
        collection2.add(150);
        collection2.add(20);
        collection2.add(320);
        collection2.add(200);
        boolean b = collection1.addAll(collection2);
        System.out.println(b);
        System.out.println(collection1);
        System.out.println(collection2);

         int size = collection1.size();
        System.out.println(size);

        boolean remove = collection1.remove(100);
        System.out.println(collection1);
         
           boolean contains = collection1.contains(100);
        System.out.println(contains);

          boolean empty = collection1.isEmpty();
        System.out.println(empty);
        
        collection1.clear();
        System.out.println(collection1);
    }
}

集合框架(Collection集合的高级功能测试)

A:案例演示
	boolean addAll(Collection c)
	boolean removeAll(Collection c)
	boolean containsAll(Collection c)
	boolean retainAll(Collection c)

public class MyTest {
    public static void main(String[] args) {
        Collection collection1 = new ArrayList();
        collection1.add(100);
        collection1.add(200);
        collection1.add(300);

        Collection collection2 = new ArrayList();
        collection2.add(150);
        collection2.add(20);
        collection2.add(320);
        collection2.add(200);

        boolean b1 = collection1.removeAll(collection2);
        System.out.println(b1);
        System.out.println(collection1);
        System.out.println(collection2);

        boolean b = collection1.containsAll(collection2);
        System.out.println(b);

      boolean b2 = collection1.retainAll(collection2);
        System.out.println(b2);
        System.out.println(collection1);
        System.out.println(collection2);
    }
}

集合框架(Collection存储自定义对象并遍历)

A:案例演示
	Collection存储自定义对象并把集合转成对象数组遍历

public class MyTest {
    public static void main(String[] args) {
        Collection collection1 = new ArrayList();
        collection1.add(100);
        collection1.add(200);
        collection1.add(300);

        Object[] objects = collection1.toArray();
        System.out.println(Arrays.toString(objects));
    }
}

集合框架(集合的遍历之迭代器遍历)

A:迭代器概述:	对 collection 进行迭代的迭代器
B:案例演示:		迭代器的使用
public class MyTest{
    public static void main(String[] args) {
        Collection collection1 = new ArrayList();
        collection1.add(100);
        collection1.add(200);
        collection1.add(300);

        Iterator iterator = collection1.iterator();

        while (iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next);
        }
    }
}

集合框架(Collection存储自定义对象并遍历)

A:案例演示:	Collection存储自定义对象并用迭代器遍历
public class MyTest {
    public static void main(String[] args) {
        Student s1 = new Student( "张三",23);
        Student s2 = new Student( "李四",20);
        Student s3 = new Student( "王五",22);
        Collection arrayList = new ArrayList();
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);

        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            Student student=(Student) next;
            System.out.println(student.getName()+"==="+student.getAge());
        }
    }
}

集合框架(迭代器的原理及源码解析)

A:迭代器原理:	为什么迭代器不定义成一个类 , 而是定义成一个接口?
B:迭代器源码解析

集合框架(Collection集合存储字符串并遍历)

A:学生练习
	Collection集合存储字符串并遍历
	迭代器的方式

集合框架(List概述及特点以及存储字符串并遍历)

A:List概述及特点:	元素有序,并且每一个元素都存在一个索引.元素可以重复.
B:案例演示
	List集合存储字符串并遍历
	迭代器的方式

集合框架(List集合存储学生对象并遍历)

A:案例演示:	List集合存储学生对象并遍历
			迭代器的方式

集合框架(List集合的特有功能概述和测试)

A:List集合的特有功能概述
	void add(int index,E element):	在指定索引处添加元素
	E remove(int index):移除指定索引处的元素  返回的是移除的元素
	E get(int index):获取指定索引处的元素
	E set(int index,E element):更改指定索引处的元素 返回的而是被替换的元素
B:案例演示:	特有功能测试
public class MyTest {
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add(100);
        arrayList.add(100);
        arrayList.add(100);
        arrayList.add(0,200);
        arrayList.add(1,300);

        System.out.println(arrayList);
        System.out.println(arrayList.indexOf(100));

        List list = arrayList.subList(0, 3);
        System.out.println(list);

        Object o = arrayList.get(0);
        System.out.println(o);

        Object set = arrayList.set(0, 150);
        System.out.println(set);
        System.out.println(arrayList);
    }
}

集合框架(List集合的特有遍历功能)

A:案例演示: 使用for循环	通过size()和get()方法结合使用遍历。
public class MyTest{
    public static void main(String[] args) {
        ArrayList arrayList = new ArrayList();
        arrayList.add(110);
        arrayList.add(120);
        arrayList.add(130);

        Iterator iterator = arrayList.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next);
        }

        for (int i = 0; i < arrayList.size(); i++) {
            Object o = arrayList.get(i);
            System.out.println(o);
        }

        ListIterator listIterator = arrayList.listIterator();
        while (listIterator.hasNext()){
            Object next = listIterator.next();
            System.out.println(next);
        }


    }
}

集合框架(List集合存储学生对象并遍历)

A:学生练习:	List集合存储学生对象并遍历。通过size()和get()方法结合使用遍历。

集合框架(ListIterator的特有功能)

​	ListIterator 继承自Iterator  可以使用Iterator中的方法
​	A:ListIterator的特有功能
​		boolean hasPrevious():			是否存在前一个元素
​		E previous():					返回列表中的前一个元素
​		以上两个方法可以实现反向遍历 但是注意 要完成反向遍历之前 要先进行正向遍历  这样指针才能移到最后
​		如果直接反向遍历是没有效果的  因为指针默认位置就在最前面 他前面没有元素
​	B:案例演示:	ListIterator的特有功能

集合框架(并发修改异常产生的原因及解决方案)

A:案例演示
	需求：我有一个集合，请问，我想判断里面有没有"world"这个元素，如果有，我就添加一个"javaee"元素，请写代码实现。
	public class MyTest {

    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("aaa");
        list.add("ccc");
        list.add("ddd");
        list.add("world");

        /*if (list.contains("world")){
            list.add("javaee");
        }
        System.out.println(list);*/

        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()){
            Object obj = listIterator.next();
            String str=(String) obj;
            if (str.equals("world")){
                listIterator.add("javaee");
            }
        }
        System.out.println(list);

        for (int i = 0; i < list.size(); i++) {
            Object obj = list.get(i);
            String str= (String) obj;
            if (str.equals("world")){
                list.add("javaee");
            }
        }
        System.out.println(list);
    }
}

B:ConcurrentModificationException出现
	我们用Iterator这个迭代器遍历采用hasNext方法和next方法，集合修改集合 会出现并发修改异常
	原因是我们的迭代依赖与集合 当我们往集合中添加好了元素之后 获取迭代器  那么迭代器已经知道了集合的元素个数
	这个时候你在遍历的时候又突然想给 集合里面加一个元素（用的是集合的add方法） 那迭代器不同意 就报错了
C:解决方案 我们用ListIterator迭代器遍历 用迭代器自带的add方法添加元素 那就不会报错了
	a:迭代器迭代元素，迭代器修改元素(ListIterator的特有功能add)
	b:集合遍历元素，集合修改元素

	解决方案2 使用for循环遍历集合 添加元素 不会报错

集合框架(数据结构之栈和队列)

A:数据结构概述及常见数据结构
	数据结构其实就是存储数据的格式
	分类:	栈 , 队列 , 数组 , 链表 , 树 , 哈希表
B:栈特点: 	先进后出
C:队列: 	先进先出

集合框架(数据结构之数组和链表)

A:数组特点:	查询快 , 增删慢
B:链表特点: 	查询慢 , 增删快

集合框架(List的三个子类的特点)

A:List的三个子类的特点
	ArrayList:
		底层数据结构是数组，查询快，增删慢。
		线程不安全，效率高。
	Vector:
		底层数据结构是数组，查询快，增删慢。
		线程安全，效率低。
	LinkedList:
		底层数据结构是链表，查询慢，增删快。
		线程不安全，效率高。
B:List有三个儿子，我们到底使用谁呢?
得看  要安全还是要效率
  是查找多还是增删多