Java基础之常见集合 && api && 详细示例代码

集合

1 . Collection接口

Collection接口是Java单列集合的根接口，它定义了各种具体单列集合的共性 ， 其它大多数单列集合直接或间接继承该接口

定义 :

public interface Collection<E> extends Iterable<E>{
    // Operations
}

一般用得少，基本上都是直接使用其子接口,如 : List , Set , Queue , SortedSet ;

其中

• List : 有序 ， 可重复 ， 有索引

• Set : 无序 ，不重复 ， 无索引

该接口的常用方法 :

• boolean add(Object o) : 向当前集合中添加一个元素

• boolean addAll(Collection c) : 将c中所有元素添加到当前集合

• void clear() : 删除当前集合得全部元素 ;

• boolean remove(Object o) : 删除指定元素 ;

• boolean removeAll(Collection c) : 删除全部元素 ;

• bool isEmpty() : 判断当前集合是否为空

• boolean contains(Object o) : 判断是否包含元素o;

• boolean containsAll(Collection c) : 判断是否包含集合c中全部元素

• Iterator itreator() : 返回当前集合得迭代器 , 用于遍历集合中的元素；

• int size() : 获取集合大小;

示例 :

package com.itheima.d1_collection;
​
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
​
/**
   目标：明确Collection集合体系的特点
 */
​
public class collectionDemo1 {
    public static void main(String[] args) {
        //有序 可重复 有索引
     Collection list = new ArrayList();
     list.add("java");
     list.add("java");
     list.add("Mybatis");
     list.add(23);
     list.add(23);
     list.add(false);
     list.add(false);
     System.out.println(list);
     System.out.println("-------------------");
​
     //无序 不重复 无索引
    Collection list1 = new HashSet();
    list1.add("java");
    list1.add("java");
    list1.add("Mybatis");
    list1.add(23);
    list1.add(23);
    list1.add(false);
    list1.add(false);
​
    System.out.println(list1);
    System.out.println("-----------------------------------");
    Collection<String> list2=new ArrayList<String>();
    list2.add("java");
    // list2.add(23);(报错)
    list2.add("黑马");
​
    //集合和泛型只支持引用数据类型，不支持基本类型
    Collection<Integer> list3 = new ArrayList<Integer>();
    list3.add(23);
    }
}

常用API :

package d2_collection_api;
​
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Objects;
​
public class CollectionDemo2 {
    public static void main(String[] args) {
​
        //Hashset:添加的元素是无序的，不重复，无索引
        Collection<String> list=new ArrayList<>();
        //1.添加元素，添加成功返回true
        list.add("java");
        list.add("html");
        list.add("java");
        list.add("Java");
        list.add("mysql");
        System.out.println(list.add("html"));
        System.out.println(list);
​
        //2.清空集合中的元素
        // list.clear();
​
        //3.判断集合是否为空，为空返回true
        System.out.println(list.isEmpty());
​
        //4.获取集合的大小
        System.out.println(list.size());
​
        //5.判断集合中是否包含这个元素
        System.out.println(list.contains("java"));
​
        //6.删除某个元素，如果有多个重复元素，那就删除前一个
        System.out.println(list.remove("java"));
        System.out.println(list);
​
        //7.吧集合转换成数组[java,独孤求败，html,Mybatis]
        Object[] arrs =list.toArray();
        System.out.println(Arrays.toString(arrs));
​
        System.out.println("---------------拓展--------------");
​
          Collection<String> c1=new ArrayList<String>();
          c1.add("java1");
          c1.add("java2");
          Collection<String> c2 = new ArrayList<String>();
          c2.add("java3");
          c2.add("java4");
          //addAll把c2集合中的元素全部倒入到c1里面去
          c1.addAll(c2);
        System.out.println(c1);
        System.out.println(c2);
​
    }
}

2 . List接口

2 . 1 List接口简介

• List继承自Collection接口

• 特点 : 有序(存入顺序与取出顺序相同) ，可重复 ， 线性 , 有索引 ;

特有API (Collection的全有) :

• void add(int idx , Object o) : 将元素o插入到idx处 ;

