集合

集合

集合概念:对象的容器,定义了对多个对象进行操作的常用方法。可以实现数组的功能。

与数组的区别:

  1. 数组长度固定,集合长度不固定

  2. 数组可以存储基本数据类型和引用数据类型,集合只能存储引用数据类型(要想存储基本数据类型,可以使用装箱的方法)

位置:java.util.*;

Collection集合

Collection体系集合:

 

Collection父接口

特点:集合层次结构中的根结点 。 集合表示一组被称为其元素的对象。 一些集合允许重复元素,而其他集合不允许。 有些被命令和其他无序

    • booleanadd(E e) 确保此集合包含指定的元素(可选操作)。
      boolean addAll(Collection c) 将指定集合中的所有元素添加到此集合(可选操作)。
      void clear() 从此集合中删除所有元素(可选操作)。
      boolean contains(Object o) 如果此集合包含指定的元素,则返回 true
      boolean containsAll(Collection c) 如果此集合包含指定 集合中的所有元素,则返回true。
      boolean equals(Object o) 将指定的对象与此集合进行比较以获得相等性。
      int hashCode() 返回此集合的哈希码值。
      boolean isEmpty() 如果此集合不包含元素,则返回 true
      Iterator iterator() 返回此集合中的元素的迭代器。
      default Stream parallelStream() 返回可能并行的 Stream与此集合作为其来源。
      boolean remove(Object o) 从该集合中删除指定元素的单个实例(如果存在)(可选操作)。
      boolean removeAll(Collection c) 删除指定集合中包含的所有此集合的元素(可选操作)。
      default boolean removeIf(Predicate filter) 删除满足给定谓词的此集合的所有元素。
      boolean retainAll(Collection c) 仅保留此集合中包含在指定集合中的元素(可选操作)。
      int size() 返回此集合中的元素数。
      default Spliterator spliterator() 创建一个Spliterator在这个集合中的元素。
      default Stream stream() 返回以此集合作为源的顺序 Stream
      Object[] toArray() 返回一个包含此集合中所有元素的数组。
      T[] toArray(T[] a) 返回包含此集合中所有元素的数组; 返回的数组的运行时类型是指定数组的运行时类型。

 

Collection的使用1

Collectin接口的使用:添加元素、删除元素、遍历元素、判断

 package com.jihe.collection;
 
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;
 
 /*
 collection接口的使用:
 1. 添加元素
 2. 删除元素
 3. 遍历元素
 4. 判断
  */
 public class Demo01 {
     public static void main(String[] args) {
         //首先先创建集合 Collection接口是不能直接实例化的,所以用它下面的是实现类
         Collection collection = new ArrayList();
 
         //1. 添加元素
         System.out.println("--------1.添加元素---------");
         collection.add("dog");
         collection.add("cat");
         collection.add("pig");
 
         System.out.println(collection.size());  //查看元素个数
         System.out.println(collection);   //打印集合(自动补了toString()方法) [dog, cat, pig]
 
         //2. 删除元素
         System.out.println("--------2.删除元素---------");
         //collection.remove("cat"); //删除指定元素
         //collection.clear();   //全部删除
         //System.out.println(collection); //[]
 
         //3. 遍历元素
         System.out.println("--------3.遍历元素---------");
         //两种遍历方法
         //1. 增强for
         System.out.println("3.1 增强for");
         for (Object o : collection) {
             System.out.println(o);
        }  //dog cat pig
         System.out.println("3.2 使用迭代器(迭代器是专门用来遍历集合的一种方式)");
         Iterator iterator = collection.iterator();
         while (iterator.hasNext()){
             String s = (String) iterator.next();
             System.out.println(s);
             //需要注意的是,在迭代器里,collection的remove()方法不能用,要想删除元素,用iterator.remove();
             //iterator.remove();
        }
 
         //4. 判断
         System.out.println("--------4.判断---------");
         System.out.println(collection.contains("pig"));  //集合中是否包含pig,包含返回true
         System.out.println(collection.isEmpty());  //查看集合是不是空 是的话返回true
    }
 }
 
 /*
 --------1.添加元素---------
 3
 [dog, cat, pig]
 --------2.删除元素---------
 --------3.遍历元素---------
 3.1 增强for
 dog
 cat
 pig
 3.2 使用迭代器(迭代器是专门用来遍历集合的一种方式)
 dog
 cat
 pig
 --------4.判断---------
 true
 false
 */

 

Collection的使用2

 

 package com.jihe.collection;
 
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;
 
 /*
 collection接口的使用: 保存学生信息
 1. 添加
 2. 删除
 3. 遍历
 4. 判断
  */
 public class Demo02 {
     public static void main(String[] args) {
         //首先先创建集合 Collection接口是不能直接实例化的,所以用它下面的是实现类
         Collection collection = new ArrayList();
         //创建学生
         Student s1 = new Student("张三", 18);
         Student s2 = new Student("张三", 18);
         Student s3 = new Student("张三", 18);
 
         //1. 添加
         System.out.println("--------1.添加---------");
         collection.add(s1);
         collection.add(s2);
         collection.add(s3);
 
         System.out.println(collection.size());  //查看个数
         System.out.println(collection);   //打印集合(自动补了toString()方法) [Student{name='张三', age=16}, Student{name='张四', age=19}, Student{name='张五', age=20}]
 
         //2. 删除
         System.out.println("--------2.删除---------");
         //collection.remove(s1); //删除指定的
         //collection.clear(); //全部删除
 
         //3. 遍历
         System.out.println("--------3.遍历---------");
         //两种遍历方法
         //1. 增强for
         System.out.println("3.1 增强for");
         for (Object o : collection) {
             Student s=(Student) o;
             System.out.println(s);
        }
         System.out.println("3.2 使用迭代器(迭代器是专门用来遍历集合的一种方式)");
         Iterator iterator = collection.iterator();
         while (iterator.hasNext()){
             Object ss = iterator.next();
             System.out.println(ss);
             //需要注意的是,在迭代器里,collection的remove()方法不能用,要想删除元素,用iterator.remove();
             //iterator.remove();
        }
 
         //4. 判断
         System.out.println("--------4.判断---------");
         System.out.println(collection.contains(s1));  //集合中是否包含s1,包含返回true
         System.out.println(collection.isEmpty());  //查看集合是不是空 是的话返回true
    }
 }
 /*
 --------1.添加---------
 3
 [Student{name='张三', age=18}, Student{name='张三', age=18}, Student{name='张三', age=18}]
 --------2.删除---------
 --------3.遍历---------
 3.1 增强for
 Student{name='张三', age=18}
 Student{name='张三', age=18}
 Student{name='张三', age=18}
 3.2 使用迭代器(迭代器是专门用来遍历集合的一种方式)
 Student{name='张三', age=18}
 Student{name='张三', age=18}
 Student{name='张三', age=18}
 --------4.判断---------
 true
 false
 */
 

 

