集合框架学习

集合框架学习

1.Collection接口

常用方法

boolean	add(E e) 向 collection 添加指定的元素（可选操作）。
boolean	remove(E e) 把给定元素在当前集合删除
Iteratir	iterator() 返回在此 collection 的元素上进行迭代的迭代器
boolean	containsAll(Collection c) 如果此 collection 包含指定 collection 中的所有元素，则返回 true。
void	clear() 移除此 collection 中的所有元素，但不删除集合（可选作）。
boolean	contains(Object o) 如果此 collection 包含指定的元素，则返回 true。
boolean	equals(Object o) 比较此 collection 与指定对象是否相等。
int	hashCode() 返回此 collection 的哈希码值。
boolean	isEmpty() 如果此 collection 不包含元素，则返回 true。
int	size() 返回此collection元素个数

Iterator迭代器

Collection接口方法iterator()返回一个此集合的迭代器

主要用于集合的遍历

迭代器常用方法

boolean   hasNext()       //判断此集合还有灭有元素
Object    next()           //取出集合的下一个元素

示例

Collection <String> coll = new ArrayList<>();
coll.add("lili")
   Iterator<String> it = coll.iterator()
   while(it.hasNext){
     String str = it.next();
   }

原理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HnrmasTK-1597737049139)(G:\图片素材\java\1596201194351.png)]

增强for循环

所有的单列集合都可以用增强for循环

底层也是使用了Iterator迭代器

for（集合/数组的数据类型 变量名：集合名/数组名）{
 sout(变量名)
}

Collections

操作Collection的工具类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-t6dm7yDV-1597737049141)(G:\图片素材\java\1596198124144.png)]

2.LIst接口

允许重复元素

list接口带索引的方法

public void add(int index,E element)	将指定元素添加到集合的指定位置上
public E get(int index)	返回集合中的指定位置的元素
public E remove(int index)	移除列表中指定位置的元素，返回的是被移除的元素
public E set(int index,E element)	用指定元素替换集合中指定位置的元素，返回更新前的元素

3.ArrayList集合

ArrayList<String> list = new ArrayLOist<>; //字符串类型集合
//常用的方法
list.add("东东")  //添加一个元素方法，返回一个boolean
list.add(4，"东东")  //指定位置添加一个元素方法
list.get(0)  //从集合取出元素，参数为索引编号，返回对应位置元素
list.remove(0)//从集合中删除元素，参数为索引编号，返回被删除的元素
list.size() //获取集合的长度，无参数，返回集合包含元素的个数
   boolean isEmpty() //判断集合是否为null 返回布尔值

特点：

实现了List接口，底层就是数组，复制数组，查询快增删慢

数组的长度不可发成变化，ArrayList集合长度可随意变化

ArrayList直接打印，得到的不是地址值而是直接打印内容

E:泛型

泛型只能是引用类型，不能为基本类型

装箱，拆箱

8大基本类型：byte short int long float double char boolean

包装类（引用）:Byte Short Integer Long Double Character Boolean

4.LinkedList集合

特点

实现了list接口的链表实现，查询慢，增删快，有索引，有序

不能使用多态创建LinkedList集合对象

常用方法

public boolean add(Object element)	向链表末尾添加一个新节点，该节点中的数据是参数element指定的对象
public void add(int index,Object element)	向链表指定位置添加一个新节点，该节点中的数据是参数element指定的对象
public void addFirist(Object element)	向链表表头添加一个新节点，该节点中的数据是参数element指定的对象
public Object removeFirst()	删除第一个节点并返回这个节点中的对象
public Object removeLast()	删除最后一个节点并返回这个节点中的对象
public Object remove(int index)	删除指定位置的节点
public Object get(int index)	得到指定位置的节点
public Object getFirst()	得到链表第一个节点的对象
public Object getLast()	得到链表最后一个节点的对象
public Object set(int index,Object element)	将当前链表index位置节点中的对象替换成参数element指定的对象，返回被替换对象

5.Set接口

