JAVA集合(学习记录)

集合：

集合的框架体系：

Collection接口的常用方法：

Collection接口实现类的特点

1.collection实现子类可以存放多个元素，每个元素可以是Object

2.有些Collection的实现类，可以存放重复的元素，有些不可以

3.有些Collection的实现类，有些是有序的List,有些不是有序Set

4.Collection接口没有直接的实现子类，是通过它的子接口Set和List来实现的

常用方法：

Collection接口常用方法，以实习那子类ArrayList来演示

1.add:添加单个元素

2.remove：删除指定元素

3.contains:查找元素是否存在

4.size：获取元素个数

5.isEmpty:判断是否为空

6.clear：清空

7.addAll:添加多个元素

8.containsAll:查找多个元素是否都存在

9.removeAll:删除多个元素

案例

package org.example.collection;

import java.util.ArrayList;
import java.util.List;

public class CollectionMethod {
    public static void main(String[] args) {
        List list = new ArrayList();
//        1.add:添加单个元素
        list.add("jack");
        list.add(10);
        list.add(true);
        System.out.println("list="+list);
//        2.remove：删除指定元素
//        list.remove(0);//删除第一个元素
        list.remove("ture");//指定删除某个元素
        System.out.println("list="+list);
//        3.contains:查找元素是否存在
        System.out.println(list.contains("jack"));
//        4.size：获取元素个数
        System.out.println(list.size());
//        5.isEmpty:判断是否为空
        System.out.println(list.isEmpty());
//        6.clear：清空
        list.clear();
        System.out.println("list="+list);
//        7.addAll:添加多个元素
        ArrayList list2 = new ArrayList();
        list2.add("红楼梦");
        list2.add("三国演义");
        list.addAll(list2);
        System.out.println("list="+list);
//        8.containsAll:查找多个元素是否都存在
        System.out.println(list.containsAll(list2));
//        9.removeAll:删除多个元素
        list.removeAll(list2);
        System.out.println("list="+list);

    }
}

Collection接口遍历元素方式1：

使用Iterator(迭代器)

1.Iterator对象称为迭代器，主要用于遍历Collection集合中的元素。

2.所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了Iterator接口的对象，既可以返回一个迭代器

3.Iterator的结构

4.Iterator仅用于遍历集合，Iterator本身并不存放对象

迭代器的执行原理

Iterator iterator = coll.iterator();//得到一个集合的迭代器

//hasNext():判断是否还有下一个元素

while(iterator.hasNext()){

//next():1.指针下移2.将下移以后集合位置上的元素返回

System.out.println(iterator.next());

}

案例：

package org.example.collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionIterator {
    public static void main(String[] args) {
        Collection col = new ArrayList();
        col.add(new Book("三国演义","罗贯中",10.1));
        col.add(new Book("小李飞刀","古龙",5.1));
        col.add(new Book("红楼梦","曹雪芹",34.6));
        System.out.println("col:"+col);
//        1.先得到col对应的迭代器
        Iterator iterator = col.iterator();
        //2.使用while循环遍历
//        while (iterator.hasNext()){//判断是否还有数据
            返回一个元素类型是object
//            Object obj = iterator.next();
//            System.out.println("obj="+obj);
//        }
        //快速生成while =>itit
        while (iterator.hasNext()) {
            Object next =  iterator.next();
            System.out.println("next="+next);
        }
//        3.当退出while循环后，这时iterator迭代器，指向最后的元素
//        iterator.next();//NoSuchElementException的错，会报
//        4.如果希望再次遍历，需要重置我们的迭代器
//        iterator= col.iterator();
    }
}

class Book{
    private String name;
    private String author;
    private double price;

    public Book(String name, String author, double price) {
        this.name = name;
        this.author = author;
        this.price = price;
    }

    public String getName() {
        return name;
    }

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

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                ", price=" + price +
                '}';
    }
}