List集合

List子接口 特点:有序、有下标、元素可以重复

具体的方法查看API

List接口的使用1

 package com.jihe.list;
 
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 import java.util.ListIterator;
 
 /*
 List接口的使用1
 特点:有序 、有下标 、可重复
  */
 public class Demo01 {
     public static void main(String[] args) {
         //创建集合
         List list = new ArrayList();
         //1.添加元素
         System.out.println("------1.添加元素------");
         list.add("苹果");
         list.add("香蕉");
         list.add(0,"橘子");
         list.add(0,"柚子");   //可以通过指定下标添加
         System.out.println(list.size());
         System.out.println(list);  //[柚子, 橘子, 苹果, 香蕉] 重复下标,按后边的,前一个往前,但是重复的都是最后一个,就报错了IndexOutOfBoundsException
 
         //2.删除元素 可通过元素值,也可通过下标
         System.out.println("------2.删除元素------");
         //list.remove("橘子");
         //list.remove(2);
         //System.out.println(list); //[柚子, 苹果]
 
         //3.遍历元素
         System.out.println("------3.遍历元素------");
         //3.1for循环
         System.out.println("3.1 因为有下标,所以可以使用for循环");
         for (int i = 0; i < list.size(); i++) {
             System.out.println(list.get(i));
        }
         //3.2增强for
         System.out.println("3.2 增强for");
         for (Object o : list) {
             System.out.println(o);
        }
         //3.3迭代器iterator()
         System.out.println("3.3迭代器iterator()");
         Iterator iterator = list.iterator();
         while (iterator.hasNext()){
             System.out.println(iterator.next());
        }
         //3.4列表迭代器listIterator()
         System.out.println("3.4列表迭代器listIterator()");
         ListIterator listIterator = list.listIterator();
         System.out.println("从前往后");
         while (listIterator.hasNext()){
             System.out.println(listIterator.nextIndex()+":"+listIterator.next());
        }
         System.out.println("从后往前");
         while (listIterator.hasPrevious()){
             System.out.println(listIterator.previousIndex()+":"+listIterator.previous());
        }
         //4.判断
         System.out.println("4.判断");
         System.out.println(list.contains("柚子"));
         System.out.println(list.isEmpty());
 
         //5.获取位置
         System.out.println("5.获取位置");
         System.out.println(list.indexOf("橘子"));
    }
 }
 /*
 ------1.添加元素------
 4
 [柚子, 橘子, 苹果, 香蕉]
 ------2.删除元素------
 ------3.遍历元素------
 3.1 因为有下标,所以可以使用for循环
 柚子
 橘子
 苹果
 香蕉
 3.2 增强for
 柚子
 橘子
 苹果
 香蕉
 3.3迭代器iterator()
 柚子
 橘子
 苹果
 香蕉
 3.4列表迭代器listIterator()
 从前往后
 0:柚子
 1:橘子
 2:苹果
 3:香蕉
 从后往前
 3:香蕉
 2:苹果
 1:橘子
 0:柚子
 4.判断
 true
 false
 5.获取位置
 1
  */

List接口的使用2

 package com.jihe.list;
 
 import java.util.ArrayList;
 import java.util.List;
 
 public class Demo02 {
     public static void main(String[] args) {
         //创建集合
         List list = new ArrayList();
         //添加数字数据 (这里面有一个自动装箱的操作)
         list.add(20);
         list.add(30);
         list.add(40);
         list.add(50);
         list.add(60);
         System.out.println(list.size());
         System.out.println(list);  //[20, 30, 40, 50, 60]
 
         //删除数据
         //list.remove((Object) 20); //注意,写数字的话,系统识别为是角标,可以前面加(object)标注,或者手动装箱 new Integer(20)
         //System.out.println(list); //[30, 40, 50, 60]
 
         //集合中指定范围抽出一个小集合 subList()
         System.out.println(list.subList(1,4));  //含头不含尾
    }
 }
 /*
 5
 [20, 30, 40, 50, 60]
 [30, 40, 50]
  */

 

List实现类

  • ArrayList [重点]:

    • 数组结构实现,查询快、增删慢

    • JDK1.2版本,运行效率快、线程不安全

  • Vector:

    • 数组结构实现,查询快、增删慢

    • JDK1.0版本,运行效率慢,线程安全

  • LinkedList:

    • 链表结构实现(双向链表),增删快,查询慢

ArrayList

