java学习笔记-集合1(韩顺平)

1.集合介绍

• 集合的理解和好处

  • 数组

    1. 长度开始时必须指定，而且一旦指定，不能修改

    2. 保存的必须为同一类型的元素

    3. 使用数组进行增加/删除元素的示意代码-比较麻烦

  • 集合

    1. 可以动态保存任意多个对象，使用比较方便

    2. 提供一系列方便的操作对象的方法：add、remove、set、get

    3. 使用集合添加，删除新元素的示意代码-简介了

2.集合的框架体系

• 单列集合

  

• 双列集合

  

• 解读

  1. 集合主要是两组(单列集合，双列集合)

  2. Collection 接口有两个重要的子接口 List Set，他们的实现子类都是单列集合

  3. Map接口实现子类是 双列集合，存放的 K-V

  4. 记住这两张图

3.Collection

• Collection接口实现类的特点

  public interface Collection <E> extends Iterable<E>

  1. collection实现子类可以存放多个元素，每个元素可以是Object

  2. 有些Collection的实现类，有些是有序的(List)，有些不是有序的(Set)

  3. Collection接口没有直接的实现子类，是通过它的子接口Set和List来实现的

• Collection接口常用方法，以实现子类ArrayList来演示

  1. add：添加单个元素

  2. remove：删除指定元素

  3. contains：查找元素是否存在

  4. size：获取元素个数

  5. isEmpty：判断是否为空

  6. clear：清空

  7. addAll：添加多个元素

  8. containsAll：查找多个元素是否都存在

  9. removeAll：删除多个元素

  10. 说明：以ArrayList实现类来演示

  package com.mdklea.collection_;
  ​
  import java.util.ArrayList;
  import java.util.List;
  ​
  public class Collection_ {
      @SuppressWarnings("all")
      public static void main(String[] args) {
          List list = new ArrayList();
          //add 添加单个元素
          list.add("jack");
          list.add(10);//list.add(new Integer(10))
          list.add(true);//list.add(new Boolean(true))
          System.out.println(list);//list中均为对象
          //remove删除指定元素
          list.remove(0);//删除第一个元素
          System.out.println(list);
  //        list.remove(true);//指定删除
          System.out.println(list);
          //contains查找元素是否存在
          System.out.println(list.contains("jack"));
          //size返回元素的个数
          System.out.println(list.size());
          //isEmpty判断我们的集合是否为空
          System.out.println(list.isEmpty());
  //        list.clear();
          System.out.println(list);
          //addAll添加多个元素
          List list2 = new ArrayList();
          list2.add("红楼梦");
          list2.add("三国演义");
          list2.add("西游记");
          list.addAll(list2);
          System.out.println(list);
          //containsAll查找多个元素是否都存在
          System.out.println(list.containsAll(list2));
          //removeAll删除多个元素
          list.removeAll(list2);
          System.out.println(list);
          //说明：以ArrayList实现的类来演示
      }
  }

4.迭代器遍历

• Collection接口遍历元素方式1-使用Iterator(迭代器)

  1. Iterator对象称为迭代器，主要用于遍历Collection集合中的元素。

  2. 所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象，即可以返回一个迭代器。

  3. Iterator的结构。

     

  4. Iterator仅用于遍历集合，Iterator本身并不存放对象。

     

• package com.mdklea.collection_;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Iterator;
  
  @SuppressWarnings("all")
  public class CollectionIterator {
  
      public static void main(String[] args) {
          Collection col = new ArrayList();
          col.add(new Book("三国演义","罗贯中",10.1));
          col.add(new Book("小李飞刀","古龙",5.1));
          col.add(new Book("红楼梦","曹雪芹",34.1));
          col.add("jack");
          //System.out.println(col);
          //现在希望能够遍历该集合
          //1. 先得到col对应的迭代器
          Iterator iterator = col.iterator();
          //2.使用while循环来遍历
  //        while (iterator.hasNext()){//判断是否还有数据
  //            //返回下一个元素，类型是Object
  //            Object next = iterator.next();
  //            System.out.println(next);
  //        }
          //快捷键 快捷生成while itit
          //显示所有的快捷键的快捷键 ctrl + j
          while (iterator.hasNext()) {
              Object next = iterator.next();
              System.out.println(next);
          }
          //当退出while循环后，iterator迭代器指向最后的元素
  //        iterator.next();//NoSuchElementException
          //如果需要再次遍历需要重置我们的迭代器
          iterator = col.iterator();
          System.out.println("第二次遍历");
          while (iterator.hasNext()) {
              Object next = iterator.next();
              System.out.println(next);
          }
      }
  }
  class Book {
      private String name;
      private String author;
      private double price;
  
      public Book(String name, String author, double price) {
          this.name = name;
          this.author = author;
          this.price = price;
      }
  
      public String getName() {
          return name;
      }
  
      public void setName(String name) {
          this.name = name;
      }
  
      public String getAuthor() {
          return author;
      }
  
      public void setAuthor(String author) {
          this.author = author;
      }
  
      public double getPrice() {
          return price;
      }
  
      public void setPrice(double price) {
          this.price = price;
      }
  
      @Override
      public String toString() {
          return "Book{" +
                  "name='" + name + '\'' +
                  ", author='" + author + '\'' +
                  ", price=" + price +
                  '}';
      }
  }