特点：

1.不允许存储重复的元素

2.没有索引，没有代索引的方法，也不能用普通的for循环遍历

3.是一个无序集合，存储元素和取出元素的顺序可能不一致

6.HashSet集合

特点：

1.不允许存储重复的元素

2.没有索引，没有代索引的方法，也不能用普通的for循环遍历

3.是一个无序集合，存储元素和取出元素的顺序可能不一致

4.底层是一个哈希表结构（查询速度非常快）

哈希表=数组+链表 或者
哈希表=数组+红黑树(提高查询的速度

5.用HashSet存储自定义元素要重写hashcode和equals方法

常用方法

boolean	add(E e) 如果此 set 中尚未包含指定元素，则添加指定元素。
void	clear() 从此 set 中移除所有元素。
Object	clone() 返回此 HashSet 实例的浅表副本：并没有复制这些元素本身。
boolean	contains(Object o) 如果此 set 包含指定元素，则返回 true。
boolean	isEmpty() 如果此 set 不包含任何元素，则返回 true。
Iterator	iterator() 返回对此 set 中元素进行迭代的迭代器。
boolean	remove(Object o) 如果指定元素存在于此 set 中，则将其移除。
int	size() 返回此 set 中的元素的数量（set 的容量）。

哈希值

十进制的整数，由系统通过一定的哈希算法，将一段较长的数据映射为较短小的数据（就是的对象的地址，是一个逻辑地址，是模拟出来得到的地址，不是数据实际存储的物理地址）

HashSet集合存储数据的结构(哈希表)

jdk1.8版本之前:哈希表=数组+链表
jdk1.8版本之后:
哈希表=数组+链表 或者
哈希表=数组+红黑树(提高查询的速度
哈希表的特点速度快

hashset存储原理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nzH49lMy-1597737049143)(G:\图片素材\java\1596273356675.png)]

在Object类有个方法可以获取哈希值
hashCode();
//string类重写了hashcode()方法
        String s1 = new String("aaa");
        String s2 = new String("aaa");//在数组中的储存位置
        System.out.println(s1.hashCode());
        System.out.println(s2.hashCode());
        System.out.println("===============");
        System.out.println("Java：".hashCode());
        System.out.println("Python：".hashCode());
        System.out.println("===============");
        System.out.println("重地：".hashCode());
        System.out.println("通话：".hashCode());//巧合，哈希冲突
//输出结果
===============
71411992
71411992
===============
36626551
36626551

7.LinkedHashSet集合

特点：

1.LinkedHashSet集合extends HashSet集合 有序 不允许重复

2.底层是一个哈希表（数组+链表/红黑树）+链表：多一条链记录存储顺序，保证有序

Map集合接口

特点：

1.map集合是一个双列集合，一个元素包含key,value

2.map集合的元素，key,value数据类型可以相同也可不同

3.map集合中，key不可以重复，value可以重复

4.map集合中的元素，key和value是一一对应的

常用方法

put(K key,V value)：添加指定的key值，和制定的value值到Map集合中
remove（object key）：Map集合中删除指定键对应的元素,返回被删除元素的值
get(object key)：获取指定键，在Map集合中获取对应的值
keySet()：获取Map集合中指定的键，存储到set集合中 主要是遍历map集合用
containKey(object key)：判断该集合中是否有此键
entrySet():把map集合内部的多个Entry对象取出来，存到一个Set集合中

1.HashMap<k,v>集合

特点：

1.底层是哈希表，查询速度快

2.JDK1.8之前：数组 +单向列表

JDK1.8之后：数组+单向链表/红黑树（链表的长度超过8）：提升查询速度

3.HashMap<k,v>集合是一个无序的集合，存储元素和取出元素的顺序有可能不一致

4.存储自定义元素为key值要重写hashcode和equals方法

2.LinkedHashMap集合

特点：

1.底层是哈希表+链表（保证迭代的顺序）

2.是个有序的集合，存入和取出元素顺序是一致的