• addAll(int idx , Collection c) : 将集合c的所有元素插入到List集合的idx处 ;

• get(idx) : 获取下标为idx的元素 ;

• remove(idx) : 删除并返回idx处的元素

• set(idx,o) : 设置idx处元素为o;

• int index(o) : 返回o第一次出现的下标

• int lastIndexOf( o ) : 返回o最后一次出现的下标

• List subList(int l , int r) : 截取[l,r)并返回

示例 :

package d5_collection_list;
​
import java.util.ArrayList;
import java.util.List;
​
public class ListDemo01 {
    public static void main(String[] args) {
        //1.创建一个ArrayList集合对象，
        //2.List:有序，可重复，有索引的
        List<String> list = new ArrayList<>();
        list.add("java");
        list.add("java");
​
        list.add("MySQL");
        list.add("MySQl");
​
        //2.在某个索引位置插入元素
        list.add(0,"HTML");
​
        System.out.println(list);
​
        //3.根据索引删除元素,返回被删除元素
        System.out.println(list.remove(2));
        System.out.println(list);
​
        //4.根据索引获取元素：public E get(int index):返回集合中指定位置的元素
        System.out.println(list.get(2));
​
        //5.修改索引位置的元素：public E set(int index,E element)
     //返回修改前的数据
        System.out.println(list.set(1, "cpp"));
        System.out.println(list);
        //[HTML, cpp, MySQL, MySQl]
        int idx = list.indexOf("cpp") ;// 返回第一次出现的索引
        System.out.println(idx);
        int idx1 = list.lastIndexOf("MySQl") ;
        System.out.println(idx1);
​
        // 6 . 截取
        List<String> lt = list.subList(1,4) ; // 左闭右开
        System.out.println(lt) ;
    }
}

2 . 2 ArrayList接口

特点 : 长度可变 ， 继承自List , 也有索引 查询元素很快，增删效率较低 ;

ArrarList集合底层原理： 1 . ArrayList底层是基于数组实现的：根据索引定位元素快，增删要做元素的移位操作 2 . 第一次创建集合并添加第一个元素的时候，在底层创建一个默认长度为10的数组 示例 :

package d5_collection_list;
​
import java.util.ArrayList;
​
public class ArrayList1 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList() ;
        // 添加元素
        list.add("zs") ;
        list.add("ls") ;
        list.add("ww") ;
        list.add("zl") ;
        // 打印集合
        System.out.println(list);
        // 获取集合中元素的个数
        int sz = list.size() ;
        System.out.println(sz) ;
        // 获取并打印指定元素的2位置
        System.out.println(list.get(2));
        //删除索引为3的元素
        list.remove(3);
        System.out.println(list);
        // 元素替换
        list.set(1 , "yss") ;
        System.out.println(list);
    }
}

2 . 3 List集合的遍历方法

4种方法 :

• for循环

• 迭代器

• foreach ：不能修改集合中的值

• lambda表达式

代码示例 :

package d5_collection_list;
​
/**
 List集合的遍历方法
 */
​
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
​
public class ListDemo03 {
    public static void main(String[] args) {
        List<String> lists = new ArrayList<>();
        lists.add("java1");
        lists.add("java2");
        lists.add("java3");
        System.out.println("-----------------------");
​
        /** 1.for循环 */
        for(int i=0;i<lists.size();i++){
            String ele=lists.get(i);
            System.out.println(ele);
        }
        /** (2).迭代器 */
        System.out.println("-------------------------");
        Iterator<String> it = lists.iterator();
        while(it.hasNext()){
            String ele=it.next();
            System.out.println(ele);
        }
​
        /** (
         * 3).foreach */
        System.out.println("--------------------");
        for(String ele:lists){
            System.out.println(ele);
        }
        /** (4)JDK 1.8开始之后的lambda表达式 */
        System.out.println("-----------------------------");
        lists.forEach(s->{
            System.out.println(s);
        });
    }
}

2 . 4 LinkedList

• 底层维护了一个双向链表 ， 链表中的每一个元素都用引用的方式记录它的前一个元素和后一个元素；

LinkedList特有的方法 :

