Java集合基础

集合基础

此文档是在预习学习过程中整理汇总

提示：关于这些比较多的东西，记不下来一定要查API

Collection

1. Collection集合概述

   • 是单列集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素
   • JDK不提供此接口的任何直接实现，它提供更具体的子接口（Set和List）实现

2. 创建Collection集合的对象

   • 多态的方式
   • 具体的实现类ArrayList（Collection的子接口的实现类）

3. Collection集合常用方法

   方法名	说明
   boolean add(E e)	添加元素
   boolean remove(Object o)	从集合中移除指定元素
   void clear()	清空集合中的元素
   boolean contains(Object o)	判断集合中是否存在指定元素
   boolean isEmpty()	判断集合是否为空
   int size()	集合的长度，也就是集合中元素的个数

4. Collection集合的遍历

   Iterator：迭代器，集合的专用遍历方式

   • Iterator< E > Iterator(): 返回此集合中元素的迭代器，通过集合的Iterator()方法得到。
   • 迭代器是通过集合的Iterator()方法得到的，所以我们说它是依赖于集合而存在的。

   Iterator中的常用方法

   • E next()：返回迭代中的下一个元素

   • boolean hasNext()：如果迭代具有更多元素，则返回true。

   import java.util.ArrayList;
   import java.util.Collection;
   import java.util.Iterator;
   public class TestDemo {
       public static void main(String[] args) {
           Collection<String> c =new ArrayList<String>();
           c.add("hello");
           c.add("world");
           c.add("java");
           Iterator<String> it = c.iterator();
           while(it.hasNext()){
               System.out.println(it.next());
           }
       }
   }
   

List

单列可重复 , List是接口

（常用）具体实现类：ArrayList、LinkedList

List的特点是由于有下标造成的

1. List集合概述

   • 有序集合（也称为序列），用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素，并搜索列表中的元素
   • 与Set集合不同，列表通常允许重复的元素

2. List集合的特点

   • 有序：存储和取出的元素顺序一致
   • 可重复：存储的元素可以重复

3. List集合特有方法

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

4. ListIterator

   ListIterator：列表迭代器

   • 通过List集合的listIterator()方法得到，所以说它是List集合特有的迭代器
   • 用于允许程序员沿任一方向遍历列表的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置

   ListIterator中的常用方法

   方法名	说明
   E next()	返回迭代中的下一个元素
   boolean hasNext()	如果迭代具有更多元素，则返回true
   E previous()	返回列表中的上一个元素
   boolean hasPrevious()	如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回true
   void add(E e)	将指定的元素插入列表

5. List集合子类特点

   • ArrayList ：底层数据结构是数组，查询快，增删慢
   • LinkedList ： 底层数据结构是链表，查询慢，增删快。

6. LinkedList集合的特有功能

   方法名	说明
   public void addFirst(E e)	在该列表开头插入指定的元素
   public void addLast(E e)	将指定的元素追加到此列表的末尾
   public E getFirst()	返回此列表中的第一个元素
   public E getLast()	返回此列表中的最后一个元素
   public E removeFirst()	从此列表中删除并返回第一个元素
   public E removeLast()	从此列表在删除并返回最后一个元素

Set

单列不可重复， Set也是接口

​ Set集合没有特别的方法，所有方法都来自Collection。且Set没有索引

​ 重点是保证如何能使其不重复。

（常用）具体实现类：HashSet、 TreeSet

1. HashSet：

   对集合的迭代顺序不做任何保证（存入是依据hash值+散列算法）

   底层数据结构是哈希表

   没有带索引的方法，所以不能使用普通for循环遍历

2. LinkedHashSet集合概述和特点

   • 哈希表和链表实现的Set接口，具有可预测的迭代次序
   • 由链表保证元素有序
   • 有哈希表保证元素唯一

3. TreeSet集合概述和特点

   • 元素有序，这里的顺序不是指存储和取出的顺序，而是按照一定的规则进行排序，具体排序方式取决于构造方法
     • TreeSet() : 根据其元素的自然排序进行排序，由小到大
     • TreeSet(Comparator comparator) : 根据指定的比较器进行排序
   • 没有索引的方法
   • 不包含重复元素

4. 自然排序Comparable的使用

   • 用TreeSet集合储存自定义对象，无参构造方法使用的是自然排序对元素进行排序的
   • 自然排序，就是让元素所属的类实现Comparable接口，重写compareTo（T o）方法
   • 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

   public class Student implements Comparable<Student>{
       private String name;
       private int age;
       public Student(){
       }
       public Student(String name,int age){
           this.name = name;
           this.age = age;
       }
       //get/set方法未补充
       @Override
   	public int compareTo(Student s){
           int num = this.age - s.age;
           int num2 = num==0?this.name.compareTo(s.name):num;
           return num2;
       }
   }
   
   public class Demo{
       public static void main(String[] args){
           TreeSet<Student> ts = new TreeSet<Student>();
           
           Student s1 = new Student("xiaolan",18);
           Student s2 = new Student("kenan",6);
           Student s3 = new Student("gongtengxingyi",19);
           Student s4 = new Student("maolilan",18);
           ts.add(s1);
           ts.add(s2);
           ts.add(s3);
           ts.add(s4);
           for(Student s:ts){
               System.out.println(s.getName() + "," +s.getAge());
           }
       }
   }
   