3.用LinkedHashMap存储自定义元素时key值要重写hashcode和equals方法

3.Hashtable集合

特点：

1.底层是哈希表，线程安全：单线程，速度慢

2.不能存null值null键

3.已被HashMap替代

4.有个子类properties集合很出名

JDK9新特性

List接口，Set接口，Map接口里面增加了一个静态方法of，可以给集合一次性添加多个元素使用前提，当集合中存储的元素的个数不在改变

注意：

1.of方法只适用于List接口，Set接口，Map接口，不适用于其他接口实现类

2.of方法的返回值是一个不能改变的集合，集合不能再使用add，使用put方法会抛出异常

3.Set接口，Map接口在调用时，不能有重复的元素，否则会异常

数据结构

栈

先进后出 入栈（压栈） 出栈（弹栈） 举例（枪弹夹）

队列

先进先出 举例（排队安检）

数组

特点：查询快：通过数组首地址可快速找到数组，通过索引快速找到某一元素

​ 增删慢：数组的长度固定，想要增删一个元素，必需创建一个新数组，复制原数组

链表

特点：查询慢：链表中的地址不是连续的，每次查询元素都必须从同开始查询

​ 增删快：链表结构，增删一个元素，对链表整体没有影响，所以增删块

单向链表：链表中只有一条链子，不能保证元素的顺序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jTX4n2pr-1597737049147)(G:\图片素材\java\1596249835800.png)]

循环链表：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VNG8oPnt-1597737049149)(G:\图片素材\java\1596250325623.png)]

双向链表：链表中有两条链子，有一条是专门记录元素的顺序，是一个有序的集合

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pQP7gb8I-1597737049151)(G:\图片素材\java\1596250469185.png)]

红黑树

查询速度非常快

手动实现一个单向链表

1.创建链表对象类

public class HeroNode {
    /**
     * 编号
     */
    private int id;
    /**
     * 英雄名称
     */
    private String name;
    /**
     * 下一个英雄串接位置
     */
    private HeroNode next;
    /**
     * 构造方法
     * @param id
     * @param name
     */
    public HeroNode(int id, String name) {
        this.id = id;
        this.name = name;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public HeroNode getNext() {
        return next;
    }
    public void setNext(HeroNode next) {
        this.next = next;
    }
    @Override
    public String toString() {
        return "id = " + id + ", name = " + name;
    }
}

2.无序单向链表实现

public class SingleLinkedListDemo {

    /**
     * 第一步
     *  初始化一个头节点.不放具体数据
     */
    private HeroNode firstHear = new HeroNode(0,null);

    /**
     * 第一步
     *  添加新节点
     */
    public void add(HeroNode heroNode){
        // 创建一个t来作为起点寻找下一个节点的位置
        HeroNode temp = firstHear;
        // 判断temp的next节点是否为空.如果为空,则把新节点放到该节点的next
        while (true){
            if (temp.getNext() == null){
                break;
            }else{
                temp = temp.getNext();
            }
        }
        temp.setNext(heroNode);
    }
    /**
     * 删除某个元素
     * @param heroNode
     */
    public void delete(HeroNode heroNode){
        HeroNode temp = firstHear;
        HeroNode before = null;
        while (true){
            if (temp.getNext() == null){
                break;
            }else{
                before = temp;
                temp = temp.getNext();
                if (temp.getId() == heroNode.getId()){
                    break;
                }
            }
        }
        before.setNext(temp.getNext());
    }
    /**
     * 输出 :
     */
    public void list(){
        HeroNode temp = firstHear;
        while (temp.getNext() != null){
            temp = temp.getNext();
            System.out.println(temp.toString());
        }
    }
}

p = temp.getNext();
if (temp.getId() == heroNode.getId()){
break;
}
}
}
before.setNext(temp.getNext());
}
/**
* 输出 :
*/
public void list(){
HeroNode temp = firstHear;
while (temp.getNext() != null){
temp = temp.getNext();
System.out.println(temp.toString());
}
}
}