5.for循环增强

• Collection接口遍历对象方式2-for循环增强

  增强for循环，可以代替iterator迭代器，特点：增强for就是简化版的iterator，本质一样。只能用于遍历集合或数组。

• 基本语法

  for(元素类型 元素名 : 集合名或数组名) {

  访问元素

  }

• 快捷方式：I

练习

package com.mdklea.collection_;
​
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
​
public class CollectionExercise {
    @SuppressWarnings({"all"})
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(new Dog("小白",20));
        list.add(new Dog("小花",10));
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            Object next = iterator.next();
            System.out.println(next);
        }
        for (Object o :list) {
            System.out.println(o);
        }
​
    }
}
class Dog {
    private String name;
    private int age;
​
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", 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;
    }
}

6.List接口和常用方法

• List接口基本介绍

  List接口时Collecation接口的子接口

  1. List集合类中元素有序(即添加顺序和取出顺序一致)、且可重复

  2. List集合类中每个元素都有其对应的顺序索引，即支持索引。

  3. List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据符号存取容器中的元素。

  4. JDK API中List接口的集合类有

     

     常用的有：ArrayList、LinkedList和Vector

• 常用方法

  1. void add(int index,Object ele)：在index位置插入ele元素

  2. boolean addAll(int index,Collection eles);从index位置开始将eles中所有元素添加进来

  3. Object get(int index)：获取指定index索引位置的元素

  4. int indexOf(Object obj)：返回obj在当前集合中首次出现的位置

  5. int lastIndexOf(Object obj)：返回obj在当前集合中末次出现的位置

  6. Object remove(int index);移除指定index位置的元素，并返回此元素

  7. Object set(int index,Object ele)：设置指定index位置的元素为ele，相当于是替换

  8. List subList(int fromindex,int toIndex)：返回从fromIndex到toIndex位置的子集合

• List的三种遍历方式[ArrayList,LinkedList,Vector]

  1. 方式一：使用iterator

     Iterator iter = col.iterrator();

  2. 方式二：使用增强for

     for(Object o : col){

     }

  3. 方式三：使用普通for

     for(int i = 0;i < list.size();i++) {

     Object o = list.get(i);

     System.out.println(o);

     }

     说明：使用LinkList完成 使用方式和ArrayList一样

• 练习

  package com.mdklea.list_;
  ​
  import java.util.ArrayList;
  import java.util.List;
  ​
  public class ListExercise02 {
      @SuppressWarnings({"all"})
      public static void main(String[] args) {
          List list = new ArrayList();
          list.add(new Book("三国演义",300.5,"罗贯中"));
          list.add(new Book("红楼梦二",100.5,"曹雪芹"));
          list.add(new Book("小李飞刀",200.5,"古龙"));
  //        for (int i = 0; i < list.size() - 1; i++) {
  //            for (int j = 0; j < list.size() - i - 1; j++) {
  //                Book book = (Book) list.get(j);
  //                Book book2 = (Book) list.get(j + 1);
  //                if (book.getPrice() > book2.getPrice()) {
  //                    list.set(j,book2);
  //                    list.set(j + 1,book);
  //                }
  //            }
  //        }
  //        for (int i = 0; i < list.size(); i++) {
  //            Book book = (Book)list.get(i);
  //            System.out.println("名称:" + book.getName() + "\t\t" +
  //                               "价格:" + book.getPrice() + "\t\t" +
  //                               "作者:" + book.getAuthor());
  //        }
          Book.sort(list);
          for (Object o : list) {
              System.out.println(o);
          }
      }
  }
  ​
  ​
  ​
  class Book {
      @SuppressWarnings({"all"})
      private String name;
      private double price;
      private String author;
  ​
      public Book(String name, double price, String author) {
          this.name = name;
          this.price = price;
          this.author = author;
      }
  ​
      public String getName() {
          return name;
      }
  ​
      public void setName(String name) {
          this.name = name;
      }
  ​
      public double getPrice() {
          return price;
      }
  ​
      public void setPrice(double price) {
          this.price = price;
      }
  ​
      public String getAuthor() {
          return author;
      }
  ​
      public void setAuthor(String author) {
          this.author = author;
      }
  ​
      public static void sort(List list) {
          int len = list.size();
          for (int i = 0; i < len - 1; i++) {
              for (int j = 0; j < len - 1 - i; j++) {
                  Book book1 = (Book) list.get(j);
                  Book book2 = (Book) list.get(j + 1);
                  if (book1.getPrice() > book2.getPrice()){
                      list.set(j,book2);
                      list.set(j + 1,book1);
                  }
              }
          }
      }
  ​
      @Override
      public String toString() {
          return "名称:" + getName() + "\t\t" +
                  "价格:" + getPrice() + "\t\t" +
                  "作者:" + getAuthor();
      }
  }