Collection接口比哪里对象方式2-增强for循环

基本语法：

for(元素类型 元素名:集合名或数组名){

访问元素

}

案例：

package org.example.collection;

import java.util.ArrayList;
import java.util.Collection;

public class CollectionFor {
    public static void main(String[] args) {
        Collection col = new ArrayList();
        col.add(new Book("三国演义","罗贯中",10.1));
        col.add(new Book("小李飞刀","古龙",5.1));
        col.add(new Book("红楼梦","曹雪芹",34.6));
        //底层还是迭代器
        for (Object book:col){
            System.out.println(book);
        }
    }
}

List接口和常用方法：

List接口基本介绍：

List接口时Collection接口的子接口

1.List集合类中元素有序(即添加顺序和取出顺序一致),且可重复

2.List集合中的每个元素都有其对应的顺序索引，即支持索引。

3.List容器中的元素都对应一个整数型的序号记载其在容器中的位置，可以根据序号存取容器中的元素

4.JDK API中List接口的实现类有：ArrayList,LinkedList和Vector

List接口的常用方法：

1.void add(int index,Object ele):在index位置插入ele元素

2.boolean addAll(int index,Collection eles):从index位置开始将eles中的所有元素添加进来

3.Object get(int index):获取指定index位置的元素

4.int indexOf(Object obj):返回obj在集合中首次出现的位置

5.int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置

6.Object remove(int index):移除指定index位置的元素，并返回此元素

7.Object set(int index,Object ele):设置的元素为ele,相当于是替换

8.List subList(int fromIndex,int toIndex):返回从fromIndex到toIndex位置的子集合

ArrayList底层结构和源码分析

Vector底层结构和源码剖析：

LinkedList底层结构：

Linkedlist的全面说明：

1.Linkedlist实现了双向链表和双端队列特点

2.可以添加任意元素(元素可以重复)，包括null

3.线程不安全，没有实现同步

LinkedList的底层操作机制：

1.LinkedList底层维护了一个双向链表

2.LinkedList中维护了两个属性first和last分别指向首节点和尾节点

3.每个节点(Node对象)，里面又维护了prev,next,item三个属性，其中通过prev指向前一个，通过next指向后一个节点。最终实现双向链表

4.所以LinkedList的元素的添加和删除，不是通过数组完成的，相对来说效率较高

Set接口和常用方法：

Set接口基本介绍：

1.无序(添加和取出的顺序不一致)，没有索引,就不能用索引的方式来获取

2.不允许重复元素，所以最多包含一个null

3.JDKAPI中Set接口有主要的是：HashSet,TreeSet

HashSet的全面说明：

1.HashSet实现了Set接口

2.HashSet实际上是HashMap,看下源码

3.可以存放null值，但是只能有一个null

4.HashSet不保证元素是有序的，取决于hash后，再确定索引的结果

5.不能有重复元素/对象

LinkedHashSet的全面说明

1.LinkedHashSet是HashSet的子类

2.LinkedHashSet底层是一个LinkedHashMpa,底层维护了一个数组+双向链表

3.LinkedHashSet根据元素的hashCode值来决定元素的存储位置，同时使用链表维护元素的次序，这使得元素看起来是以插入顺序保存的

4.LinkedHashSet不允许添重复元素

Map接口和常用方法

Map接口实现类的特点

1.Map与Collection并列存在。用于保存具有映射关系的数据：Key-Value

2.Map中的key和value可以是任何引用类型的数据，会封装到HashMap$Node对象中

3.Map中的key不允许重复，原因和HashSet一样，前面分析过源码

4.Map中的value可以重复

5.Map的key可以为null,value也可以为null，注意key 为null,只能有一个，value为null，可以多个

6.常用String类作为Map的key

7.key和value之间存在单向一对一关系，即通过指定的key总能找到对应的value

8.Map存放数据key-value示意图，一对k-v是放在一个Node中的，有因为Node实现了Entry接口，有些书上也说一对k-v就是一个Entry

