Java集合详细课堂笔记（附源码&详细阐述）

集合概述（课堂笔记）

• 集合就是一个容器，这个容器可以装很多其他的数据

• Collection(根类)

容器：

• 数组

• StringBuffer/StringBuilder

• append() insert()

• Collection

1、为什么会有集合？

​ 数组：长度固定！！！！

​ 存储学生的成绩，但是不知道学生有多少人

1.存储对象可以考虑，①数组 ②集合

2.数组存储对象的特点，Student[] stu =new Student[20]; stu[0] =new Student();…

​ > 弊端，①一旦创建，其长度不可变。②真实的数组存放的对象的个数是不可知的

2、集合体系

java集合可分为Collection和Map两种体系

• Collection接口：

  • Set：元素无序、不可重复的集合 （类似高中集合特性：确定性，无序性，互异性）
  • List：元素有序，可重复的集合（类似“动态”数组 如班级成绩，成绩有一样的）

• Map接口：具有映射关系“key-value对”的集合 —类似于高中的“函数” y=f(x) (x1,y1)(x2,y2)

3、接口方法介绍

package Collection1;


import java.util.*;

public class TextCollection {
    public static void main(String[] args) {
        TextCollection textCollection = new TextCollection();
//        textCollection.textCollection1();
//        textCollection.textCollection2();
        textCollection.textCollection3();
    }
    public void textCollection1(){
        Collection coll = new ArrayList();
        // 1. size() ：返回集合中元素的个数
        System.out.println(coll.size());
        // 2. add(Object obj) : 向集合中添加一个元素，默认Objcet类型
        coll.add(123);
        coll.add("AA");
        coll.add(new Date());
        coll.add("BB");
        System.out.println(coll.size());

        // 3. addAll(Collection coll) : 将形参coll中包含的所有元素添加到当前集合中
        Collection coll1 = Arrays.asList(1, 2, 3);
        coll.addAll(coll1);
        System.out.println(coll.size());

        //查看集合元素
        System.out.println(coll);

        // 4. isEmpty(); 判断集合是否为空
        System.out.println(coll.isEmpty());

        // 5. clear() : 清空集合元素
        coll.clear();
        System.out.println(coll.isEmpty());
    }

    public void textCollection2(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(new String("AA"));
        coll.add(new Date());
        coll.add("BB");
        Person p = new Person("MM", 23);
        coll.add(p);
        coll.add(new Person("mm",31));
        System.out.println(coll);

        // 6. contains(Object obj) : 判断集合中是否包含指定的obj元素，包含返回true，不包含返回false
        //判断的依据，根据元素所在的类的equals()方法进行判断
        //明确，如果存入集合中的元素是自定义类的对象，要求，自定义要重写equals()方法！
        boolean contains = coll.contains(123);
        contains = coll.contains("AA");
        System.out.println(contains);
        boolean contains1 = coll.contains(p);
        System.out.println(contains1);

        boolean mm = coll.contains(new Person("mm", 31));
        System.out.println(mm);

        // 7. containsAll(Collection coll) : 判断当前集合中是否包含coll中所有的元素
        Collection coll1 = new ArrayList();
        coll1.add(123);
        coll1.add(new String("AA"));
        boolean b = coll.containsAll(coll1);
        System.out.println(b);

        // 8. retainAll(Collection coll) : 求当前集合与coll的共有的元素，返回给当前集合
        coll.retainAll(coll1);

        // 9. remove(Object obj) ： 删除集合中的obj元素，若删除成功，返回true，否则，
        coll.remove("BB");
    }

    public void textCollection3(){
        Collection coll = new ArrayList();
        coll.add(123);
        coll.add(new String("AA"));
        coll.add(new Date());
        coll.add("BB");
        coll.add(new Person("MM",23));

        Collection coll1 = new ArrayList();
        coll1.add(123);
        coll1.add(new String("AA"));
        // 10. removeAll(Collection coll) : 从当前集合中删除包含在coll中的元素。
        coll.removeAll(coll1);
        System.out.println(coll);

        // 11. equals(Object obj) : 判断集合中的所有元素是否完全相同
        Collection coll2 = new ArrayList();
        coll2.add(123);
        coll2.add(new String("AA"));
        System.out.println(coll1.equals(coll2));

        // 12. hashCode():
        System.out.println(coll.hashCode());
        System.out.println();
        // 13. toArray() : 将集合转化为数组
        Object[] obj = coll.toArray();
        for (int i = 0; i < obj.length; i++) {
            System.out.println(obj[i]);
        }
        System.out.println();

        // 14. iterator()迭代器 : 返回一个Iterator接口实现类的对象,进而实现集合的遍历！
        Iterator iterator = coll.iterator();
        //方式1
//        System.out.println(iterator.next());
        //方式2
///        for (int i = 0; i < coll.size(); i++) {
///            System.out.println(iterator.next());
///        }
        //方式3
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

    }

}