ArrayList的使用:

 package com.jihe.list;
 
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.ListIterator;
 import java.util.Objects;
 
 //ArrayList的使用
 public class Demo03 {
     public static void main(String[] args) {
         //创建集合
         ArrayList arrayList = new ArrayList();
         //创建Animal
         Animal dog = new Animal("dog", "play", 3);
         Animal cat = new Animal("cat", "sleep", 4);
         Animal pig = new Animal("pig", "eat", 6);
         //1. 添加元素
         arrayList.add(dog);
         arrayList.add(cat);
         arrayList.add(pig);
         System.out.println(arrayList.size());
         System.out.println(arrayList);  //[Animal{name='dog', hobby='play', age=3}, Animal{name='cat', hobby='sleep', age=4}, Animal{name='pig', hobby='eat', age=6}]
 
         //2. 删除元素
         //arrayList.remove("dog");
         //arrayList.remove(new Animal("pig","eat",6)); 通过这样创建同样的对象删除是不行的,因为地址不一样,remove是根据equals来
         //删除的,equals是找的地址,我们要想通过new出属性一样的对象来删除,可以在实体类里重写equals方法,写我们判断的规则
         //arrayList.remove(new Animal("pig","eat",6));
         //System.out.println(arrayList);
 
         //3. 遍历元素
         //3.1 使用迭代器
         Iterator iterator = arrayList.iterator();
         while (iterator.hasNext()){
             System.out.println(iterator.next());
        }
 
         //3.2 使用列表迭代器
         ListIterator listIterator = arrayList.listIterator();
         while (listIterator.hasNext()){
             System.out.println(listIterator.next());
        }
 
         //3.3 使用列表迭代器倒序
         while (listIterator.hasPrevious()){
             System.out.println(listIterator.previous());
        }
         //4. 判断
         System.out.println(arrayList.contains(pig));
         //5.查找
         System.out.println(arrayList.indexOf(pig));
    }
 
 
       static class Animal {
             private String name;
             private String hobby;
             private Integer age;
 
             public Animal() {
            }
 
             public Animal(String name, String hobby, Integer age) {
                 this.name = name;
                 this.hobby = hobby;
                 this.age = age;
            }
 
             @Override
             public String toString() {
                 return "Animal{" +
                         "name='" + name + '\'' +
                         ", hobby='" + hobby + '\'' +
                         ", age=" + age +
                         '}';
            }
 
             public String getName() {
                 return name;
            }
 
             public void setName(String name) {
                 this.name = name;
            }
 
             public String getHobby() {
                 return hobby;
            }
 
             public void setHobby(String hobby) {
                 this.hobby = hobby;
            }
 
             public Integer getAge() {
                 return age;
            }
 
             public void setAge(Integer age) {
                 this.age = age;
            }
 
             @Override
             public boolean equals(Object o) {
                 if (this == o) return true;
                 if (o == null || getClass() != o.getClass()) return false;
                 Animal animal = (Animal) o;
                 return Objects.equals(name, animal.name) &&
                         Objects.equals(hobby, animal.hobby) &&
                         Objects.equals(age, animal.age);
            }
        }
 
 
 }
 /*
 3
 [Animal{name='dog', hobby='play', age=3}, Animal{name='cat', hobby='sleep', age=4}, Animal{name='pig', hobby='eat', age=6}]
 Animal{name='dog', hobby='play', age=3}
 Animal{name='cat', hobby='sleep', age=4}
 Animal{name='pig', hobby='eat', age=6}
 Animal{name='dog', hobby='play', age=3}
 Animal{name='cat', hobby='sleep', age=4}
 Animal{name='pig', hobby='eat', age=6}
 Animal{name='pig', hobby='eat', age=6}
 Animal{name='cat', hobby='sleep', age=4}
 Animal{name='dog', hobby='play', age=3}
 true
 2
 */

ArrayList源码分析:

DEFAULT_CAPACITY=10 默认容量

注意:通过分析源码可知,如果没有向集合中添加任何元素时,容量为0。一旦添加任意一个元素之后,容量为10,如果添加到了10,扩容,为1.5倍 (比如第一次扩到15)

elementData 存放元素的数组

size 实际元素个数

add() 添加元素的方法

  public boolean add(E e) {
         ensureCapacityInternal(size + 1);  // Increments modCount!!
         elementData[size++] = e;
         return true;
    }
 
 private static int calculateCapacity(Object[] elementData, int minCapacity) {
         if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
             return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
         return minCapacity;
    }
 
  private void grow(int minCapacity) {
         // overflow-conscious code
         int oldCapacity = elementData.length;
         int newCapacity = oldCapacity + (oldCapacity >> 1);
         if (newCapacity - minCapacity < 0)
             newCapacity = minCapacity;
         if (newCapacity - MAX_ARRAY_SIZE > 0)
             newCapacity = hugeCapacity(minCapacity);
         // minCapacity is usually close to size, so this is a win:
         elementData = Arrays.copyOf(elementData, newCapacity);
    }

 

Vector

Vector类实现了可扩展的对象数组。 像数组一样,它包含可以使用整数索引访问的组件。 但是, Vector的大小可以根据需要增长或缩小,以适应在创建Vector之后添加和删除项目

 package com.jihe.list;
 
 import java.util.Enumeration;
 import java.util.Vector;
 
 //vector
 public class Demo04 {
     public static void main(String[] args) {
         //创建集合
         Vector vector = new Vector();
 
         //增加元素
         vector.add("鼠标");
         vector.add("键盘");
         vector.add("摄像头");
         System.out.println(vector);  //[鼠标, 键盘, 摄像头]
 
         //删除元素
         //vector.remove(0);
         //vector.remove("键盘");
 
         //遍历元素 使用枚举器(vector特有的)
         Enumeration elements = vector.elements();
         while (elements.hasMoreElements()){
             System.out.println(elements.nextElement());
        }
 
         //判断
         System.out.println(vector.contains("鼠标"));
         System.out.println(vector.isEmpty());
    }
 }
 /*
 [鼠标, 键盘, 摄像头]
 鼠标
 键盘
 摄像头
 true
 false
  */

 

LinkedList

 package com.jihe.list;
 
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.ListIterator;
 
 //LinkedList的使用
 public class Demo05 {
     public static void main(String[] args) {
         //创建集合
         LinkedList linkedList = new LinkedList();
         //创建对象
         Face face1 = new Face("black", "long");
         Face face2 = new Face("blue", "small");
 
         //添加元素
         linkedList.add(face1);
         linkedList.add(face2);
         System.out.println(linkedList);  //[Face{eye='black', nose='long'}, Face{eye='blue', nose='small'}]
 
         //删除元素
         //linkedList.remove(0);
         //linkedList.remove(face2);
 
         //遍历集合
         System.out.println("1. for遍历");
         for (int i = 0; i < linkedList.size(); i++) {
             System.out.println(linkedList.get(i));
        }
         System.out.println("2. 增强for");
         for (Object o : linkedList) {
             System.out.println(o);
        }
         System.out.println("3. 迭代器");
         Iterator iterator = linkedList.iterator();
         while (iterator.hasNext()){
             System.out.println(iterator.next());
        }
         System.out.println("4. 列表迭代器正序");
         ListIterator listIterator = linkedList.listIterator();
         while (listIterator.hasNext()){
             System.out.println(listIterator.nextIndex()+":"+listIterator.next());
        }
         System.out.println("5. 列表迭代器倒序");
         while (listIterator.hasPrevious()){
             System.out.println(listIterator.previousIndex()+":"+listIterator.previous());
        }
 
         //判断
         System.out.println(linkedList.contains(face1));
         System.out.println(linkedList.isEmpty());
 
         System.out.println(linkedList.indexOf(face2));  //获取下标
 
    }
 }
 
 class Face{
     private String eye;
     private String nose;
 
     public Face() {
    }
 
     @Override
     public String toString() {
         return "Face{" +
                 "eye='" + eye + '\'' +
                 ", nose='" + nose + '\'' +
                 '}';
    }
 
     public String getEye() {
         return eye;
    }
 
     public void setEye(String eye) {
         this.eye = eye;
    }
 
     public String getNose() {
         return nose;
    }
 
     public void setNose(String nose) {
         this.nose = nose;
    }
 
     public Face(String eye, String nose) {
         this.eye = eye;
         this.nose = nose;
    }
 }
 

