一、集合的引入及其概念

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: 双向链表结构: 查询效率低, 修改效率高

• 

  跟ArrayList用法基本一致