1.单列集合(接口 Collection，List，Set)

单列集合(接口 Collection，List，Set)

单列集合体系结构:

特点:

1.List系列集合:	添加的元素是有序、可重复、有索引；
2.Set系列集合:	添加的元素是无序、不重复、无索引；
3.有序为存入和取出都是一样的顺序，非内部里的顺序；

Collection

概念:

Collection是单列集合的祖宗接口,它的功能是全部单列集合都可以继承使用的。

注意点：

Collection是一个接口,我们不能直接创建他的对象所以，现在我们学习他的方法时，只能创建他实现类的对象
使用多态方法创建记住编译看左,运行看右:
	如:Collection<String> coll = new ArrayList<>();

常用方法:

public boolean add(E e)					添加
public void clear()						清空 
public boolean remove(E e)				删除
public boolean contains(object obj)		判断元素是否包含
public boolean isEmpty()				判断集合是否为空
public int size()						集合长度

各别方法细节:

1.添加:
	细节1:如果我们要往List系列集合中添加数据,那么方法永远返回true,因为List系列的是允许元素重复的;
	细节2:如果我们要往Set系列集合中添加数据,如果当前要添加元素不存在,方法返回true,表示删除成功;如果已存在,方法返回false表示删	  除失败;因为Set系列的集合不允许重复;

2.删除:
	细节1:因为Collection里面定义的是共性的方法,所以此时不能通过索引进行删除。只能通过元素的对象进行删除;
	细节2:方法会有一个布尔类型的返回值,删除成功返回true,删除失败返回false;删除元素不存在,就会失败;
	细节3:如果有多个重复元素,只会删除最近元素;

3.判断是否包含:
	细节:底层是依赖equals方法进行判断是否存在的;
	所以,如果集合中存储的是自定义对象,也想通过contains方法来判断是否包含,那么在javabean类中,一定要重写equals方法;

单列集合遍历方法:

迭代器遍历:

• 迭代器在遍历集合的时候是不依赖索引的，是通过创建指针并移动指针来遍历集合的;

• 常用方法:

  Iterator<E> iterator()	:	获取一个迭代器对象
  boolean hasNext()		:	判断当前指向的位置是否有元素
  E next()				:	获取当前指向的元素并移动指针
  void remove()			:	从迭代器指向的collection中移除迭代器返回的最后一个元素
  

• 细节注意点:

  1.报错NoSuchElementException(没有这个元素异常);
  2.迭代器遍历完毕,指针不会复位(要再次遍历,需要重新获取一个新的迭代器对象);
  3.循环中只能用一次next方法;
  4.迭代器遍历时,不能用集合的方法进行增加或者删除,可以用迭代器的remove方法删除元素;
  

• 例子:

  package com.caihongjia.mycollection;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Iterator;
  
  public class A03_CollectionDemo3 {
      public static void main(String[] args) {
          /*
              Iterator<E> iterator() :  获取一个迭代器对象
              boolean hasNext()     :  判断当前指向的位置是否有元素
              E next()            :  获取当前指向的元素并移动指针
          */
          Collection<String> coll = new ArrayList<>();
          coll.add("aaa");
          coll.add("bbb");
          coll.add("ccc");
          coll.add("ddd");
          
          Iterator<String> it = coll.iterator();
          while(it.hasNext()){
              String str = it.next();
              System.out.println(str);
          }
  
          Iterator<String> it2 = coll.iterator();
          while(it2.hasNext()){
              String str = it2.next();
              if ("bbb".equals(str)){
                  it2.remove();
              }
              System.out.println(str);
          }
  
          System.out.println(coll);
  
      }
  }
  

增强for遍历:

• 增强for的底层就是迭代器，为了简化迭代器的代码书写的；

• 所有的单列集合和数组才能用增强for进行遍历；

• 内部原理就是一个Iterator迭代器；

• 书写格式：

  for(元素的数据类型 变量名 : 数组或者集合){
  
  }
  

• 细节：

  1.s是一个第三方变量,再循环的过程中依次表示循环的每一个数据;
  2.修改增强for中的变量,不会改变集合中原本的数据;
  

• 例子：

  package com.caihongjia.mycollection;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Iterator;
  
  public class A05_CollectionDemo5 {
      public static void main(String[] args) {
  
          Collection<String> coll = new ArrayList<>();
          coll.add("zhangsang");
          coll.add("lisi");
          coll.add("wangwu");
  
  
          //s是一个第三方变量,再循环的过程中依次表示循环的每一个数据;
  //        for (String s : coll){
  //            System.out.println(s);
  //        }
  
          for (String s : coll) {
              s = "qqq";
          }
  
          System.out.println(coll);
      }
  }
  

lambda表达式遍历(匿名内部类简写):

• 常用方法:

  default void forEach(Consumer<? super T> action) 	:	 结合lambda遍历集合
  

• 底层原理:

  1.在底层自己遍历集合,依次得到每一个元素;
  2.把得到的每一个元素,传递给下面的accept方法;
  3.变量s依次表示集合中的每一个数据;
  

• 例子:

  package com.caihongjia.mycollection;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.function.Consumer;
  
  public class A06_CollectionDemo6 {
      public static void main(String[] args) {
  
          Collection<String> coll = new ArrayList<>();
          coll.add("zhangsang");
          coll.add("lisi");
          coll.add("wangwu");
  
  
          //匿名内部类写法:
          /*
          coll.forEach(new Consumer<String>() {
              @Override
              public void accept(String s) {
                  System.out.println(s);
              }
          });
          
           */
  
          //lambda表达式写法:
          coll.forEach(s->System.out.println(s));
      }
  }
  
  

List集合:

常用方法:

void add(int index,E element)	:	在此集合中的指定位置插入指定的元素
E remove(int index)				:	删除指定索引处的元素,返回被删除的元素
E set(int index,E element)		:	修改指定索引处的元素,返回被修改的元素
E get(int index)				:	返回指定索引处的元素

细节:

删除元素:
	在调用方法的时候,如果方法出现了重载现象;
	优先调用,实参与形参类型一致的那个方法;

遍历方法:

• 迭代器遍历

• 增强for遍历

• lambda表达式遍历

• 普通for遍历

• 列表迭代(List系列独有的方式):

  • 常用方法:

    ListIterator<E> listIterator()	:	获取一个列表迭代器对象
    boolean hasNext()				:	判断当前指向的位置是否有元素
    E next()						:	获取当前指向的元素并移动指针
    void add(E e)					:	将指定元素插入列表
    void remove()					:	从迭代器指向的collection中移除迭代器返回的最后一个元素
    

  • 例子:

    package com.caihongjia.mylist;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.ListIterator;
    
    public class A03_ListDemo3 {
        public static void main(String[] args) {
            List<String> list = new ArrayList<>();
    
            list.add("aaa");
            list.add("bbb");
            list.add("ccc");
    
            System.out.println(list);
    
            //列表迭代器
            ListIterator<String> it = list.listIterator();
            while(it.hasNext()){
                String s = it.next();
                if ("bbb".equals(s)){
                    it.add("qqq");
                }
            }
            System.out.println(list);
        }
    }
    
    

Set集合:

特点：

无序、不重复、无索引；
Set集合的方法上基本上与Collection的API一致；

Set集合实现类特点：

HashSet: 无序、不重复、无索引；
LinkedHashSet: 有序、不重复、无索引；
TreeSet: 可排序、不重复、无索引；