LinkedList源码分析:

int size:集合的大小

Node first:链表的头节点

Node last:链表的尾节点

 private void linkFirst(E e) {
         final Node<E> f = first;
         final Node<E> newNode = new Node<>(null, e, f);
         first = newNode;
         if (f == null)
             last = newNode;
         else
             f.prev = newNode;
         size++;
         modCount++;
    }

 

ArrayList和LinkedList的区别:

 

泛型

  • Java泛型时JDK1.5引入的一个新特性,其本质时参数化类型,把类型作为参数传递

  • 常见形式有:泛型类、泛型接口、泛型方法

  • 语法:<T,....> T被称为类型占位符,表示一个引用类型 (E、K、V)都能用

  • 好处:

    • 提高代码的重用性

    • 防止类型转换异常,提高代码的安全性

 

泛型类

泛型类和测试类:

 package com.jihe.generic;
 
 
 //泛型类 语法: 类名<T>       T是类型占位符,表示一种引用类型,如果编写多个使用逗号隔开
 class MyGeneric<T> {
     //使用泛型T
 
     //1. 创建变量
     T t;
 
     //2. 泛型作为方法的参数
     public void show(T t){
         System.out.println(t);
    }
 
     //3. 泛型作为方法的返回值
     public T getT() {
         return t;
    }
 }
 
 public class TestMyGeneric {
     public static void main(String[] args) {
         //使用泛型类创建对象
 
         MyGeneric<String> myGeneric = new MyGeneric<>();
         myGeneric.t="hello";
         myGeneric.show("大家好");
         String t = myGeneric.getT();
         System.out.println(t);
 
         MyGeneric<Integer> myGeneric1 = new MyGeneric<>();
         myGeneric1.t=123;
         myGeneric1.show(456);
         Integer t1 = myGeneric1.getT();
         System.out.println(t1);
    }
 }
 /*
 大家好
 hello
 456
 123
  */

泛型接口

泛型接口和实现类和测试类:

 package com.jihe.generic;
 
 //泛型接口 语法: 接口名<T>   注意:不能泛型静态常量
 interface MyGenericInterface<T>{
     T servlet(T t);
 }
 
 //第一个实现类:已经知道参数类型
 class MyGenericInterfaceImpl01 implements MyGenericInterface<String>{
 
     @Override
     public String servlet(String s) {
         System.out.println(s);
         return s;
    }
 }
 
 //第二个实现类:还不知道参数类型
 class MyGenericInterfaceImpl02<T> implements MyGenericInterface<T>{
 
     @Override
     public T servlet(T t) {
         System.out.println(t);
         return t;
    }
 }
 
 
 public class TestMyGenericInterface {
     public static void main(String[] args) {
         MyGenericInterfaceImpl01 impl01 = new MyGenericInterfaceImpl01();
         impl01.servlet("李四");
 
         MyGenericInterfaceImpl02<Integer> impl02 = new MyGenericInterfaceImpl02<>();
         impl02.servlet(123);
    }
 }
 /*
 李四
 123
 */

泛型方法

泛型方法和测试类:

 package com.jihe.generic;
 
 //泛型方法   语法: <T> 返回值类型(可以为T)
 class MyGenericMethod{
     public <T> void eat(T t){
         System.out.println("我爱吃"+t);
    }
 }
 
 public class TestMyGenericMethod {
     public static void main(String[] args) {
         MyGenericMethod myGenericMethod = new MyGenericMethod();
         //不用定义T的类型 给什么是什么
         myGenericMethod.eat("水果");
         myGenericMethod.eat(123);
         myGenericMethod.eat(true);
         myGenericMethod.eat(3.14);
         myGenericMethod.eat('a');
    }
 }
 /*
 我爱吃水果
 我爱吃123
 我爱吃true
 我爱吃3.14
 我爱吃a
  */

泛型集合

  • 概念:参数化类型、类型安全的集合,强制集合元素的类型必须一致。

  • 特点:

    • 编译时即可检查,而非运行时抛出异常

    • 访问时,不必类型转换(拆箱)

    • 不同泛型之间引用不能相互赋值,泛型不存在多态。

 package com.jihe.generic;
 
 import java.util.ArrayList;
 import java.util.LinkedList;
 import java.util.ListIterator;
 
 public class Test {
     public static void main(String[] args) {
         ArrayList<String> stringArrayList = new ArrayList<>();
         stringArrayList.add("桌子");
         stringArrayList.add("椅子");
         //stringArrayList.add(123); 不是传进泛型指定类型的元素,在编码过程中就会报错
         //stringArrayList.add('a');
         for (String s : stringArrayList) {
             System.out.println(s);
        }
 
         LinkedList<Integer> integerLinkedList = new LinkedList<>();
         integerLinkedList.add(123);
         integerLinkedList.add(456);
         ListIterator<Integer> listIterator = integerLinkedList.listIterator();
         while (listIterator.hasNext()){
             System.out.println(listIterator.nextIndex()+":"+listIterator.next());
        }
    }
 }
 

 

set集合

特点:无序、无下标、元素不可重复

方法:全部继承自Collection中的方法

两个实现类:

  • HashSet

    • 基于HashCode计算元素存放位置

    • 当存入元素的哈希码相同时,会调用equals方法进行确认,如果结果为true,则拒绝后者存入

  • TreeSet

    • 基于排序顺序实现元素不重复

    • 实现了SortedSet接口,对集合元素进行自动排序

    • 元素对象的类型必须实现Comparable接口,指定排序规则

    • 通过CompareTo方法确定是否为重复元素