5. 比较器排序Comparator的使用

   • 用TreeSet集合储存自定义对象，带参构造方法使用的是比较器排序对元素进行排序的
   • 比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare（T o1，T o2）方法
   • 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写

   public class Student{
       private String name;
       private int age;
       public Student(){
       }
       public Student(String name,int age){
           this.name = name;
           this.age = age;
       }
       //get/set方法未补充
   }
   
   public class Demo{
       public static void main(String[] args){
           TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>(){
               @Override
               public int compare(Student s1,Student s2){
                   int num = s1.getAge() - s2.getAge();
                   int num2 = num==0?s1.getName().compareTo(s2.getName()):num;
                   return num2;
               }
           });
           
           Student s1 = new Student("xiaolan",18);
           Student s2 = new Student("kenan",6);
           Student s3 = new Student("gongtengxingyi",19);
           Student s4 = new Student("maolilan",18);
           ts.add(s1);
           ts.add(s2);
           ts.add(s3);
           ts.add(s4);
           for(Student s:ts){
               System.out.println(s.getName() + "," +s.getAge());
           }
       }
   }
   

泛型

1. 泛型概述

   • 泛型是JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型，它的本质是参数化类型，也就是说操作的数据类型被指定为一个参数。

   • 参数化类型就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型

   • 这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口

2. 泛型定义格式

   • <类型> : 指定一种类型的格式。这里的类型可以看成形参

   • <类型1， 类型2> : 指定多种类型的格式，

   • 将来具体调用时给定的类型可以看成实参，并且实参的类型只能是引用数据类型。也就是说用int不行，必须用Integer（int对应的包装类）

3. 泛型的好处

   • 把运行时期的问题提前到了编译期

   • 避免的强制类型转换

4. 泛型类

   • 格式：修饰符 class 类名<类型>{ }

   • 范例：public class Generic< T >{ }

     此处T可以随意写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。

5. 泛型方法

   • public < T > void show（T t）{ }

6. 泛型接口

   • 格式：修饰符 interface 类名<类型>{ }
   • 范例：public interface Generic< T >{ }

7. 类型通配符

   为了表示各种泛型List的父类，可以使用类型通配符（我没搞懂这玩意实际运用中有什么用

   • 类型通配符： <?>
   • List<?> : 表示元素类型未知的List，它的元素可以匹配任何的类型
   • 这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中

   如果不希望List< ? >是任何泛型List的父类，只希望它代表某一类泛型list的父类，可以使用类型通配符的上限

   • 类型通配符上限：< ?extends 类型 >
   • List< ?extends Number >：表示类型是Number或其子类型
   • 类型通配符下限：< ?super 类型 >
   • List< ?super Number >：表示类型是Number或其父类型

Map

双列集合，是接口

1. Map集合概述

   • Interface Map< K, V > K: 键的类型 V:值的类型
   • 将键映射到值的对象；不能包含重复的键；每个键可以映射最多一个值

2. 创建Map集合的对象

   • 多态的方式
   • （常用）具体实现类：HashMap

3. Map集合的基本功能

   方法名	说明
   V put(K key, V value)	添加元素
   V remove(Object key)	根据键删除键值对元素
   void clear()	移除所有的键值对元素
   boolean containsKey(Object key)	判断集合是否包含指定的键
   boolean containsValue(Object value)	判断集合是否包含指定的值
   boolean isEmpty()	判断集合是否为空
   int size()	集合的长度，也就是集合中键值对的个数

4. Map集合的获取功能

   方法名	说明
   V get(Object key)	根据键获取值
   Set< k > keySet()	获取所有键的集合
   Collection< V > values()	获取所有值的集合
   Set< Map.Entry< K, V> > entrySet()	获取所有键值对对象的集合

5. Map遍历的两种思路

   //初始化数据
   Map<String,String> map = new HashMap<String,String>();
   
   map.put("001","赵敏");
   map.put("002","黄蓉");
   map.put("003","小龙女");
   

   //方式1
   //获取所有键的集合
   Set<String> keySet = map.keySet();
   //遍历键集合，输出
   for (String key:keySet){
       String value = map.get(key);
       System.out.println(key+"--"+value);
   }
   

   //方式2
   //获取所有键值对对象的集合
   Set<Map.Entry<String, String>> entrySet = map.entrySet();
   //遍历键值对对象的集合，得到每个键值对对象
   for (Map.Entry<String,String> ms:entrySet){
       String key = ms.getKey();
       String value = ms.getValue();
       System.out.println(key+"--"+value);
   }
   

   //结果
   //001--赵敏
   //002--黄蓉
   //003--小龙女
   

Collections

C0llections类概述

• ​ 是针对集合操作的工具类

Collections类的常用方法

方法名	说明
public static < T extends Comparable< ?super T > > void sort(List< T > list)	将指定的列表按升序排序
public static void reverse(List< ? > list)	反转列表中元素的顺序
public static void shuffle(List< ? > list)	使用默认的随机源随机排列指定列表

注：预习资源来源是b站黑马程序员的视频

汇总不易，看更多内容记得关注