集合

集合

1.集合体系结构

• Collection（单列集合）：是单列集合的祖宗接口，他的功能是全部单列集合都可以继承使用的

  • 脉动

    康师傅

    奥利奥

  • List集合：添加到元素是有序，可重复，有索引

    • ArrayList（实现类）
    • LinkedList（实现类）
    • Vector（过时实现类）

  • Set（集合）：添加的元素是无序，不重复，无索引

    • HashSet(实现类)
      • LinkedHashSet
    • TreeSet（实现类）

• Map（双列集合）

  • 脉动 3元

    康师傅 五元

2.Collection用法

package JH;

import java.util.ArrayList;
import java.util.Collection;

public class Demo01 {
    /**
     Collection接口的使用
     public boolean add(E e)                  添加
     public void clear()                      清空
     public boolean remove(E e)               删除
     public boolean contains(Object obj)      判断是否包含
     public boolean isEmpty()                 判断是否为空
     public int size()                        集合长度

     */
    public static void main(String[] args) {
        /*


       注意点：
            Collection是一个接口，我们不能直接创建它的对象。
            所以，现在我们学习他的方法时，只能创建他实现类的对象
            eg.实现类：ArrayList
         */
            //目的：为了学习Collection接口里面的方法
            //自己再做一些联系的时候，还是按照之前的方式去创建对象

        Collection<String> coll=new ArrayList<>();

        //1.添加元素
        //细节1：如果我们要往List系列集合中添加数据，那么方法永远为true，因为list系列是允许元素重复的
        //细节2：如果我们要往Set系列集合中添加数据，如果当前元素不存在，返回true，表示添加成功
        //                                   如果当前要添加的元素已经存在，方法返回false，表示添加失败
        //                                   因为Set系列的集合不允许重复
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        System.out.println(coll);

        //2.清空
         //coll.clear();

        //3.删除
        //细节1：因为Collectio里面定义的是共性的方法，所以此时不能通过索引进行删除，只能通过元素的对象进行删除
        //细节2：方法回应一个布尔类型的返回值，删除成功返回true，删除失败返回false
        //如果要删除的元素不存在就会删除失败
        System.out.println(coll.remove("aaa"));
        System.out.println(coll);

        //4.判断元素是否包含
        //细节：底层是依赖equals（）方法进行判断是否存在
        //所以，如果集合中存储的是自定义对象，也想通过contains方法判断是否包含，那么在Javabean中，一定要重写equals方法
        boolean result =coll.contains("bbb");
        System.out.println(result);

        //5.判断集合是否为空
        boolean result2=coll.isEmpty();
        System.out.println(result2);//false

        //6.获取集合长度
        int size= coll.size();

    }
}

package JH;

import java.util.ArrayList;
import java.util.Collection;

public class Demo012 {
    public static void main(String[] args) {
        //1.创建集合对象
        Collection<Student> coll=new ArrayList<>();

        //2.创建三个学生对象
        Student s1 = new Student("zhangsan",23);
        Student s2 = new Student("lisi",24);
        Student s3 = new Student("wangwu",25);

        //3.把学生对象添加到对象中
        coll.add(s1);
        coll.add(s2);
        coll.add(s3);

        //4.判断集合中某一个学生对象是否包含
        Student s4 = new Student("zhangsan",23);
        //因为contains方法在底层依赖equals方法判断对象是否一致的
        //如果村的是自定义对象，没有重写equals方法，那么默认使用Object类中的equals方法进行判断，而Object类equals方法，依赖地址值进行判
        //如果同名同姓同年龄，就认为是同一个学生
        //所以，需要在自定义Javabean类中，重写equals方法
        System.out.println(coll.contains(s4));//true


    }
}

package JH;

import java.util.Objects;

public class Student {
    private String name;
    private int age;


    public Student(){

    }
    public Student(String name, int age) {

        this.name = name;
        this.age=age;
    }