4、Collection接口

4.1、List接口

存储有序的，可以重复的元素

• ArrayList(主要的实现类)

• package TestList;
  
  import java.util.ArrayList;
  import java.util.List;
  
  public class TestList {
      public static void main(String[] args) {
          TestList testList = new TestList();
  //        testList.textList1();
          testList.textList2();
      }
      //ArrayList, List的主要实现类  (动态数组)
  
      /*
      List中相对于Collection，新增加的方法
      void add(int index) : 在指定的索引位置index添加元素ele
      boolean addAll(int index,Collection eles):在指定位置添加eles集合中的所有元素
      Object get(int index):获取指定位置的元素
      Object remove(int index): 删除指定索引位置的元素
      Object set(int index,Object ele)：设置指定索引位置的元素为 ele
      int indexOf(Object obj): 返回obj在集合中首次出现的位置。没有的话，返回-1
      int lastIndexOf(Object obj): 返回obj在集合中最后一次出现的位置，没有的话，返回-1
      List subList(int fromIndex，int toIndex): 返回从fromTndex到toIndex
  
      List常用方法，增(add(Object obj))删(remove)
      改(set(int index,Object obj))查(get(int index))
      插(add(int index,Object ele))长度(size())
       */
      public void textList1(){
          List list = new ArrayList();
          // 1. add添加元素
          list.add(123);
          list.add(456);
          list.add(new String("AA"));
          list.add(new String("GG"));
          System.out.println(list);
          // 2. add向指定位置添加元素
          list.add(0, 555);
          System.out.println(list);
          // 3. get获取指定位置的元素
          Object o = list.get(1);
          System.out.println(o);
          // 4. remove删除指定索引位置的元素
          list.remove(0);
          System.out.println(list);
          // 5. set设置指定索引位置的元素
          list.set(0, 111);
          System.out.println(list);
  
  
      }
  
      public void textList2(){
          List list = new ArrayList();
          // 1. add添加元素
          list.add(123);
          list.add(456);
          list.add(new String("AA"));
          list.add(new String("GG"));
          list.add(456);
  
          System.out.println(list);
          System.out.println(list.indexOf(456));
          System.out.println(list.lastIndexOf(456));
          System.out.println(list.indexOf(123)==list.lastIndexOf(123));
          System.out.println(list.indexOf(444));
  
          List list1 = list.subList(0, 3);
          System.out.println(list1);
      }
  }
  

• LinkedList（对于频繁的插入、删除操作）

• Vector （古老的实现类、线程安全的）

4.2、Set接口

存储无序的，不可重复的元素

• HashSet
• LinkedHashSet
• TreeSet

package TextSet;

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

public class TextSet {
    public static void main(String[] args) {
        TextSet textSet = new TextSet();
//        textSet.testHashSet();
        textSet.testTreeSet1();
    }
    /*
     Collection接口：
         |----List接口存储有序的，可以重复的元素
                |----ArrayList(主要的实现类);
                |----LinkedList(对于频繁的插入、删除操作)、
                |----Vector(古老的实现类，线程安全的，但效率要低于ArrayList)
         |----Set接口，存储无序的，不可重复的元素.Set中常用的方法都是Collection下定义的。
                |----HashSet(主要实现类)
                |----LinkedHashSet
                |----TreeSet
     */

    public void testTreeSet1(){
        Set set =new TreeSet();
//        set.add(123);
//        set.add(456);//类型不兼容
//        set.add(new String("AA"));
//        set.add(new String("AA"));
//        set.add("JJ");
//        set.add("GG");
//        set.add("MM");
//      都是String类型


           /*
    TreeSet：
    1.向TreeSet中添加的元素必须是同一个类的。
    2.可以按照添加进集合中的元素的指定的顺序遍历。
    像String，包装类等默认按照从小到大的顺序遍历
    */


        //当Person没有实现Comparable接口时，当向
        // TreeSet中添加Person对象时，报ClassCastException错
        set.add(new Person("CC",23));
        set.add(new Person("MM",21));
        set.add(new Person("GG",25));
        set.add(new Person("JJ",24));
        set.add(new Person("DD",20));
        set.add(new Person("DD",19));
        for (Object str : set){
            System.out.println(str);
        }
        //字母顺序，指定的顺序，从小到大
    }




