集合（一）集合的引入及其概念、List、ArrayList、LinkedList

ゝ一纸荒年。 2023-10-04 19:14 74阅读 0赞

## 一、集合的引入及其概念 ##

1.集合是用来解决数组相关缺点诞生的

数组固定长度，无法扩容

数组不是一个类没有方法，程序员只能自己写增删查改的方法

2.集合是什么？

集合只能存放对象

集合是可变长度的，不限制元素的类型，也可以限定元素的类型--泛型

集合可以自动扩容

3.集合包括（集合类位于java.util包）

*  Collection接口: 存储的单一对象
 *  List接口: 可重复,有序(次序, 有下标)
 *  Set接口: 唯一,无序(次序,没有下标)
 *  Map 接口: 存储的key/value键值对
 *  key 任意数据类型, value 任意数据类型
 *  key: 唯一, value 可重复
    
    1、 Iterator(迭代器)家族。主要用于遍历Colleciton接口的及其子类而设计。
    
    2、 Compaator(比较器), 在集合中存储对象时候，用于对象之间的比较
    
    3、 Collecitons是工具类。注意该类名带个s，一般就表示工具类。里面提供了N多静态方法，来对Colleciton集合进行操作。
    
    ## （二）List ##
    
    1.List是有序的，可重复的
    
    2.List常用的实现类:
    
    > 1.  ArrayList : 底层以数组结构存放元素
    > 2.  LinkedList: 底层以双向链表结构存放元素
    
    ## （三）ArrayList ##
    
    1.三个构造方法
    
        ArrayList() 
        构造一个初始容量为十的空列表。 
        ArrayList(Collection<? extends E> c) 
        构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。  
        ArrayList(int initialCapacity) 
        构造具有指定初始容量的空列表。  
        
    
    2.常见方法
    
        //创建ArrayList集合
                List list = null;
                list = new java.util.ArrayList();
                
                //添加元素 add() 往末尾添加元素
                list.add(1);  
                //1 int基本数据类型  自动装箱 Integer  向上转型: Object
                list.add("abc"); // 向上转型: Object
                list.add(1);
                list.add("hello");
                //add(int index, 元素) 往指定下标插入元素
                list.add(1,"word");
                System.out.println(list); //[1, word, abc, 1, hello]
        
                //修改元素  set()
                //修改下标为1的元素,修改为呵呵
                list.set(1,"呵呵");
                System.out.println(list);// [1, 呵呵, abc, 1, hello]
                //删除 remove(int 指定位置)
                //把下标为2的元素删除
                list.remove(2); //[1, 呵呵, 1, hello]
                System.out.println(list);
                //删除 remove(Object 元素)  删除第一个
                list.remove(new Integer(1));
                System.out.println(list);
                //清空 clear()
                //list.clear();
                //System.out.println(list);
        
                //获取指定下标的元素 get() //[呵呵, 1, hello]
                Object ele =  list.get(1);
                System.out.println(ele);
        
                //判断集合是否包含某个元素  contains()
                System.out.println("集合是否包含呵呵:"+list.contains("嘻嘻"));
        
                //元素个数 size()
                System.out.println("集合的元素个数:"+list.size());
        
                //是否是空:
                //list ==  null 判断这个list是否创建对象, 防止空指针异常
        
                // isEmpty() 判断集合是否是空集合, 没有添加元素  true 是空 false 不是空
                System.out.println(list.isEmpty());
        
                //变成数组 toArray()
                Object[] objects = list.toArray();
        
                //遍历集合, 把集合的元素一个一个获取
                for (int i = 0; i < list.size(); i++) {
                    System.out.println(list.get(i));
                }
        
                //如果get() 的下标大于等于 size() 抛IndexOutOfBoundsException 下标越界
                list.get(3);
        
    
    3.往ArrayList存放学生类时，比较是否相同要重写equals、hashCode方法
    
    （1）如果Student类中两个含有相同值的对象存放进去，用contains对list比较结果是false
    
        Student stu1 = new Student(1,"张三",21);
        System.out.println("stu1的hashCode:"+stu1.hashCode());
        Student stu2 = new Student(1,"张三",21);
        System.out.println("stu2的hashCode:"+stu2.hashCode());
        List list = new ArrayList();
        list.add(stu1);
        System.out.println(list.contains(stu2));
    
    原因：contains方法调用了equals ，list中的equals方法支持重复元素，所以要重写，还要重写hascode方法让他们的值一致，才是同一个对象
    
    （2）所以要重写equals、hashCode方法
    
        @Override 
        public boolean equals(Object o) {  
        
        if (this == o) 
            return true;    
            
        if (o == null || getClass() != o.getClass()) 
            return false;
            
        Student student = (Student) o;  
        
        return stuNo == student.stuNo && age == student.age &&    Objects.equals(name, student.name); 
        }
        
        /*
        原来没重写的从Object类继承:
        public boolean equals(Object obj) {
             return (this == obj);
        }
        */
        
        @Override 
        public int hashCode() {     
        return Objects.hash(stuNo, name, age); 
        }
    
    （3）遍历Arraylist
    
    普通遍历
    
        for (int i = 0; i < list.size(); i++) {
              System.out.println(list.get(i));
        }
    
    foreach遍历
    
        for(String str : list) {
        //其内部实质上还是调用了迭代器遍历方式，这种循环方式还有其他限制，不建议使用。
            System.out.println(str);
        }
    
    迭代器遍历
    
        Iterator iter = list.iterator();
                while(iter.hasNext()){
                    Object ele = iter.next();
                    //删除集合的元素
                    //调用集合的remove() 删除
                    //list.remove(ele);
                    //添加元素
                   // list.add("world");
                //避免出现ConcurrentModificationException异常
                    //调用迭代器的remove()
                    iter.remove();
                }
    
    学生类遍历
    
        for (int i = 0; i < list.size(); i++) {
              Student1 stu = (Student1)list.get(i);
              System.out.println(stu.toString());
         }
    
        重写toString()方法
    
        @Override
        public String toString() {
             final StringBuilder sb = new StringBuilder("Student").append(' ')
                        .append("姓名=")
                        .append(name)
                        .append(",语文成绩=")
                        .append(chinese)
                        .append(",数学成绩=")
                        .append(math)
                        .append(",英语成绩=")
                        .append(english)
                        .append("\n");
                return sb.toString();
        }
    
    （4）迭代器查询
    
        System.out.println("===================="); 
         //ListIterator 迭代器指针可以往上获取元素, 也可以向下获取 ListIterator listIter = list.listIterator(); listIter.next(); //第一个 
         Object ele = listIter.next();//第二个 
         listIter.previous(); //还是获取当前元素 
         Object prevEle = listIter.previous();//第一个
         // System.out.println(ele); 
         System.out.println(prevEle);
    
    ## LinkedList ##
    
    1.与ArrayList的用法
    
    ArrayList: 数组结构, 查询效率高, 修改(插入元素,删除元素)效率低
    
    LinkedList: 双向链表结构: 查询效率低, 修改效率高
 *  ![2b6983941c66428686f5d0861c3d3e3d.png][]![b619f7337f6d41b482531e1a10ce1c71.png][]
    
    跟ArrayList用法基本一致

[2b6983941c66428686f5d0861c3d3e3d.png]: https://img-blog.csdnimg.cn/2b6983941c66428686f5d0861c3d3e3d.png
[b619f7337f6d41b482531e1a10ce1c71.png]: https://img-blog.csdnimg.cn/b619f7337f6d41b482531e1a10ce1c71.png