set接口的使用

 package com.jihe.set;
 
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Set;
 
 /*
 测试set接口的使用
 特点:无序,没有下标 不重复
  */
 public class Demo1 {
     public static void main(String[] args) {
         //创建集合
         Set<String> stringSet = new HashSet<>();
 
         //1. 添加元素
         stringSet.add("香蕉");
         stringSet.add("苹果");
         stringSet.add("榴莲");
         //stringSet.add("榴莲");   不重复
         System.out.println(stringSet.size());
         System.out.println(stringSet);
 
         //2. 删除元素
 //       stringSet.remove("香蕉");
 //       stringSet.clear();
 //       System.out.println(stringSet);
 
         //3. 遍历【重点】 两种方式
 
         //3.1 增强for
         for (String s : stringSet) {
             System.out.println(s);
        }
         //3.2 使用迭代器
         Iterator<String> iterator = stringSet.iterator();
         while (iterator.hasNext()){
             System.out.println(iterator.next());
        }
 
         //4. 判断
         System.out.println(stringSet.contains("香蕉"));
         System.out.println(stringSet.isEmpty());
    }
 }
 /*
 3
 [香蕉, 苹果, 榴莲]
 香蕉
 苹果
 榴莲
 香蕉
 苹果
 榴莲
 true
 false
  */

HashSet

HashSet存储结构: 哈希表(数组+链表+红黑树)

  • 基于HashCode计算元素存放位置

  • 当存入元素的哈希码相同时,会调用equals方法进行确认,如果结果为true,则拒绝后者存入

HashSet的使用1:

 package com.jihe.set;
 
 import java.util.HashSet;
 import java.util.Iterator;
 
 /*
 HashSet的使用1
  */
 public class Demo02 {
     public static void main(String[] args) {
         //创建集合
         HashSet<String> hashSet = new HashSet<>();
 
         //添加数据
         hashSet.add("手机");
         hashSet.add("电脑");
         hashSet.add("平板");
         //hashSet.add("平板");   特点:不重复
         System.out.println(hashSet.size());
         System.out.println(hashSet);
 
         //删除数据
 //       hashSet.remove("平板");
 //       hashSet.clear();
 //       System.out.println(hashSet);
 
         //循环【重点】
         //第一种方式: 增强for
         for (String s : hashSet) {
             System.out.println(s);
        }
         //第二种方式: 迭代器
         Iterator<String> iterator = hashSet.iterator();
         while (iterator.hasNext()){
             System.out.println(iterator.next());
        }
 
         //判断
         System.out.println(hashSet.contains("手机"));
         System.out.println(hashSet.isEmpty());
    }
 }
 /*
 3
 [电脑, 手机, 平板]
 电脑
 手机
 平板
 电脑
 手机
 平板
 true
 false
  */

 