Map接口常用方法

1.put:添加

2.remove:根据键删除映射关系

3.get:根据键获取值

4.size:获取元素个数

5.isEmpty:判断个数是否为0

6.clear:清除

7.containsKey:查找键是否存在

Map接口遍历方法：

package org.example.map;

import java.util.*;

public class MapFor {
    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("邓超","孙俪");
        map.put("王宝强","马蓉");
        map.put("宋姐","马蓉");
        map.put("刘令博",null);
        map.put(null,"刘亦菲");
        map.put("鹿晗","关晓彤");
//        第一种：选取出所有的Key，通过key取出对应的value
//        (1)增强for
        Set keyset = map.keySet();
        for (Object key:keyset) {
            System.out.println(key+"-"+map.get(key));
        }
//        （2）迭代器
        Iterator iterator = keyset.iterator();
        while (iterator.hasNext()) {
            Object key = iterator.next();
            System.out.println(key+"-"+map.get(key));
        }
//2.把所有的value值取出
        Collection values = map.values();
//        这里可以使用所有的collections使用的遍历方法
//        (1)增强for
        for (Object value:values
             ) {
            System.out.println(value);
        }
//        (2)迭代器
        Iterator iterator1 = values.iterator();
        while (iterator1.hasNext()) {
            Object next = iterator1.next();

            System.out.println(next);
        }
//3.通过EntrySet来获取
        Set entrySetset = map.entrySet();
//        (1)增强for
        for (Object entry:entrySetset
             ) {
//            将entry转化Map.Entry
            Map.Entry m = (Map.Entry)entry;
            System.out.println(m.getKey()+"--"+m.getValue());
        }
//        (2)迭代器
        Iterator iterator2 = entrySetset.iterator();
        while (iterator2.hasNext()) {
            Object next = iterator2.next();
            Map.Entry m1 = (Map.Entry)next;
            System.out.println(m1.getKey()+"----"+m1.getValue());
        }
    }
}

HashMap小结

1.Map接口的常用实现类：HashMap,Hashtable和Properties

2.HashMap是Map接口使用频率最高的实现类。

3.HashMap是以key-val对的方式来存储数据

4.key不能重复，但是值可以重复，允许使用null键和null值

5.如果添加相同的key，则会覆盖原来的key-val，等同于修改(key不会替换，val会替换)

6.与HashSet一样，不保证映射的顺序，因为底层是以hash表的方式来存储的。

7.HashMap没有实现同步，因此线程不安全

HashMap扩容机制

1.HashMap底层维护了Node类型的数组table,默认为null

2.当创建对象时，将加载因子(loadfactor初始化为0.75)

3.当添加key-val时，通过key的哈希值得到在table的索引。然后判断该索引处是否有元素，如果没有元素直接添加。如果该索引处有元素，继续判断该元素的key是否和准备加入的key相等，如果相等，则直接替换val;如果不相等需要判断是树结构还是链表结构，做出相应处理。如果添加时发现容量不够，则需要扩容。

4.第1次添加，则需要扩容table容量为16，临界值(threshold为)12.

5.以后再扩容，则需要扩容table容量为原来的2倍，临界值为原来的2倍，即24，依此类推。

6.在Java8中，如果一条链表的元素个数超过TREEIFY_THESHOLD(默认是8)，并且talbe的

大小>=MIN_TREEIFY_CAPACITY(默认64)，就会进行树化(红黑树)

HashTable的基本介绍

1.存放的元素是键值对：即K-V

2.hashtable的键和值都不能为null，否则会抛出NullPointerException

3.hashTable使用方法基本上和HashMap一样

4.hashTable是线程安全的，hashMap是线程不安全的

Properties的基本介绍

1.Properties类继承自Hashtable类并且实现了Map接口，也是使用一种键值对的形式来保存数据

2.他的使用特点和Hashtable类似