7.AraryList

• ArrayList的注意事项

  1. permits all elements,including null,ArrayList 可以加入null并且多个

  2. ArrayList是由数组来实现数据储存的

  3. ArrayList基本等同于Vector，除了ArrayList是线性不安全的(执行效率高)，在多线程情况下，不建议使用ArrayList

• ArrayList底层机制源码分析

  1. ArrayList中维护了一个Object类型的数组elementData。

     transient Object[] elementData;//transient 表示瞬间，短暂的，表示该属性不会被序列化

  2. 当创建对象时，如果使用的是无参构造器，则初始elementData容量为0(jdk7是10)

  3. 当添加元素时：先判断是否需要扩容，如果需要扩容，则调用grow方法，否则直接添加元素到合适位置

  4. 如果使用的是无参构造器，如果第一次添加，需要扩容的话，则扩容elementData为10，如果需要再次扩容的话，则扩容elementData为1.5倍

  5. 如果使用的是指定容量capacity的构造器，则初始elementData容量为capacity

  6. 如果使用的是指定容量capacity的扩容器，如果需要扩容，则直接扩容elementData为1.5倍

8.Vector

• Vector的介绍

  1. Vector类的定义说明

     

  2. Vector底层也是一个对象数组，protected Object[] elementData;

  3. Vector是线性同步的，即线性安全，Vector类的操作方法带有synchronized

     

  4. 在开发中，需要线性同步安全时，考虑使用Vector

• Vector底层和ArrayList比较

  

9.LinkedList

• LinkedList的全面说明

  1. LinkedList底层实现了双向链表和双端队列特点

  2. 可以添加任意元素(元素可以重复)，包括null

  3. 线程不安全，没有实现同步

• 双向链表

  package com.mdklea.linkedlist;
  ​
  public class LinkedList_ {
      @SuppressWarnings({"all"})
      public static void main(String[] args) {
          //模拟一个简单的双向链表
          Node jack = new Node("jack");
          Node tom = new Node("tom");
          Node mdk = new Node("mdk");
          jack.next = tom;
          tom.next = mdk;
          mdk.pre = tom;
          tom.pre = jack;
          Node first = jack;
          Node last = mdk;
          //演示：从头到尾遍历
          while (true){
              if (first == null){
                  break;
              }else {
                  System.out.println(first);
                  first =first.next;
              }
          }
  ​
          first = jack;
  ​
          System.out.println("=========================");
  ​
          //演示链表添加数据
          Node smith = new Node("smith");
          smith.next = mdk;
          mdk.pre = smith;
          smith.pre = tom;
          tom.next = smith;
          while (true){
              if (first == null) {
                  break;
              }
              else {
                  System.out.println(first);
                  first = first.next;
              }
          }
      }
  }
  ​
  //定义一个Node类，Node对象表示双向链表的一个结点
  class Node {
      public Object item;
      public Node next;
      public Node pre;
      public Node(Object name) {
          this.item = name;
      }
  ​
      @Override
      public String toString() {
          return "Node name =" + item ;
      }
  }

• ArrayList和LinkedList比较

  

  如何选择ArrayList和LinkedList：

  1. 如果我们改查操作较多，选择ArrayList

  2. 如果我们增删操作多，选择LinkedList

  3. 一般来说，在程序中80%-90%都是查询，因此大部分情况下会选择ArrayList

  4. 在一个项目中，根据业务灵活选择，也可能这样，一个模块使用的是ArrayList，另一个模块是LinkedList,也就是说要根据业务来进行选择