• void add(int index , E element) : 在idx处插入元素element

• void addFirst( o )

• void addLast(( o )

• Object getFirst()

• Object getLast()

• removeFirst() : 删除第一个并返回

• removeLast() : 删除最后一个并返回

• boolean offer( o ) : 将o添加到集合末尾

• boolean offerFirst( o ) : 添加到开头

• boolean offerLast( o ) : 添加到末尾

• Object peekFirst() : 获取第一个元素

• Object peekLast() : 获取最后一个元素

• Object pollFirst() : 移除并返回第一个

• Object pollLast() : 移除并返回最后一个

• void push( o ) : 将o添加到开头

• Object pop() : 删除第一个并返回

示例(用LinkedList实现栈和队列) :

package d5_collection_list;
​
import java.util.LinkedList;
​
/**
 ArrarList集合底层原理：
 1.ArrayList底层是基于数组实现的：根据索引定位元素快，增删要做元素的移位操作
 2.第一次创建集合并添加第一个元素的时候，在底层创建一个默认长度为10的数组
 LinkedList的底层是用双链表来实现的
 */
​
public class ListDemo02 {
    public static void main(String[] args) {
        //1.LinkedList可以完成队列结构，和栈结构（双链表）
        //栈
        LinkedList<String> stack = new LinkedList<>();
        //压栈，入栈
        stack.push("java1");
        stack.push("java2");
        stack.addFirst("java3");
        stack.addFirst("java4");
        System.out.println(stack);
    //出栈，弹栈
       // System.out.println(stack.getFirst());
        System.out.println(stack.pop());
        System.out.println(stack.removeFirst());
        System.out.println(stack.removeFirst());
        System.out.println(stack);
​
        System.out.println("===========================================");
​
        //队列
        LinkedList<String> queue = new LinkedList<>();
        //1.入队
        queue.offerLast("c1");
        queue.addLast("c2");
        queue.addLast("c3");
        queue.addLast("c4");
        System.out.println(queue);
        //2.出队
        System.out.println(queue.removeFirst());
        System.out.println(queue.removeFirst());
        System.out.println(queue.removeFirst());
        System.out.println(queue);
    }
​
}

​

3 . Set接口

3 . 1 set接口

特点 : 无序且不重复 ;

Set常见的三个实现类 :

• HashSet : 根据hash值来确定元素的存储位置,具有良好的存储和查找性能

• LinkedHashSet : 链表+哈希表

• TreeSet : 二叉树 , 可以对元素进行排序

示例 :

package com.itheima.d1_set;
​
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
​
public class SetDemo1 {
    public static void main(String[] args) {
        // 看看set系列集合的特点，HashSet,LinkedHashSet,TreeSet
        //无序不重复，无索引
        Set<String> sets = new HashSet<>(); //一行经典代码,多态
        sets.add("Mysql");
        sets.add("Mysql");
        sets.add("java");
        sets.add("java");
        sets.add("html");
        sets.add("html");
        sets.add("springboot");
        sets.add("springboot");
        System.out.println(sets);
​
        //LinkedHashSet 有序 不重复，无索引
        Set<String> sets1 = new LinkedHashSet<>(); //一行经典代码,多态
        sets1.add("Mysql");
        sets1.add("Mysql");
        sets1.add("java");
        sets1.add("java");
        sets1.add("html");
        sets1.add("html");
        sets1.add("springboot");
        sets1.add("springboot");
        System.out.println(sets1);
    }
}

​

3 . 2 HashSet

HashSet存储的元素是不可重复的；当向HashSet中添加一个元素时 ， 首先会调用hashCode()方法确定元素的存储位置 ， 然后再调用equals()方法确保该位置没有重复元素 ， Set接口和List接口存取元素的方式是一样的 吗但是Set集合中的元素是无序的 ;

调用hashCode()方法示例 :

public class SetDemo2 {
    public static void main(String[] args) {
        //目标：学会获取对象的哈希值，并确认一下
        String name = "itheima";
        System.out.println(name.hashCode());
        System.out.println(name.hashCode());
​
        String name1 = "itheima1";
        System.out.println(name1.hashCode());
        System.out.println(name1.hashCode());
​
    }
}

hashSet使用示例 :

public class hashSet {
    public static void main(String[] args) {
        HashSet ht = new HashSet() ;
        ht.add("张三") ;
        ht.add("李四") ;
        ht.add("王五") ;
        ht.add("赵六") ;
        Iterator it = ht.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

3 . 3 LinkedHashSet

底层采用双向链表来维护内部元素之间的关系；

LinkedHashSet set = new LinkedHashSet() ;

3 . 4 TreeSet

内部采用二叉树存储元素 ， 保证没有重复元素，并且能够对元素进行排序 (二叉排序树);

TreeSet特有的方法 :

• Object first() : 返回集合的第一个元素

• Object last() : 返回集合的最后一个元素

• Object lower( o ) : 返回集合中小于给定元素的最大元素，没有则返回null ;

• Object floor( o ) : 返回<=o的最大元素 ， 没有返回null ;

• Object higher( o ) : >o 的最小元素,....

• Object ceiling( o ) : >= o 的最小元素

• Object pollFirst() : 移除并返回集合的第一个元素

• Object pollLast() : 移除并返回最后一个元素。

示例 :

Apple类 :

package com.itheima.d1_set;
​
public class Apple implements Comparable<Apple>{
    private String name;
    private String color;
    private double price;
    private int weight;
​
    public Apple() {
    }
​
    public Apple(String name, String color, double price, int weight) {
        this.name = name;
        this.color = color;
        this.price = price;
        this.weight = weight;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public String getColor() {
        return color;
    }
​
    public void setColor(String color) {
        this.color = color;
    }
​
    public double getPrice() {
        return price;
    }
​
    public void setPrice(double price) {
        this.price = price;
    }
​
    public int getWeight() {
        return weight;
    }
​
    public void setWeight(int weight) {
        this.weight = weight;
    }
​
    @Override
    public String toString() {
        return "Apple{" +
                "name='" + name + '\'' +
                ", color='" + color + '\'' +
                ", price=" + price +
                ", weight=" + weight +
                '}';
    }
​
    /**
       方式一：类自定义比较规则
     o1.compareTo(o2)
     * @param o the object to be compared.
     * @return
     */
    @Override
    public int compareTo(Apple o) {
       //按照重量比较
       // return this.weight-o.weight >=0 ?1 : -1;  //保留
        return this.weight-o.weight; //去掉重量重复元素
    }
}

​

test :

package com.itheima.d1_set;
​
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;
/**
  目标： 观察TreeSet对于有值特性的数据如何排序
       学会对自定义类型对象进行指定规则排序
 */
public class SetDemo5 {
    public static void main(String[] args) {
        Set<Integer> sets = new TreeSet<Integer>();//不重复 无索引 可排序
        sets.add(23);
        sets.add(24);
        sets.add(12);
        sets.add(8);
        System.out.println(sets);
​
        Set<String> sets1 = new TreeSet<>();//不重复 无索引 可排序
        sets1.add("d");
        sets1.add("c");
        sets1.add("b");
        sets1.add("a");
        System.out.println(sets1);
​
        System.out.println("------------------------------------");
        //方式二:集合自带比较器对象进行规则制定
​
        Set<Apple> apples = new TreeSet<>(new Comparator<Apple>() {
            @Override
            public int compare(Apple o1, Apple o2) {
                return o1.getWeight()- o2.getWeight(); //升序
           //   return Double.compare(o2.getPrice()-o1.getPrice());
            }
        });
        apples.add(new Apple("hongfushi","red",9.9,500));
        apples.add(new Apple("lufushi","lu",15.9,300));
        apples.add(new Apple("yellowfushi","yellow",29.9,400));
        apples.add(new Apple("blackfushi","black",9.8,500));
       System.out.println(apples);
​
    }
}
​

TreeSet对于自定义类型可以采用的两种排序规则 :

1.自然排序 :

类必须实现Comparable接口 ， 并重写CompareTo()方法 ：

/**
   方式一：类自定义比较规则
 o1.compareTo(o2)
 * @param o the object to be compared.
 * @return
 */
@Override
public int compareTo(Apple o) {
   //按照重量比较
   // return this.weight-o.weight >=0 ?1 : -1;  //保留
    return this.weight-o.weight; //去掉重量重复元素
}

2.自定义排序:

Set<Apple> apples = new TreeSet<>(new Comparator<Apple>() {
    @Override
    public int compare(Apple o1, Apple o2) {
        return o1.getWeight()- o2.getWeight(); //升序
   //   return Double.compare(o2.getPrice()-o1.getPrice());
    }
});

4 . Map接口

4 . 1 Map

Map接口是一个双列集合 , 每个元素包含[key,val] ; 键值对 , 称为映射 ， Map中的键不允许重复 ；

常用方法 :

• void put(Object key , Object val) : 存入集合

• Object get(Object key) : 获取key对应的值,不存在则返回null ;

• void clear() : 清空Map， 移除所有的键值对集合

• V renove(Object key) : 根据key删除对应的值，返回被删除的值 ;

• int size() : 返回Map大小

• boolean containsKey(Object Key) : 查看是否包含key的映射关系

• boolean containsValue(Object value) : 查看是否包含key的映射关系

• Set keySet() : 返回此映射中包含键的Set集合

• Collection<V> values() : 返回此映射中包含的值的Collection集合

• Set<Map,Entry<K,V>> entrySet() : 返回此映射中包含的映射关系的集合 ;

示例 :

package com.itheima.d6_map_api;
​
import java.util.*;
import java.util.Map.Entry;
​
public class MapDemo {
    public static void main(String[] args) {
        Map<String, Integer> maps = new HashMap<>();
    //   1.添加
          maps.put("张飞",18888);
          maps.put("小乔",2888) ;
​
        //2.清空 maps.clear();
​
      // maps.isEmpty();
​
        System.out.println(maps.get("张飞"));
​
        boolean tag =  maps.containsKey("张飞");
        System.out.println(tag);
        maps.remove("张飞");
        boolean tag2 =  maps.containsKey("张飞");
        System.out.println(tag2);
​
        maps.put("张飞",18888);
       boolean tag3 =  maps.containsValue(18888);
        System.out.println(tag3);
​
       // 获取全部键的集合  public Set<K> keySet()
       Set<String> keys = maps.keySet();
        System.out.println(keys);
​
​
        //获取全部值的集合
        Collection<Integer> values = maps.values();
        System.out.println(values);
​
        //集合的大小：
      System.out.println(maps.size());
​
        Set<Map.Entry<String,Integer>> st= maps.entrySet();
        System.out.println(st);
​
        //合并其他map集合
       // map1.putAll(map2);
​
​
​
    }
​
}

​

4 . 2 HashMap

• 键不重复且元素无序

• 使用put遇到相同的key,那么value实现覆盖 ;

遍历方式 :

• foreach :

       maps.forEach((k,v)->{
           System.out.println(k+"===>"+v);
       });

• 先转set :

  ​
  

          Set<Map.Entry<String, Integer>> entries = maps.entrySet();
          for(Map.Entry<String, Integer> entry : entries){
              String key = entry.getKey();
              int value = entry.getValue();
              System.out.println(key +"====>"+value);
          }

• 先用Set存下所有的key,再遍历set,得到key,再得到val :

   //1.键找值
          Set<String> keys = maps.keySet();
          //2. 第二步：遍历每个键，根据键找值
          for(String key:keys){
              int value = maps.get(key);
              System.out.println(key+ "===>"+value);
          }

4.3 LinkedHashMap

集合中的遍历顺序和存入顺序一致;

使用双向链表维护内部元素之间的关系 : 示例 :

public class linkedHashmap {
    public static void main(String[] args) {
        Map map = new LinkedHashMap() ;
        map.put("3","李四") ;
        map.put("2","张三") ;
        Set keyset = map.keySet() ;
        Iterator it = keyset.iterator() ;
        while(it.hasNext()){
            Object key = it.next() ;
            Object val = map.get(key) ;
            System.out.println(key + "-->" +val);
        }
    }
}

​