    public void testHashSet(){
        /*Set：存储的元素是无序的，不可重复的！
        1.无序性，无序性!=随机性
        真正的无序性，指的是元素在底层存储的位置是无序的。
        2.不可重复性，当向Set中添加进相同的元素的时候，后面的这个元素不能够添加进去

        说明，要求添加进Set中的元素所在类，一定要重写equals()和hashCode()方法
        进而保证Set中元素的不可重复性

        Set中的元素是如何存储的呢？ 使用了hashCode方法（哈希算法）
            当Set添加对象时，首先调用此对象所在类的hashCode()方法，计算此对象的哈希值，此
            哈希值决定了此对象在Set中的存储位置，若此位置之前没有对象存储，则这个对象存储到此位置
            若此位置已有对象存储，再通过equals()比较这两个对象是否相同，后一个对象就不能再添加进来。
            万一返回false呢，都存储，（不建议如此）
             > 要求，hashCode()方法要与equals()方法一致
        */
        Set set = new HashSet();
        set.add(123);
        set.add(465);
        set.add("AA");
        set.add("AA");
        set.add(new String("AA"));
        set.add(new String("AA"));
        set.add("BB");
        set.add(null);
        Person p1 = new Person("GG",23);
        Person p3 = new Person("GG",23);
        Person p2 = new Person("MM",21);
        System.out.println(p1.equals(p3));//没有重写equals，并且重写hashCode，不相同
        System.out.println(p3.hashCode());
        System.out.println(p1.hashCode());
        set.add(p1);
        set.add(p2);
        set.add(p3);
        System.out.println(set.size());
        System.out.println(set);//无序的
    }
}

5、Map接口

存储“键-值”对的数据

• HashMap
• LinkedHashMap
• TreeMap
• Hashtable（子类：Properties）

5.1、接口说明

• Map与Collection并列存在。用于保存具有映射关系的数据：Key-Value
• Map中的Key和Value都可以是任何引用类型的数据
• Map中的Key用Set来存放，不允许重复，即同一个Map对象所对应的类，需重写hashCode()和equals()方法
• 常用String类作为Map的“键”
• Key和Value之间存在单向一对一关系，即通过指定的Key总能找到唯一的、确定的Value

Map底层结构

package TextMap;

import java.lang.reflect.AnnotatedArrayType;
import java.util.HashMap;
import java.util.Map;

public class TestMap {
    /*
    * Collection接口
    *
    *
    * Map接口
    * 实现类：
    * - HashMap(主要实现类)
    * - LinkedHashMap
    * - TreeMap
    * - Hashtable
    *       - Properties
    *
    * */

    public static void main(String[] args) {
        TestMap testMap = new TestMap();
        testMap.test1();
    }

    //方法介绍
    /*
    Object put(Object key,Object value):向Map中添加一个元素
    Object remove(Object key): 按照指定的key删除此key-value
    void putAll(Map t) 添加Map类的对象t中所有的key-value添加进调用对象
    void clear() :清空
    Object get(Object key):获取指定的key的value值，若无指定的key，则返回null
    boolean containsKey(Object key) : 判断是否包含指定key
    boolean containsValue(Object value): 判断是否包含指定value 对应类型重写equals方法
    int size() :返回集合的长度
    boolean isEmpty() 判断是否为空
    boolean equals(Object obj)判断是否相等

    HashMap
    1.Key 不能重复  用Set存放|value 是Collection存放，可重复|
    一个Key-value对，是一个Entry，所有的Entry是用Set存放的，也是不可重复的
    2.向HashMap中添加元素时会调用Key所在类的equals方法，
    判断两个Key是否相同，若相同则只能添加进一个，旧的被覆盖，添加进新的值

    */


    public void test1(){
        Map map =new HashMap();
        ////put 添加 get 获取
        map.put("AA", 123);
        map.put("AA", 1234);
        System.out.println(map.get("AA"));
        System.out.println(map.get("AC"));
        System.out.println(map.size());
        map.put("BB", 123);
        map.put("CC", 1234);
        map.put(123, "DD");
        map.put(null, null);
                //person要重写equals
        map.put(new Person("DD",23),123);
        map.put(new Person("DD",23),12);
        ////remove 清空
        map.remove("AA");
        System.out.println(map.size());
        System.out.println(map);

        Map map1 =new HashMap();
        map1.put("AA", 12345);
        map1.put("AAC", 12345);
        map.putAll(map1);
        System.out.println(map);
        System.out.println(map1);
    }

}

6、Person 自定义类代码

package TextSet;

import java.util.Objects;

public class Person implements Comparable{
    private  String name;
    private Integer age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

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

    public Person(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
        super();
    }

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

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

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }


    //当向TreeSet中添加Person类的对象时，依据此方法，设定按照哪个属性排列。
    @Override
    public int compareTo(Object o) {
        if(o instanceof Person){
            Person p=(Person) o;
            return this.name.compareTo(p.name);
        }
        return 0;
    }
}