    public String getName() {
        return name;
    }


    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }


    @Override
    public boolean equals(Object o) {
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

3.Collection的遍历方式

package JH;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Demo02 {
    public static void main(String[] args) {
        /*
        Coolection系列三种通用的遍历方式：
        1.迭代器遍历
        2.增强佛如遍历
        3.lambda表达式遍历

        迭代器相关的三个方法
        Iterato<E> iterator();      获取一个迭代器对象
        boolean hasNext（）；        判断当前指向的位置是否有元素
        E next（）         ；        获取当前指向的元素并移动指针

         */


        //1.创建集合并添加元素
        Collection<String> coll=new ArrayList<>();
        coll.add("aaa");
        coll.add("bbb");
        coll.add("ccc");
        coll.add("ddd");

        //2.获取迭代器对象
        //迭代器就好比是一个箭头，默认指向集合的0索引处
        Iterator<String> it=coll.iterator();
        //3.利用循环不断地去获取集合中的每一个元素
        while(it.hasNext()){
            String str=it.next();
            System.out.println(str);
        }
    }
}

• 迭代器遍历注意细节

  package JH;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Iterator;
  
  public class Demo022 {
      public static void main(String[] args) {
          /*
          迭代器的细节注意点：
          1.报错NoSuchElementException
          2.迭代器遍历完毕，指针不会复位
          3.循环中只能用一次next方法
          4.迭代器遍历时，不能用集合的方法进行增加或删除
           */
          //1.创建集合并添加元素
          Collection<String> coll=new ArrayList<>();
          coll.add("aaa");
          coll.add("bbb");
          coll.add("ccc");
          coll.add("ddd");
  
          //2.获取迭代器对象
          //迭代器就好比是一个箭头，默认指向集合的0索引处
          Iterator<String> it=coll.iterator();
          //3.利用循环不断地去获取集合中的每一个元素
          while(it.hasNext()){
              String str=it.next();
              System.out.println(str);
          }
  
          //当上面循环结束后，迭代器的指针已经指向了最后没有元素的位置
          //System.out.println(it.next());//NoSuchElementException
  
          //迭代器遍历完毕，指针不会复位
          System.out.println(it.hasNext());
          System.out.println(it.hasNext());
  
          //如果我们继续第二次遍历集合，只能获取一个新的迭代器对象，此时这个迭代器与第一个没有关系
          Iterator<String> iterator= coll.iterator();
          while(iterator.hasNext()){
              String str=iterator.next();
              System.out.println(str);
          }
      }
  }
  
  

  package JH;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Iterator;
  
  public class Demo023 {
      public static void main(String[] args) {
  
  
          /*
          迭代器的细节注意点：
          1.报错NoSuchElementException
          2.迭代器遍历完毕，指针不会复位
          3.循环中只能用一次next方法
          4.迭代器遍历时，不能用集合的方法进行增加或删除,
          如果实在要删除，可以用迭代器里的remove方法进行删除
          如果要添加，则暂时没办法
           */
  
              //1.创建集合并添加元素
              Collection<String> coll=new ArrayList<>();
              coll.add("aaa");
              coll.add("bbb");
              coll.add("ccc");
              coll.add("ddd");
              coll.add("eee");
  
              //2.获取迭代器对象
              //迭代器就好比是一个箭头，默认指向集合的0索引处
              Iterator<String> it=coll.iterator();
              //3.利用循环不断地去获取集合中的每一个元素
              while(it.hasNext()){
                  //4.next方法的两件事情：获取元素，并移动指针
                  //奇数报错，偶数不报错
                 // System.out.println(it.next());
                  //System.out.println(it.next());//NoSuchElementException
                  String str=it.next();
  
                  if("bbb".equals(str)){
                     // coll.remove("bbb");
                      it.remove();
                  }
                 // System.out.println(coll);//ConcurrentModificationException  第四个注意点，
  
  
              }
  
          System.out.println(coll);//oncurrentModificationException  第四个注意点，
  
      }
  }
  

List中常见的方法和五种遍历方式

• List集合的特点：

  • 有序：存和取的元素顺序一致
  • 有索引：可以通过索引操作元素
  • 可重复：存储的元素可以重复

• 特有方法：

  • Collection的方法都被继承了
  • List集合因为有索引所以多了很多索引操作的方法

  public class Demo01 {
      public static void main(String[] args) {
  
  
      /*
  
      List集合中独有的方法
      void add(int index,e element)         再次集合中的指定位置插入指定元素
      E remove(int index)                   删除指定索引处的元素，返回被删除的元素
      E set(int index,E element)            修改指定索引的元素，返回被修改的元素
      E get(int index)                      返回指定索引处的元素
       */
  
          //1.创建一个集合
          List<String> list=new ArrayList<>();
  
          //2.添加元素
          list.add("aaa");
          list.add("bbb");
          list.add("ccc");
  
          //    void add(int index,e element)
          //细节：原来索引上的元素会后移
          //list.add(1,“qqq”）
  
          //   E remove(int index)                   删除指定索引处的元素，返回被删除的元素
          String remove=list.remove(0);
          System.out.println(remove);
  
          //    E set(int index,E element)            修改指定索引的元素，返回被修改的元素
          String result=list.set(0,"qqq");
          System.out.println(result);
  
          //    E get(int index)                      返回指定索引处的元素
          String s=list.get(0);
          System.out.println(s);
  
          //3.打印集合
          System.out.println(list);
   }
  }
  

• List中删除的两种方法

  public class Demo02 {
      public static void main(String[] args) {
  
  
          //List系列集合中的两个删除的方法
          //1.直接删除元素
          //2.通过索引进行删除
  
          //1.创建集合并添加元素
          List<Integer> list=new ArrayList<>();
          list.add(1);
          list.add(2);
          list.add(3);
  
          /*
          2.删除元素
          请问：此时删除的是1这个元素还是索引
          因为在调用方法的时候，如果方法出现了重载现象，优先调用，实参跟形参类型一致的那个方法
          list。remove（1）
           */
          //list.remove(1);
  
          //手动装箱
          Integer i=Integer.valueOf(1);
  
          list.remove(i);
  
          System.out.println(list);
  
  
      }
  }