第15天

今天开始进入集合

集合

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()：判断集合是否为空
		boolean retainAll(Collection c)移除此 collection 中未包含在指定 collection 中的所有元素，如果此 collection 由于调用而发生更改，则返回 true。
	d:获取功能
  			Iterator<E> iterator()(重点)
		e:长度功能
			int size():元素的个数
		f:交集功能
			//例如：A集合对B集合取交集，获取到的交集元素在A集合中。返回的布尔值表示的是A集合是否发生变化 
			boolean retainAll(Collection c):获取两个集合的交集元素(交集：两个集合都有的元素)
		g:把集合转换为数组
			Object[] toArray()

上述都是集合的基础功能，这里要特别说一下的是Collection的删除功能返回值是一个boolear型，判断功能中的判断部分的位置。

集合的遍历之集合转数组遍历

      Collection aList = new ArrayList();
        aList.add(1);
        aList.add(15);
        aList.add(16);
        aList.add(14);
        aList.add(17);
        创建一个数组
        //Integer[] arr = new Integer[aList.size()];
        //int index = 0;
        //Iterator iterator = aList.iterator();//迭代器
        //while (iterator.hasNext()) {
        //    Object obj = iterator.next();
        //    Integer integer = (Integer) obj;
        //    arr[index] = integer;
        //    index++;
        //}
        //
        //System.out.println(Arrays.toString(arr));
        //将一个集合转换成数组
        Object[] objects = aList.toArray();
        for (int i = 0; i < objects.length; i++) {
            Integer num= (Integer) objects[i];
            System.out.println(num);

List概述及特点以及存储字符串并遍历

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

数据结构：数据的存储结构
常见的数据存储结构：栈 队列， 链表，数组，二叉树
栈的数据结构的特点：先进后出，后进先出
队列：先进先出
数组：顺序结构，有索引，查询快，增删慢
链表：查询慢，增删快
List:元素有序（存的顺序跟取的顺序一致），运行重复
List 三个子类
ArrayList 底层数据结构是数组，查询块，增删慢 线程不安全，效率
LinkedList 底层数据结构是链表 查询慢，增删块 线程不安全效率高
Vector 底层数据结构是数组，查询块，增删慢 线程安全效率低，查询多
ArrayList中的比较器

list.sort(new Comparator() {
            @Override
            public int compare(Object a, Object b) {
                Integer aa = (Integer) a;
                Integer bb = (Integer) b;
                return bb - aa; //根据差值 的正 负 0 就会排列集合中的元素
            }
        });

 // Consumer
        //JDK1.8 提供的新语法 Lmabda 表达式
        list.forEach(System.out::println);
        System.out.println("---------------");
        list.forEach(new Consumer() {
            @Override
            public void accept(Object o) {
                System.out.println(o);
            }
        });

用forEach遍历时不能进行增删操作。

ListIterator的特有功能

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

   //案例演示
        //需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)
        //思路：创建新集合方式

        ArrayList list = new ArrayList();
        list.add("abc");
        list.add("abc");
        list.add("abcddd");
        list.add("abc");
        list.add("abc");
        list.add("abcdd");
        list.add("abcddd");
        list.add("abc");

        //去除集合中的重复元素
        //创建一个新集合
        ArrayList newList = new ArrayList();

        for (int i = 0; i < list.size(); i++) {
           String  oldEle = (String) list.get(i);
           if(!newList.contains(oldEle)){
               newList.add(oldEle);
           }

        }
        System.out.println(newList);
    }
    另一种
    private static ArrayList<String> qudiao(ArrayList<String> list) {
        //判断元素有没有重复
        for (int i = 0; i < list.size(); i++) {
            String obj = list.get(i);
            if (list.indexOf(obj) != list.lastIndexOf(obj)) {
                list.remove(obj);
                return qudiao(list);
            }
        }
        return list;
        另一种
         for (int i = 0; i < list.size(); i++) {
            for (int j = i + 1; j < list.size(); j++) {
                String str = (String) list.get(i);
                String str2 = (String) list.get(j);
                if (str.equals(str2)) {
                    list.remove(str2);
                    j--;
                }
            }