Java基础之集合

目录

集合

 Collection接口

List 接口及实现类

ArrayList

LinkedList的常用方法

List接口集合迭代

Set 接口

HashSet

TreeSet

Set 接口集合迭代(和List接口集合迭代相似,不重复写了)

Map 接口

HashMap

Hashtable

TreeMap

集合

Java的集合框架是由很多接口,抽象类,具体类组成的.都位于java.util包中.

 Collection接口

Collection接口  是单列集合中最大的接口
Collection类  是一个集合操作的工具类   里面包含许多的静态方法
Collections是集合类的工具类，与数组的工具类Arrays类似.

• binarySearch(List<? extends Comparable<? super T>> list, T key)
• sort(List<T> list)
• swap(List<?> list, int i, int j)
• copy(List<? super T> dest, List<? extends T> src) ; 注意 dest size需大于等于src.size
• fill(List<? super T> list, T obj)
• max(Collection<? extends T> coll)
• min(Collection<? extends T> coll)
• replaceAll(List<T> list, T oldVal, T newVal)
• reverse(List<?> list)
• shuffle(List<?> list) 随机排序

ArrayList<Integer> arrayList = new ArrayList<>();
                           arrayList.add(2);
                           arrayList.add(5);
                           arrayList.add(1);
                           arrayList.add(4);
                           arrayList.add(4);
                           arrayList.add(3);
        //collections.sort(arrayList);//序
        //System.out.println(Collections.binarySearch(arrayList,55)); 二分查找
        //collections.swap(arrayList,0，3)//交换两个指定位置的元素
        ArrayList<Integer> arrayList1 = new ArrayList<>();
                           arrayList1.add(6);
                           arrayList1.add(7);
                           arrayList1.add(8);
        //Collections.copy(arrayList，arrayListl);//把一个集合中的数据复制到指定的集合中，目标集合的size需要大于等于原集合的size
        System.out.println(arrayList);

List 接口及实现类

ArrayList

• add(E element)
• add(int index, E element)
• addAll(Collection<? extends E> c)
• remove(int index)
• remove(Object o)
• clear()
• set(int index, E element)
• indexOf(Object o)
• isEmpty()
• contains(Object o)
• get(int index)
• size()
• toArray(T[] a)

ArrayList<String> arrayList0 = new ArrayList();
                          arrayList0.add("M");


        ArrayList<String> arrayList = new ArrayList();
                          arrayList.add("a");//默认向末尾添加元素
                          arrayList.add("b");
                          arrayList.add("c");
                          arrayList.add("d");
                          arrayList.add(1, "e");//向指定位置添加元素
                          arrayList.addAll(arrayList0);//把另外一个集合数据添加进来
        System.out.println(arrayList);

        //System.out.println(arrayList.remove(2));//根据索引删除对应的元素  并返回删除的元素
        //System.out.println(arrayList.remove("m"));//根据内容删除第一次匹配的元素,删除成功返回true,否则返回false;
        //arrayList.clear();//清空集合元素

        System.out.println(arrayList.isEmpty());//判断集合是否为空  为空返回true
        System.out.println(arrayList.contains("b"));//判断是否包含指定的元素

        arrayList.set(1, "E");//替换指定位置的元素
        System.out.println(arrayList.indexOf("a"));//指定元素所在的索引值
        System.out.println(arrayList.size());//返回的是集合实际添加的元素个数

        System.out.println(arrayList);

LinkedList的常用方法

• add(E e)
• add(int index,Eelement)
• set(int index, E element)
• get(int index)
• removeFirst()
• contains(Object o)
• isEmpty()
• getFirst()
• getLast()
• addFirst(Eelement)
• addLast(Eelement)
• removeLast()
• remove(int index)

LinkedList<Integer> linkedList = new LinkedList<>();
                            linkedList.add(1);
                            linkedList.add(2);
                            linkedList.add(3);
                            linkedList.add(4);
                            /*
                            linkedList.add(1, 3);
                            linkedList.addFirst(5);
                            linkedList.addLast(6);
                            */
        System.out.println(linkedList.get(3));//只能从头或者尾开始查找,直到找到对应的位置的元素

        System.out.println(linkedList);

        /*
           栈和队列

           队列: 排队   从尾添加  从头
         */
        LinkedList<String> linkedList1 = new LinkedList<>();
                           linkedList1.addLast("一一");
                           linkedList1.addLast("二二");
                           linkedList1.addLast("三三");
        System.out.println(linkedList1.removeFirst());

List接口集合迭代

for循环遍历

支持遍历时,删除数据 注意:删除后 ,后面的元素前移

 for (int i = 0; i < arrayList.size(); i++) {
            if (arrayList.get(i).equals("a")){
                arrayList.remove(i);
                i--;
            }
        }

增强for循环的遍历

不允许删删除数据,如果删除数据会报错

for (String s : arrayList){
            if (s.equals("a")){
                arrayList.remove(s);
            }
        }

