JAVA集合

一.集合

1.集合的由来

集合是容器类型，容器类型还有（数组和Stringbuffer）

2.数组和集合的区别

​ 数组的长度固定
​ 集合的长度可变

数组储存的是同一类型的数据
集合储存的可以是任意类型的数据

数组可以储存基本数据类型 和引用数据类型
集合只能存储引用类型的数据

3.Iterator 迭代器

①先创建一个集合

list c1=new arraylist（）；
C1.add("1");
C1.add("2");
C1.add("3");
C1.add("4");
//创建迭代器接口
Iterator it=c1.iterator();
//提取元素
while (it.hasNext()){						查看集合内部是否为空 返回值是true 或者false
    String name = it.next();				获取集合内的下一个元素，，，其实就是本为元素，因为集合首先是空的
    System.out.println(name);

4.迭代器的注意事项

循环尽量用while
不要多次使用next方法
迭代器是依赖于集合而存在的
迭代器啥时候用啥时候创建

5.泛型

简单理解为参数的数据类型

提前限定好集合只能存储的数据类型

举例：

List<String> list = new ArrayList();   // 这个集合泛型为了字符串  之后存储也只能存储字符串

list.add("张益鸣")；

二.List

1.ArrayList的特点

特点：底层数据结构是数组，查询快，增删慢，线程不安全，效率高，可以存储重复元素

举例：

ArrayList list = new ArrayList();
System.out.println(list);

2.LinkedList的特点

底层数据结构是链表，查询慢，增删快，线程不安全，效率高，可以存储重复元素

LinkedArrayList list = new LinkedArrayList();
System.out.println(list);

3.List的子类特点及功能

list是有序的 意思是进来是啥顺序出去就是啥顺序 可重复
此类为list集合的特有功能

3.1 添加功能

​ 在指定位置加入某各元素 不能元素越界
​

    void  add (int index,objecct lement)

3.2 获取功能

• object get(int index)获取指定位置的元素
  1
  li1.get(1) 获取指定位置的数据
  *列表迭代器
  *ListInerator listIterator() list特有的功能
  

3.3 删除功能

• object remove(int index)//删除指定的元素
  1
  删除指定位置的元素 并且返回该元素
  

3.4 修改功能

改变指定位置的数据

set(int index,E element);

3.5 遍历功能

利用get和size方法进行结合出来的遍历

for (int i = 0; i < li1.size(); i++) {
System.out.println(li1.get(i));

特有的迭代器
但是基本上不用，因为不通用（其实与基本的迭代器差不多，操作一样）

迭代器 是依赖于集合的不能存在并发执行修改
迭代器遍历元素的时候，通过集合是不能修改内容的
迭代器在添加元素的时候应该使用ListIterator中的add方法
用普通迭代器中add不行
新添加的元素是跟在刚才迭代的元素的后面

三.Set

1. set 的概念

set集合不包含重复元素 并且有序 不会按照自己输入的顺序 是个接口 （从大到小）

set集合：存储顺序和添加顺序不一定相同

​ 不可以保存相同的数据

​ 每个元素没有索引（即：不可以通过下标遍历，可通过迭代器）

2.HashSet概述

2.1HashSet不保证set的迭代顺序，特别是它不保证该顺序恒久不变

2.2HashSet如何保证元素的唯一性

底层数据结构是哈希表（元素是链表的数组）

哈希表依赖与哈希值存储

添加功能底层依赖两个方法：

int hashCade（）；

boolean equals（Object obj）；

3.LinkedHashSet（是hashset的子类）

有两个数据机构 一个是链表 一个是hash表
A. 元素有序唯一
B. 由链表保证元素有序
C. 由哈希表保证元素唯一
D. 存取顺序一致

4.Treeset 默认排序 并且消除重复项

是排序基于treemap的put方法来进行排序的
还有比较器排序是依赖于compareTo（）方法 而这个方法是定义在定义在Comparable里面的 所以要想重写该方法 就必须先Comparable接口 则就是自然排序

举例：

public class Book implements Comparable {
    /**
     * 书名
     */
    private String name;
    /**
     * 作者
     */
    private String author;
    /**
     * 单价
     */
    private int price;
    /**
     * 销量
     */
    private int sales;

    @Override
    public int compareTo(Object o) {
        Book book = (Book) o;
        int y = this.name.compareTo(book.getName());
        int x = book.getAuthor().compareTo(this.author);
        int z = getPrice()-this.price;
        int w = getSales()-this.sales;
        if (y!=0){
            return y;
        }else if (x!=0){
            return x;
        }else if (z!=0){
            return z;
        }else {
            return w;
        }
    }
}

输出：

    SortedSet<Book> books = new TreeSet<>();
    books.add(new Book("浮城谜事", "娄烨", 35, 150));

四. Map集合

1. Map集合的特点

将映射得值的对象，一个映射不能包含重复的键；
每个键最多只能映射到一个值

2.Map集合和collection集合的区别

A． map集合存储元素成对出现，map集合的键是唯一的，只可以重复出现，可理解为夫妻对
B． collection集合存储元素是单度出现的，collection的儿子set是唯一的 list是可重复的，可理解为是单独的
C． map集合的数据结构只针对于键有效，与值无关
collection集合的数据结构是针对于元素有效

3.Hashmap的功能

举例：

A．添加功能 V put（k key， V value）

Map<String, String> map = new HashMap<>();
map.put("key1","value1");
System.out.println(map.get("key1"));

B．删除功能 void clear（）清除所有的映射关系

V remove （object key） 根据键移除键值对元素 并把值返回

Map<String, String> map = new HashMap<>();
map.put("key1", "value1");
 map.remove("key1");

C．获取功能 set<map,entry<k,v>> entrySet()=对象.entrySet

public void test09() {
    //利用map.entrySet();  将map里的key和value转为一个set整体 然后再遍历输出
    Map<String, String> map = new HashMap<>();
    for (int i = 0; i < 10; i++) {
        map.put("key" + i, "value" + i);
    }
    Set<Map.Entry<String, String>> entrySet = map.entrySet();
    Iterator<Map.Entry<String, String>> it = entrySet.iterator();
    while (it.hasNext()){
        Map.Entry<String, String> entry = it.next();
        System.out.println("key >>> " + entry.getKey() + "\tvalue >>> " + entry.getValue());
    }
}

V get (object ket) 根据键获取值
Set（k） keyset 获取集合中所有键的集合
Collection values（） 获取集合中所有值的集合

public void test08() {
    //将value变成collection 然后利用迭代器 遍历输出
    Map<String, String> map = new HashMap<>();
    for (int i = 0; i < 10; i++) {
        map.put("key" + i, "value" + i);
    }
    Collection<String> values = map.values();
    Iterator<String> it = values.iterator();
    while (it.hasNext()) {
        String value = it.next();
        System.out.println(value);
    }
}

D．长度功能 int size（） 返回键值对的个数

Map<String, String> map = new HashMap<>();
map.put("key1","value1");
System.out.println(map.size());

4. LinkedHashMap<String, String>

LinkedHashMap 可以保持序列的有序性（即 你输入数据的顺序 HashMap的保证数据的唯一性 Linked保证数据的有序性）

举例：

public void test01(){
    //new linedHashMap  输出后就是有序的
    Map<String, String> map = new LinkedHashMap();
    for (int i = 0; i < 10; i++) {
        map.put("key" + i, "value" + i);
    }
    Set<Map.Entry<String, String>> entrySet = map.entrySet();
    Iterator<Map.Entry<String, String>> it = entrySet.iterator();
    while (it.hasNext()){
        Map.Entry<String, String> entry = it.next();
        System.out.println("key >>> " + entry.getKey() + "\tvalue >>> " + entry.getValue());
    }
}

5. HashMap和hashtable的区别

hashMap是用来替代Hashtable的 hashtable的用法和HashMap差不多
Hashtable 线程安全 不允许null键和null值
HashMap线程不安全 效率高 允许null键和null值

举例：

public void test01(){
    Map<String, String> map = new Hashtable();
    for (int i = 0; i < 10; i++) {
        map.put("key" + i, "value" + i);
    }
    Set<Map.Entry<String, String>> entrySet = map.entrySet();
    Iterator<Map.Entry<String, String>> it = entrySet.iterator();
    while (it.hasNext()){
        Map.Entry<String, String> entry = it.next();
        System.out.println("key >>> " + entry.getKey() + "\tvalue >>> " + entry.getValue());
    }
}

6.ConcurrentHashMap

public void test01() {
    Map<String, String> map = new ConcurrentHashMap();
    for (int i = 0; i < 10; i++) {
        map.put("key" + i, "value" + i);
    }
    Set<Map.Entry<String, String>> entrySet = map.entrySet();
    Iterator<Map.Entry<String, String>> it = entrySet.iterator();
    while (it.hasNext()) {
        Map.Entry<String, String> entry = it.next();
        System.out.println("key >>> " + entry.getKey() + "\tvalue >>> " + entry.getValue());
    }
}