HashSet的使用2: 添加对象,包括HashSet的存储方式

 package com.jihe.set;
 
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.Objects;
 
 class People{
     private String name;
     private Integer age;
 
     public People() {
    }
 
     @Override
     public String toString() {
         return "People{" +
                 "name='" + name + '\'' +
                 ", age=" + age +
                 '}';
    }
 
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
         People people = (People) o;
         return Objects.equals(name, people.name) &&
                 Objects.equals(age, people.age);
    }
 
     @Override
     public int hashCode() {
         return Objects.hash(name, 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 People(String name, Integer age) {
         this.name = name;
         this.age = age;
    }
 }
 
 /*
 HashSet的使用2:
 HashSet存储结构: 哈希表(数组+链表+红黑树)
 HashSet的存储过程:
 ①:根据hashcode计算保存的位置,如果此位置为空,则直接保存,如果不为空执行第二步
 ②:再执行equals方法,根据equals方法,为true则认为是重复,否则,形成链表
  */
 public class Demo03 {
     public static void main(String[] args) {
         //创建集合
         HashSet<People> peopleHashSet = new HashSet<>();
         //创建对象
         People p1 = new People("张三", 20);
         People p2 = new People("李四", 30);
         People p3 = new People("王五", 25);
 
         //添加对象
         peopleHashSet.add(p1);
         peopleHashSet.add(p2);
         peopleHashSet.add(p3);
         //peopleHashSet.add(p3); 重复 不添加
         peopleHashSet.add(new People("李四",30));   //不加处理,添加进去了,因为name、age和p2相同,
         // 要想不添加,需要在people类重写hashcode()和equals方法
         System.out.println(peopleHashSet.size());
         System.out.println(peopleHashSet);
 
         //删除对象
         //peopleHashSet.remove(p1);
         //peopleHashSet.remove(new People("王五",25));
         //System.out.println(peopleHashSet); //[People{name='李四', age=30}]
 
         //遍历
         //第一种方式:增强for
         for (People people : peopleHashSet) {
             System.out.println(people);
        }
         //第二种方式:迭代器
         Iterator<People> iterator = peopleHashSet.iterator();
         while (iterator.hasNext()){
             System.out.println(iterator.next());
        }
 
         //判断
         System.out.println(peopleHashSet.contains(p2));
         System.out.println(peopleHashSet.contains(new People("张三", 20)));
         System.out.println(peopleHashSet.isEmpty());
    }
 }
 /*
 3
 [People{name='张三', age=20}, People{name='王五', age=25}, People{name='李四', age=30}]
 People{name='张三', age=20}
 People{name='王五', age=25}
 People{name='李四', age=30}
 People{name='张三', age=20}
 People{name='王五', age=25}
 People{name='李四', age=30}
 true
 true
 false
  */

 

TreeSet

  • 基于排序顺序实现元素不重复

  • 实现了SortedSet接口,对集合元素进行自动排序

  • 元素对象的类型必须实现Comparable接口,指定排序规则

  • 通过CompareTo方法确定是否为重复元素

TreeSet的使用1:

 package com.jihe.set;
 
 import java.util.Iterator;
 import java.util.TreeSet;
 
 /*
 TreeSet的使用1
 存储结构:红黑树
  */
 public class Demo04 {
     public static void main(String[] args) {
         //创建集合
         TreeSet<String> treeSet = new TreeSet<>();
         //添加元素
         treeSet.add("abc");
         treeSet.add("xyz");
         treeSet.add("hello");
         System.out.println(treeSet.size());
         System.out.println(treeSet);  //[abc, hello, xyz]
         //删除元素
 //       treeSet.remove("abc");
 //       treeSet.clear();
         //遍历
         //第一种方式:增强for
         for (String s : treeSet) {
             System.out.println(s);
        }
         //第二种方式:迭代器
         Iterator<String> iterator = treeSet.iterator();
         while (iterator.hasNext()){
             System.out.println(iterator.next());
        }
         //判断
         System.out.println(treeSet.contains("xyz"));
         System.out.println(treeSet.isEmpty());
    }
 }
 /*
 3
 [abc, hello, xyz]
 abc
 hello
 xyz
 abc
 hello
 xyz
 true
 false
  */

TreeSet的使用2:

 package com.jihe.set;
 
 import java.util.Iterator;
 import java.util.TreeSet;
 
 class Food implements Comparable<Food>{
     private String name;
     private Integer price;
 
     public Food() {
    }
 
     public Food(String name, Integer price) {
         this.name = name;
         this.price = price;
    }
 
     @Override
     public String toString() {
         return "Food{" +
                 "name='" + name + '\'' +
                 ", price=" + price +
                 '}';
    }
 
     public String getName() {
         return name;
    }
 
     public void setName(String name) {
         this.name = name;
    }
 
     public Integer getPrice() {
         return price;
    }
 
     public void setPrice(Integer price) {
         this.price = price;
    }
 
     @Override
     public int compareTo(Food o) {
        int n1=this.getName().compareTo(o.getName());
        int n2=this.price-o.price;
        return n1==0?n2:n1;
    }
 }
 
 /*
 TreeSet的使用2
 存储结构:红黑树
 要求:元素必须要实现Comparable接口,(因为需要我们定义排序的规则)compareTo()方法
  */
 public class Demo05 {
     public static void main(String[] args) {
         //创建集合
         TreeSet<Food> foodTreeSet = new TreeSet<>();
         //创建对象
         Food rice = new Food("rice", 2);
         Food fish = new Food("fish", 10);
         Food soup = new Food("soup", 5);
         Food soup2 = new Food("soup", 3);
         //添加对象
         foodTreeSet.add(rice);
         foodTreeSet.add(fish);
         foodTreeSet.add(soup);
         foodTreeSet.add(soup2);
         System.out.println(foodTreeSet);
 
         //删除对象
         foodTreeSet.remove(soup2);
         System.out.println(foodTreeSet);
 
         //遍历
         //第一种:增强for
         for (Food food : foodTreeSet) {
             System.out.println(food);
        }
         //第二种:迭代器
         Iterator<Food> iterator = foodTreeSet.iterator();
         while (iterator.hasNext()) {
             System.out.println(iterator.next());
        }
 
         //判断
         System.out.println(foodTreeSet.contains(rice));
         System.out.println(foodTreeSet.isEmpty());
    }
 }
 /*
 [Food{name='fish', price=10}, Food{name='rice', price=2}, Food{name='soup', price=3}, Food{name='soup', price=5}]
 [Food{name='fish', price=10}, Food{name='rice', price=2}, Food{name='soup', price=5}]
 Food{name='fish', price=10}
 Food{name='rice', price=2}
 Food{name='soup', price=5}
 Food{name='fish', price=10}
 Food{name='rice', price=2}
 Food{name='soup', price=5}
 true
 false
  */
 
 

小案例:

 package com.jihe.set;
 
 import java.util.Comparator;
 import java.util.TreeSet;
 
 /*
 要求:使用TreeSet集合实现字符串按照长度进行排序
 需要使用Comparator接口实现定制比较
  */
 public class Demo06 {
     public static void main(String[] args) {
         //创建集合,并指定比较规则
         TreeSet<String> treeSet = new TreeSet<>(new Comparator<String>() {
             @Override
             public int compare(String o1, String o2) {
                 int n1=o1.length()-o2.length();
                 int n2=o1.compareTo(o2);
                 return n1==0?n2:n1;
            }
        });
         treeSet.add("123");
         treeSet.add("hello");
         treeSet.add("大家好,我是李四");
         treeSet.add("a");
         treeSet.add("abc");
         System.out.println(treeSet);
    }
 }

 

Map集合

Map集合体系结构图:

 

 

Map父接口

将键映射到值的对象。 地图不能包含重复的键; 每个键可以映射到最多一个值。

特点:存储一对数据(Key-Value),无序、无下标,键不可重复,值可重复。

 

    • Modifier and TypeMethod and Description
      void clear() 从该地图中删除所有的映射(可选操作)。
      default V compute(K key, BiFunction remappingFunction) 尝试计算指定键的映射及其当前映射的值(如果没有当前映射, null )。
      default V computeIfAbsent(K key, Function mappingFunction) 如果指定的键尚未与值相关联(或映射到 null ),则尝试使用给定的映射函数计算其值,并将其输入到此映射中,除非 null
      default V computeIfPresent(K key, BiFunction remappingFunction) 如果指定的密钥的值存在且非空,则尝试计算给定密钥及其当前映射值的新映射。
      boolean containsKey(Object key) 如果此映射包含指定键的映射,则返回 true
      boolean containsValue(Object value) 如果此地图将一个或多个键映射到指定的值,则返回 true
      Set> entrySet() 返回此地图中包含的映射的Set视图。
      boolean equals(Object o) 将指定的对象与此映射进行比较以获得相等性。
      default void forEach(BiConsumer action) 对此映射中的每个条目执行给定的操作,直到所有条目都被处理或操作引发异常。
      V get(Object key) 返回到指定键所映射的值,或 null如果此映射包含该键的映射。
      default V getOrDefault(Object key, V defaultValue) 返回到指定键所映射的值,或 defaultValue如果此映射包含该键的映射。
      int hashCode() 返回此地图的哈希码值。
      boolean isEmpty() 如果此地图不包含键值映射,则返回 true
      Set keySet() 返回此地图中包含的键的Set视图。
      default V merge(K key, V value, BiFunction remappingFunction) 如果指定的键尚未与值相关联或与null相关联,则将其与给定的非空值相关联。
      V put(K key, V value) 将指定的值与该映射中的指定键相关联(可选操作)。
      void putAll(Map m) 将指定地图的所有映射复制到此映射(可选操作)。
      default V putIfAbsent(K key, V value) 如果指定的键尚未与某个值相关联(或映射到 null )将其与给定值相关联并返回 null ,否则返回当前值。
      V remove(Object key) 如果存在(从可选的操作),从该地图中删除一个键的映射。
      default boolean remove(Object key, Object value) 仅当指定的密钥当前映射到指定的值时删除该条目。
      default V replace(K key, V value) 只有当目标映射到某个值时,才能替换指定键的条目。
      default boolean replace(K key, V oldValue, V newValue) 仅当当前映射到指定的值时,才能替换指定键的条目。
      default void replaceAll(BiFunction function) 将每个条目的值替换为对该条目调用给定函数的结果,直到所有条目都被处理或该函数抛出异常。
      int size() 返回此地图中键值映射的数量。
      Collection values() 返回此地图中包含的值的Collection视图。

 

Map接口的使用

 

 package com.jihe.map;
 
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
 
 /*
 Map接口的使用
 特点:①:存储键值对 ②:键不能重复,值可以重复 ③:无序
  */
 public class Demo01 {
     public static void main(String[] args) {
         //创建Map集合
         Map<String, String> map = new HashMap<>();
         //添加元素
         map.put("name","张三");
         map.put("age","18");
         map.put("job","teacher");
         System.out.println(map.size());
         System.out.println(map);
 
         //删除元素
 //       map.remove("age"); //通过key删除
 //       map.remove("job","teacher"); //通过key和value删除
 //       System.out.println(map);
 
         //遍历   两个方法
         //第一种方法: keySet() 可以得到key,然后通过map.get(key),,得到value
         Set<String> keySet = map.keySet();
         for (String s : keySet) {
             System.out.println(s+":"+map.get(s));
        }
         //第二种方法:entrySet() 获得的就是键值对,当然,entrySet()方法也能得单独的value和key
         Set<Map.Entry<String, String>> entrySet = map.entrySet();
         for (Map.Entry<String, String> entry : entrySet) {
             System.out.println(entry);
             System.out.println(entry.getKey());
             System.out.println(entry.getValue());
        }
 
         //判断
         System.out.println(map.containsKey("job"));
         System.out.println(map.containsValue("李四"));
    }
 }
 /*
 3
 {name=张三, job=teacher, age=18}
 name:张三
 job:teacher
 age:18
 name=张三
 name
 张三
 job=teacher
 job
 teacher
 age=18
 age
 18
 true
 false
  */

 

HashMap

JDK1.2版本,线程不安全,运行效率快;允许用null作为key或value

HashMap集合的使用:

 package com.jihe.map;
 
 
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
 
 class Book{
     private String name;
     private Integer price;
 
     public Book() {
    }
 
     public Book(String name, Integer price) {
         this.name = name;
         this.price = price;
    }
 
     public String getName() {
         return name;
    }
 
     public void setName(String name) {
         this.name = name;
    }
 
     public Integer getPrice() {
         return price;
    }
 
     public void setPrice(Integer price) {
         this.price = price;
    }
 
     @Override
     public String toString() {
         return "Book{" +
                 "name='" + name + '\'' +
                 ", price=" + price +
                 '}';
    }
 
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
         Book book = (Book) o;
         return Objects.equals(name, book.name) &&
                 Objects.equals(price, book.price);
    }
 
     @Override
     public int hashCode() {
         return Objects.hash(name, price);
    }
 }
 
 /*
 HashMap集合的使用
 存储结构:哈希表(数组+链表+红黑树)
 默认:使用key的hashcode和equals作为重复的判断   所以要重写hashCode()方法和equals()方法
  */
 public class Demo02 {
     public static void main(String[] args) {
         //创建集合
         HashMap<Book, String> hashMap = new HashMap<>();
         //创建对象
         Book book1 = new Book("西游记", 15);
         Book book2 = new Book("水浒传", 25);
         Book book3 = new Book("红楼梦", 36);
         Book book4 = new Book("三国演义", 23);
 
         //添加
         hashMap.put(book1, "吴承恩");
         hashMap.put(book2, "施耐庵");
         hashMap.put(book3, "曹雪芹");
         hashMap.put(book4, "罗贯中");
         System.out.println(hashMap.size());
         System.out.println(hashMap);
 
         //删除
 //       hashMap.remove(new Book("西游记", 15));
 //       hashMap.remove(book2);
 //       hashMap.clear();
 //       System.out.println(hashMap);
 
         //遍历 两个方法
         //方法一:keySet() 通过keySet()方法得到key,再通过hashMap.get(book)获得value
         Set<Book> books = hashMap.keySet();
         for (Book book : books) {
             System.out.println(book+":"+hashMap.get(book));
        }
         //方法二:entrySet() 直接获得键值对
         Set<Map.Entry<Book, String>> entrySet = hashMap.entrySet();
         for (Map.Entry<Book, String> bookStringEntry : entrySet) {
             System.out.println(bookStringEntry);
        }
 
         //判断
         System.out.println(hashMap.containsKey(book1));
         System.out.println(hashMap.containsValue("吴承恩"));
         System.out.println(hashMap.containsValue("吴承"));
    }
 }
 /*
 4
 {Book{name='红楼梦', price=36}=曹雪芹, Book{name='三国演义', price=23}=罗贯中, Book{name='西游记', price=15}=吴承恩, Book{name='水浒传', price=25}=施耐庵}
 Book{name='红楼梦', price=36}:曹雪芹
 Book{name='三国演义', price=23}:罗贯中
 Book{name='西游记', price=15}:吴承恩
 Book{name='水浒传', price=25}:施耐庵
 Book{name='红楼梦', price=36}=曹雪芹
 Book{name='三国演义', price=23}=罗贯中
 Book{name='西游记', price=15}=吴承恩
 Book{name='水浒传', price=25}=施耐庵
 true
 true
 false
  */

 