迭代器遍历（Iterator）

 Iterator<String> iterator = arrayList.iterator();
        while (iterator.hasNext()){
            String item = iterator.next();
            if (item.equals("a")){
                iterator.remove();//调用迭代器中的remove
            }
        }

Set 接口

HashSet

HashSet类底层基于哈希表实现,元素位置是散列无序的

HashSet是如何实现值不能重复(HashMap的key不重复原理):
    底层用到两个方法  hashCode()  equals()
    先调用hashCode(),根据内容算出一个哈希值(int类),先用整数哈希值比较,哈希值相同,说明内容也就相同了
    用哈希值判断是会存在风险的:内容不同.算出的哈希值相同   例如"通话"和"重地"
    所以在哈希值相同的情况下,再调用equals()判断内容

    结论:向HashSet中添加的数据类型中,必须提供hashCode()和equals()

向HashSet中存储我们自己定义的Studet类型,如果没有重写hashCode(),默认会掉调用object类中hashCode()
  Object类中    public native int hashCode();是一个native修饰的方法(是本地方法,是由操作系统提供的),读取的是对象的内存地址
  所以只要是new出来的对象,对象地址都不同
  现在的需求是,对象中的内容相同,就判定为重复内容
  需要对Object类中的equals()和hashCode()进行重写,根据内容计算哈希值,判断内容是否相等----提高效率

HashSet<Integer> hashSet = new HashSet<>();
                         hashSet.add(1);
                         hashSet.add(22);
                         hashSet.add(33);
                         hashSet.add(44);
                         hashSet.add(5);
                         hashSet.add(65);//将指定的元素添加到此集合(如果尚未存在)
                         //hashSet.clear();//从此集合中删除所有元素
                         hashSet.contains(5);//如果此集合包含指定的元素,则返回 true
                         hashSet.isEmpty();//如果此集合不包含元素,则返回 true
                         hashSet.iterator();//获得迭代器
                         hashSet.remove(33);//如果存在,则从该集合中删除指定的元素
                         hashSet.size();//返回此集合中的元素数(其基数)
        System.out.println(hashSet);

TreeSet

TreeSet底层基于树形结构实现,元素进行指定方式的排序.存储的类型必须实现Comparable接口.

TreeSet  底层使用的是红黑树  可以自平衡  避免成为链表
向TreeSet集合中添加的类型必须要实现comparable接口,提供一个排序的规则

TreeSet<Student> treeSet = new TreeSet<>();
                         treeSet.add(new Student(101, "Jam"));
                         treeSet.add(new Student(105, "Max"));
                         treeSet.add(new Student(104, "Min"));
                         treeSet.add(new Student(102, "Donk"));
                         treeSet.add(new Student(103, "Tom"));
        System.out.println(treeSet);

Set 接口集合迭代(和List接口集合迭代相似,不重复写了)

Map 接口

• 实现了Map接口的实现类都是双列集合
• 可以存储一组键值对
• 键不能重复,值可以重复

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()
   V get(Object key)
   Collection<V> values()
   Set<K> keySet()

HashMap

HashMap
   可以存储一个为null的键,值都可以为null

   底层用到的数据结构: 哈希表(数组)链表 红黑树

   向HashMap中添加元素的过程:
       当向HashMap添加一个元素,首先用key计算出一个哈希值,用哈希值与数组长度进行取模运算,结果就是该元素在数组中的位置.
       如果此位置上还没有元素,直接将该元素存储到一个节点中,放到数组中
       如果继续添加元素,出现相同位置,先比较两者是否相同,如果不同,把后一个元素挂载到第一个元素的后面形成一个链表,当链表的长度满足一定条件时,会转为红黑树

   常用参数:
      哈希表(数组长度):16
      哈希表扩容:每次扩容为原来的2倍

   链表转红黑树条件: 链表长度等于8  哈希表长度大于等于64

HashMap<String , String> hashMap = new HashMap<>();
                                 hashMap.put("x", "xx");
                                 hashMap.put("q","qq");
                                 hashMap.put("z", "zz");
                                 hashMap.put("k", "kk");
                                 hashMap.put("a", "aa");
                                 //hashMap.clear();
        System.out.println(hashMap.remove("a"));//通过key删除键值映射
        System.out.println(hashMap.containsKey("q"));//判断是否包含指定的key
        System.out.println(hashMap.containsValue("kk"));//判断是否包含指定的value
        System.out.println(hashMap.isEmpty());
        System.out.println(hashMap.size());
        System.out.println(hashMap.get("k"));

        Collection<String> values = hashMap.values();
        System.out.println(values);

        System.out.println(hashMap);

Hashtable

无序的  也是哈希结构的,方法都加了锁,在多线程场景是安全的
不能存储为null的键和值

if (value == null) {
     throw new NullPointerException();//抛出异常,程序终止
}

TreeMap

基于红黑树结构的实现类,可以通过key的自然顺序进行排序,如果需要得到一个有序的Map就应该使用TreeMap,key值的类型必须实现Comparable接口,重写compareTo方法.