3.Properties还可以用于从xxx.properties文件中，加载数据到Properties类对象，并进行读取和修改

4.说明：工作后 xxx.properties文件通常作为配置文件

开发中如何选择集合实现类

TreeSet案列

package org.example.set;

import java.util.Comparator;
import java.util.TreeSet;

public class TreeSet_ {
    public static void main(String[] args) {
//        1.当我们使用无参构造器，创建TreeSet时，仍然时无序的
//        2.老师希望添加的元素，按照字符串大小来排序
//        3.使用TreeSet提供的构造器，可以传入一个比较器(匿名内部类)
//        并指定一个排序规则
//
        TreeSet treeSet = new TreeSet(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
//                下面调用String 的compareTo方法进行字符串大小比较
//                return ((String)o2).compareTo((String)o1);
//                按照长度大小排序
                return ((String)o2).length()-((String)o1).length();
            }
        });
        treeSet.add("jack");
        treeSet.add("tom");
        treeSet.add("sp");
        treeSet.add("a");
        System.out.println("treeSet="+treeSet);

    }
}

TreeMap案列

package org.example.map;

import org.example.set.TreeSet_;

import java.util.Comparator;
import java.util.TreeMap;

public class TreeMap_ {
    public static void main(String[] args) {
        //使用默认构造器，创建TreeMap,是无序的(也没有排序）
        /*
        * 要求按照传入的k(String)的大小排序
        * */
        TreeMap treeMap = new TreeMap(new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
//                return ((String)o2).compareTo((String)o1);
//                按照字符串长度来进行排序
                return ((String)o2).length()-((String)o1).length();
            }
        });
        treeMap.put("jack","杰克");
        treeMap.put("tom","汤姆");
        treeMap.put("kristina","克瑞斯提诺");
        treeMap.put("smith","斯密斯");

        System.out.println("treemap="+treeMap);
    }
}

Collections工具类

Collections工具类介绍

1.Collections是一个操作Set,List和Map等集合的工具类

2.Collections中提供了一系列静态的方法对集合元素进行排序，查询和修改等操作

排序操作：(均为static方法)

1.reverse(List):反转List中元素的顺序

2.shuffle(List):对List集合元素进行随机排序

3.sort(List):根据元素的自然顺序对指定List集合元素按升序排序

4.sort(List,Comparator):根据指定的Comparator产生的顺序对List集合元素进行排序

5.swap(List,int,int):将指定list集合中的i处元素和j处元素进行交换

查找，替换

1.Object max(Collection):根据元素的自然顺序，返回给定集合中的最大元素

2.Object max(Collection,Comparator):根据Comparator指定的顺序，返回给定集合中的最大元素

3.Object min(Collection)

4.Object min(Collection,Comparator)

5.int frequency(Collection,Object):返回指定集合中指定元素的出现次数

6.void copy(List dest,List src):将src中的内容复制到dest中

7.boolean replaceAll(List list,Object oldVal,Object newVal):使用新值替换List对象的所有旧值

tic方法)

1.reverse(List):反转List中元素的顺序

2.shuffle(List):对List集合元素进行随机排序

3.sort(List):根据元素的自然顺序对指定List集合元素按升序排序

4.sort(List,Comparator):根据指定的Comparator产生的顺序对List集合元素进行排序

5.swap(List,int,int):将指定list集合中的i处元素和j处元素进行交换

查找，替换

1.Object max(Collection):根据元素的自然顺序，返回给定集合中的最大元素

2.Object max(Collection,Comparator):根据Comparator指定的顺序，返回给定集合中的最大元素

3.Object min(Collection)

4.Object min(Collection,Comparator)

5.int frequency(Collection,Object):返回指定集合中指定元素的出现次数

6.void copy(List dest,List src):将src中的内容复制到dest中

7.boolean replaceAll(List list,Object oldVal,Object newVal):使用新值替换List对象的所有旧值