集合进阶

迈不过友情╰ 2022-06-10 20:25 209阅读 0赞

## 集合&迭代器 ##

**集合体系结构**

*集合体系图*

![这里写图片描述][SouthEast]

public class CollectionDemo {
        public static void main(String[] args) {        
            //创建集合对象
            ArrayList al = new ArrayList();
            //添加元素
            al.add("hello");
            al.add("world");
            al.add("java");
            //遍历集合
            for(int x = 0;x < al.size();x++) {
                System.out.println(al.get(x));
            }
        }
    }

**Collection中常用的功能**

boolean add(Object e): 向集合中添加元素  
void clear():清空集合中所有元素  
boolean contains(Object o):判断集合中是否包含某个元素  
boolean isEmpty():判断集合中的元素是否为空  
boolean remove(Object o):根据元素的内容来删除某个元素  
int size():获取集合的长度  
Object\[\] toArray():能够将集合转换成数组并把集合中的元素存储到数组中

**迭代器**

java中提供了很多个集合，它们在存储元素时，采用的存储方式不同。我们要取出这些集合中的元素，可通过一种通用的获取方式来完成。  
Collection集合元素的通用获取方式：在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。  
集合中把这种取元素的方式描述在Iterator接口中。Iterator接口的常用方法如下  
hasNext（）方法：判断集合中是否有元素可以迭代  
next（）方法：用来返回迭代的下一个元素，并把指针向后移动一位。

import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    
    public class IteratorDemo {
        public static void main(String[] args) {
            //method();
            //创建集合对象
            Collection c = new ArrayList();
            //添加元素
            c.add("hello");
            c.add("world");
            c.add("java");
    
            //获取迭代器对象
            Iterator it = c.iterator();
    
            //Object next() :返回下一个元素
            //boolean hasNext() ：判断是否有元素可以获取
    
            /*if(it.hasNext()) System.out.println(it.next()); if(it.hasNext()) System.out.println(it.next()); if(it.hasNext()) System.out.println(it.next()); if(it.hasNext()) System.out.println(it.next());*/
    
            while(it.hasNext()) {
                System.out.println(it.next());
            }
        }
    
        private static void method() {
            //创建集合对象
            Collection c = new ArrayList();
            //添加元素
            c.add("hello");
            c.add("world");
            c.add("java");
            //获取数组
            Object[] objs = c.toArray();
            //遍历数组
            for (int i = 0; i < objs.length; i++) {
                System.out.println(objs[i]);
            }
        }
    }

**修改并发异常**

*并发修改异常产生原因:*  
当使用迭代器遍历集合的时候,使用了集合中的 增加/删除 方法,导致并发修改异常产

*并发修改异常解决方案:*

A:不使用迭代器遍历集合,就可以在遍历的时候使用集合的方法进行增加或删除
     B:依然使用迭代器遍历,那么就需要使用Iterator的子接口ListIterator来实现向集合中添加

## 增强for&泛型 ##

**泛型引入**

在前面学习集合时，我们都知道集合中是可以存放任意对象的，只要把对象存储集合后，那么这时他们都会被提升成Object类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换

import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    
    public class GenericDemo { 
        public static void main(String[] args) {
            //创建集合对象
            Collection  c = new ArrayList();
            //创建元素对象
            Student s = new Student("zhangsan",18);
            Student s2 = new Student("lisi",19);
            //添加元素对象
            c.add(s);
            c.add(s2);
            //遍历集合对象
    
            Iterator  it = c.iterator();
            while(it.hasNext()) {
                 String str = (String)it.next();
                 System.out.println(str);
            }
        }
    }
    
    class Student {
        String name;
        int age;
        public Student(String name,int age) {
            this.name = name;
            this.age = age;
        }
    }

以上代码会发生强制转换异常,原因就是String str = (String)it.next() ,存入集合的是Student,而强转为String,String与Student之间没有任何子父关系不能强转,未使用泛型前有可能发声强制转换异常的问题

**泛型的使用**

当类上定义<>的时候就可以使用泛型,例如ArrayList类的定义:  
class ArrayList,那么我们在创建ArrayList对象的时候就可以指定<>中E的类型  
ArrayList al=new ArrayList(),那么String就把E替换掉了

import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Iterator;
    
    public class GenericDemo { 
        public static void main(String[] args) {
            //创建集合对象
            Collection<Student> c = new ArrayList<Student>();
            //创建元素对象
            Student s = new Student("zhangsan",18);
            Student s2 = new Student("lisi",19);
            //添加元素对象
            c.add(s);
            c.add(s2);
            //遍历集合对象
    
            Iterator<Student> it = c.iterator();
            while(it.hasNext()) {
                //String str = (String)it.next();
                //System.out.println(str);
    
                Student stu = it.next();
                System.out.println(stu.name);
            }
        }
    }
    
    class Student {
        String name;
        int age;
    
        public Student(String name,int age) {
            this.name = name;
            this.age = age;
        }
    }

*泛型的好处*

避免了类型转换的问题
     可以减少黄色警告线
     可以简化我们代码的书写

**增强for**

增强for循环是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。

格式：
    for(元素的数据类型  变量 : Collection集合or数组){
    }