通过分析源码对HashMap的总结:

 1. HashMap刚创建时,table是null,为了节省空间,当添加第一个元素时,table容量调整为16
 2. 当元素个数大于阙值(16*0.75=12)时,会进行扩容,扩容后的大小为原来的2倍。目的是减少调整元素的个数
 3. jdk1.8 当每个链表长度大于8,并且数组元素个数大于64时,会调整为红黑树,目的是提高执行效率
 4. jdk1.8 当链表长度小于6时,调整为链表
 5. jdk1.8 之前,链表是头插入,jdk1.8之后,是尾插入

 

TreeMap

实现了SortedMap接口(是Map的子接口),可以对key自动排序

 package com.jihe.map;
 
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
 import java.util.TreeMap;
 
 class Book2 implements Comparable<Book2>{
     private String name;
     private Integer price;
 
     public Book2() {
    }
 
     public Book2(String name, Integer price) {
         this.name = name;
         this.price = price;
    }
 
     public String getName() {
         return name;
    }
 
     public void setName(String name) {
         this.name = name;
    }
 
     public Integer getPrice() {
         return price;
    }
 
     public void setPrice(Integer price) {
         this.price = price;
    }
 
     @Override
     public String toString() {
         return "Book2{" +
                 "name='" + name + '\'' +
                 ", price=" + price +
                 '}';
    }
 
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
         Book2 book2 = (Book2) o;
         return Objects.equals(name, book2.name) &&
                 Objects.equals(price, book2.price);
    }
 
     @Override
     public int hashCode() {
         return Objects.hash(name, price);
    }
 
 
     @Override
     public int compareTo(Book2 o) {
         int n1=this.price-o.price;
         int n2=this.getName().compareTo(o.getName());
         return n1==0?n2:n1;
    }
 }
 
 public class Demo03 {
     public static void main(String[] args) {
         //创建集合
         TreeMap<Book2, String> treeMap = new TreeMap<>();
         //创建对象
         Book2 book1 = new Book2("西游记", 15);
         Book2 book2 = new Book2("水浒传", 25);
         Book2 book3 = new Book2("红楼梦", 36);
         Book2 book4 = new Book2("三国演义", 23);
 
         //添加
         treeMap.put(book1,"吴承恩");
         treeMap.put(book2,"施耐庵");
         treeMap.put(book3,"曹雪芹");
         treeMap.put(book4,"罗贯中");
         //treeMap.put(book4,"罗贯中");
         System.out.println(treeMap);  //java.lang.ClassCastException
         // 直接输出报错,因为是二叉树,我们需要定义排序的规则,在Book2类中实现Comparable接口
 
         //删除
 //       treeMap.remove(book1);
 //       System.out.println(treeMap);
 
         //遍历
         //第一种方法:keySet()
         Set<Book2> book2s = treeMap.keySet();
         for (Book2 book21 : book2s) {
             System.out.println(book21+":"+treeMap.get(book21));
        }
         //第二种方法:entrySet()
         Set<Map.Entry<Book2, String>> entries = treeMap.entrySet();
         for (Map.Entry<Book2, String> entry : entries) {
             System.out.println(entry);
        }
 
         //判断
         System.out.println(treeMap.containsKey(book2));
         System.out.println(treeMap.containsValue("小小怪"));
    }
 }
 /*
 {Book2{name='西游记', price=15}=吴承恩, Book2{name='三国演义', price=23}=罗贯中, Book2{name='水浒传', price=25}=施耐庵, Book2{name='红楼梦', price=36}=曹雪芹}
 Book2{name='西游记', price=15}:吴承恩
 Book2{name='三国演义', price=23}:罗贯中
 Book2{name='水浒传', price=25}:施耐庵
 Book2{name='红楼梦', price=36}:曹雪芹
 Book2{name='西游记', price=15}=吴承恩
 Book2{name='三国演义', price=23}=罗贯中
 Book2{name='水浒传', price=25}=施耐庵
 Book2{name='红楼梦', price=36}=曹雪芹
 true
 false
  */

 