它用于遍历Collection和数组。通常只进行遍历元素，不要在遍历的过程中对集合元素进行增删操作。

import java.util.ArrayList;
    import java.util.Collection;
    
    public class ForEachDemo {
        public static void main(String[] args) {
             //创建集合对象
            Collection<String> c = new ArrayList<String>();
            //添加元素
            c.add("hello");
            c.add("world");
            c.add("java");
    
            //增强for循环遍历集合
            for(Object obj : c) {
                System.out.println(obj);
            }
    
    
            for(String s : c) {
                System.out.println(s.toUpperCase());
            }
    
            for (String string : c) {
                c.add("android");
                System.out.println(string);
            }
        }
    }

## 常见数据结构 ##

**数组**

数组，采用该结构的集合，对元素的存取有如下的特点：

查找元素快：通过索引，可以快速访问指定位置的元素
    增删元素慢 ,每次添加元素需要移动大量元素或这创建新的数组

![这里写图片描述][SouthEast 1]

**链表**

链表，采用该结构的集合，对元素的存取有如下的特点：

A:多个节点之间，通过地址进行连接。例如，多个人手拉手，每个人使用自己的右手拉住下个人的左手，依次类推，这样多个人就连在一起了。
    B:查找元素慢：想查找某个元素，需要通过连接的节点，依次向后查找指定元素
    C:增删元素快：
    增加元素：只需要修改连接下个元素的地址即可。
    删除元素：只需要修改连接下个元素的地址即可

![这里写图片描述][SouthEast 2]  
**栈&&队列**

A:堆栈，采用该结构的集合，对元素的存取有如下的特点：  
先进后出（即，存进去的元素，要在后它后面的元素依次取出后，才能取出该元素）。例如，子弹压进弹夹，先压进去的子弹在下面，后压进去的子弹在上面，当开枪时，先弹出上面的子弹，然后才能弹出下面的子弹。  
B:队列，采用该结构的集合，对元素的存取有如下的特点：  
先进先出（即，存进去的元素，要在后它前面的元素依次取出后，才能取出该元素）。例如，安检。排成一列，每个人依次检查，只有前面的人全部检查完毕后，才能排到当前的人进行检查。  
![这里写图片描述][SouthEast 3]

## List子体系 ##

**List子体系特点**

A:有序的（存储和读取的顺序是一致的） 
    B:有整数索引 
    C:允许重复的

**List的特有功能**

void add(int index, E element) :将元素添加到index索引位置上  
E get(int index) :根据index索引获取元素  
E remove(int index) :根据index索引删除元素  
E set(int index, E element):将index索引位置的的元素设置为element

public class ListDemo {
        public static void main(String[] args) {
            //创建的列表对象
            List list = new ArrayList();
    
            //void add(int index, E element) : 在指定索引位置添加指定元素
            list.add(0, "hello");
            list.add(0, "world");
            list.add(1, "java");
    
            //E get(int index) :根据索引返回元素
            /*System.out.println(list.get(0)); System.out.println(list.get(1)); System.out.println(list.get(2));*/
            //System.out.println(list.get(3));
    
            /*for (int i = 0; i < list.size(); i++) { System.out.println(list.get(i)); }*/
    
            //E remove(int index) : 删除指定元素并返回
    
            //System.out.println(list.remove(5));
    
            //E set(int index, E element) : 将指定索引位置的元素替换为指定元素，并将原先的元素返回
            System.out.println(list.set(0, "android"));
    
            System.out.println(list);
        }
    }

**LinkedList的特有功能**

LinkedList底层使用的是链表结构,因此增删快,查询相对ArrayList较慢  
void addFirst(E e) :向链表的头部添加元素  
void addLast(E e):向链表的尾部添加元素  
E getFirst():获取链头的元素,不删除元素  
E getLast():获取链尾的元素,不删除元素  
E removeFirst():返回链头的元素并删除链头的元素  
E removeLast():返回链尾的元素并删除链尾的元素

import java.util.LinkedList;
    
    public class LinkedListDemo {
        public static void main(String[] args) {
                LinkedList list = new LinkedList();
                list.add("hello");
                list.add("world");
    
                //void addFirst(E e) :将元素添加到索引为0的位置
                //void addLast(E e) ：将元素添加到索引为size()-1的位置
                list.addFirst("java");
                list.addLast("android");
    
                //E getFirst() :获取索引为0的元素
                //E getLast() ：获取索引为size()-1的元素
                //System.out.println(list.getFirst());
                //System.out.println(list.getLast());
    
                //E removeFirst() :删除索引为0的元素并返回
                //E removeLast() ：删除索引为size()-1的元素并返回
                System.out.println(list.removeFirst());
                System.out.println(list.removeLast());
                System.out.println(list);
        }
    }

[SouthEast]: /images/20220611/9d468cbe8fdb4f1899277d2ecf5371c3.png
[SouthEast 1]: /images/20220611/8493ce690c444be09516fdc119dc8f14.png
[SouthEast 2]: /images/20220611/8803e92f934943c4aba0a4ebc20922eb.png
[SouthEast 3]: /images/20220611/d2405f7efd0b4978bb16ba8da7ec6d9f.png