Colletions工具类

概念:集合工具类,定义除了存取以外的集合常用方法

具体方法实现看代码

 package com.jihe;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
 /*
 Collections工具类的使用
  */
 public class Collections {
     public static void main(String[] args) {
         ArrayList<Integer> list = new ArrayList<>();
         list.add(10);
         list.add(8);
         list.add(190);
         list.add(0);
         list.add(-1);
         list.add(-10);
         list.add(100);
         System.out.println(list);
         //排序 sort()
         java.util.Collections.sort(list);
         System.out.println("排序后:"+list);
 
         //二分查找 binarySearch()
         int i = java.util.Collections.binarySearch(list, 0);
         System.out.println("二分查找,得的是下标:"+i);
 
         //反转 reverse()
         java.util.Collections.reverse(list);
         System.out.println("反转后:"+list);
 
         //顺序打乱   shuffle()
         java.util.Collections.shuffle(list);
         System.out.println("顺序打乱后:"+list);
 
         //list转成数组
         Integer[] array = list.toArray(new Integer[0]);
         System.out.println("list转成数组,长度:"+array.length);
         System.out.println("list转成数组:"+Arrays.toString(array));
 
         //数组转成集合
         String[] names={"张三","李四","王五"};
         //注意:转过来的集合是一个受限集合,不能添加和删除
         List<String> asList = Arrays.asList(names);
         System.out.println("数组names转成集合:"+asList);
    }
 }
 /*
 [10, 8, 190, 0, -1, -10, 100]
 排序后:[-10, -1, 0, 8, 10, 100, 190]
 二分查找,得的是下标:2
 反转后:[190, 100, 10, 8, 0, -1, -10]
 顺序打乱后:[100, 0, -1, 190, -10, 10, 8]
 list转成数组,长度:7
 list转成数组:[100, 0, -1, 190, -10, 10, 8]
 数组names转成集合:[张三, 李四, 王五]
  */

 

总结:

  • 集合的概念:

    • 对象的容器,和数组类似,定义了对多个对象进行操作的常用方法。

  • List集合:

    • 有序、有下标、元素可以重复 (ArrayList、LinkedList、Vector)

  • Set集合:

    • 无序、无下标、元素不可重复 (HashSet、TreeSet)

  • Map集合:

    • 存储一对数据,无序、无下标,键不可重复,值可重复。 (HashMap、TreeMap、HashTable)

  • Collections:

    • 集合工具类,定义除了存取以外的集合常用方法。

    •  

 

 

 

 

posted @ 2022-05-02 19:30  超、自律即自由  阅读(14)  评论(0编辑  收藏  举报