Java集合相关

集合---容器 与数组类似，集合的长度存储之后还能改变 ，集合是用来存储一组元素 可以理解为集合是我们封装的Box

集合java.util

Collection和Map都是接口

Collection存储的都是value(是一个对象形式,应用类型的) (都是接口不能直接new对象)

List有序可重复 set 无序无重复      Queue

map存储的是以key-value形式存在 

key无序无重复 value无序可重复

序 : 顺序 添加进去的元素 取得元素的顺序一致 注意指的不是集合自己的顺序

重复：两个对象元素一致

List集合

ArrayList

ArrayList(JDK1.2) Vector区别(JDK1.0)--->类似于StringBuilder StringBuffer

ArrayList----->底层就是一个数组

所属的包 java.util，默认是扩容1.5倍，ArrayList特点适合遍历轮询 不适合插入删除

如何创建对象

无参数构造方法 带默认空间的构造方法 带collection参数的构造方法

常用的方法---小容器 (增删改查)

存 add 取 get 删 remove 改 set 个数 size

add(E e) add(int index,E e)

addAll(Collection c);并集 合并两个对象里面的 方法里面是一个集合类型的

addAll(Collection<? extends E> c)

ArrayList<Integer> list1 = new ArrayList<Integer>();

ArrayList<Integer> list2 = new ArrayList<Integer>();

list1.addAll(list2); 并集

注意：如果list2里面的类型和list1不一样就存不进去 或者list2是list1里面的子类 list2的类型小于list1

add(int index,E e)

clear();将集合内的全部元素清除

set(int index, E element)

boolean = contains(Object);找寻某一个给定的元素是否在集合中拥有

ensureCapacity(int minCapacity);

E = get(int index);

int = indexOf(Object obj); lastIndexOf(); 跟String用法不一样里面只有一个参数

boolean = isEmpty();

Iterator = list.iterator();//迭代器(通常用来遍历没有顺序的)

remove(int index) //知道索引位置 remove(Object obj)//不知道索引位置

如果list是Integer类型,remove里面写数字默认看作基本类型，删除索引位置

要删除某个数字就需要重新new一个对象list.remove(new Integer(1));

list1.removeAll(list2)差集

retainAll();交集

E = set(int index,E value)返回旧的元素

int size();

List = subList(int begin,int end);截取 返回一个父类的List //不包括end

List<Integer> list =arrayList.subList(0,2);//需要创建一个新的来接收

toArray(); 集合变成数组 需要造型

Object[] objects=arrayList.toArray();
for (Object o:objects){
Integer integer=(Integer)o; 
System.out.println(integer);
}

toArray(T[] );//需要先创建一个新的数组用来接收

Integer[] integers=new Integer[arrayList.size()];

arrayList.toArray(integers); //集合就变成了数组

此时integers里面就有了集合里面的元素

trimToSize();// 变成有效元素个数那么长

//快速创建集合

List<String> list= Arrays.asList("111","222","333");

LinkedList

LinkedList是一个实现了List接口和Deque接口的双端链表。它继承自AbstractSequentialList，是Java集合中常用的数据结构之一。

LinkedList底层链表结构支持高效的插入和删除操作，同时它实现了Deque接口，使得LinkedList类也具有队列的特性。它还可以被当作堆栈、队列或双端队列进行使用。

LinkedList实现了Cloneable接口，这意味着它可以被克隆。同时，它也实现了java.io.Serializable接口，这意味着LinkedList支持序列化，能通过序列化进行传输。

需要注意的是，LinkedList中的操作不是线程安全的。如果想使LinkedList变成线程安全的，可以调用静态类Collections类中的synchronizedList方法。

Vector类

1.java.util包

2.是ArrayList集合的早期版本 (StringBuffer早期 StringBuilder后来)

Vector底层也是利用(动态)数组的形式存储

Vector是线程同步的(synchronized) 安全性高 效率低

3.扩容方式与ArrayList不同

默认是扩容2倍 可以通过构造方法创建对象时修改这一机制

4.构造方法

5.常用方法 和Arraylist用法差不多

Stack类

栈 先进后出FILO //继承vector vector里面的方法都能调用

1.java.util包

2.构造方法只有一个无参数

3.除了继承自Vacton类的方法外还有特殊的方法

push(E e)将某一个元素压入栈顶(add())

E = pop()将某一个元素从栈顶取出并删掉(E = remove())

E = peek()查看栈顶的一个元素 不删除(get())

boolean = empty()判断栈内元素是否为空(isEmpty())

int = search()查找给定的元素在栈中的位置 不是索引 是第几个

没有size方法

4.中国象棋 悔棋

栈中存储每一次操作的步骤

撤销功能

Queue接口

队列

1.java.util 通常子类LinkedList ArrayDeque

2.通常无参数构造方法创建

Queue<Integer> queue=new LinkedList<>() ;

3.一般方法

add()

element()//相当于get() 一般不会用element这个方法

remove()

用下面三个不会抛出异常

boolean = offer(E e);//相当于add

E = peek();// 无参数 相当于 element方法 取出第一个

E = poll();剪短// 无参数 相当于remove() 删除第一个

size()

isEmpty()

4.双十一零点秒杀

所有进入秒杀系统的人存入队列

Set集合

Collection

以value形式存在

Set 无序无重复

1.具体的实现类 HashSet TreeSet

2.基本的使用

3.无序 无重复

无序：我们使用集合存放元素的顺序 集合内取出来的顺序不一致 集合本身是有自己的算法排布顺序 hash算法

HashSet---->(HashMap (数组+链表) 散列表 临接连表)

1.java.util

2.如何创建对象 无参数 有参数

3.集合容器的基本使用

增删查

boolean = add(value) addAll(collection c) retainAll removeAll

boolean = remove(Object)

没有修改方法 可以使用增强for循环遍历集合

iterator() 获取一个迭代器对象Iterator<(跟HashSet一样的类型)> it=hashset.iterator(); while(it.hasNext()){ //it.hasNext()用来判断下一个位置是否有元素

String value=it.next();

System.out.println(value); }//相当于遍历元素 size()

4.无重复的原则

首先通过String类型和Person类型存储

大概猜测 无重复的原则 利用equals方法进行比较

如果我们想要让Person对象的name一致认为是同一个对象

我们可以重写equals方法

重写了equals方法 发现还没有产生无重复的效果

证明可能原则不止equals一个方法这么简单

还有另一个规则同时起着作用 hashCode方法 int

五个Person对象只剩一个 第一次存储的 还是最后一次存储

set集合是发现重复的元素 拒绝存入 存储的是第一个

 public boolean equals(Object obj){
      if (this==obj){
          return true;
      }
      if (obj instanceof Person){
          Person ano=(Person)obj;
          if (ano.name.equals(this.name)){
              return true;
          }
      }
      return false;
  }

public int hashCode(){
      return this.name.hashCode();
}

TreeSet-----(TreeMap 二叉树 利用Node(left item right))

无序无重复 java.util

无参数构造方法 带Collection构造方法

基本常用方法 add(E e) iterator() remove(E e) 没有修改 size()

无重复的规则是如何实现的

treeSet集合本身有顺序 我们指的无序存入的和取出来的不一致

compareTo---->String类 按照字母的自然顺序排布(Unicode)

如果想要把自己写的类型 比如Person对象存入TreeSet集合里

不能随意的存储 需要让自己写的类先实现Comparable接口

总结：

set 特点 无序无重复

无序: 添加的顺序 获取的顺序不一致 (不是集合本身是否有序 Tree自然有序)

无重复: 添加的元素不能一致 (如果出现重复元素 只存第一个 不再存入)

HashSet底层实现是HashMap--->数据存储结构 散列表)

TreeSet底层实现是TreeMap--->数据存储结构 二叉树)

set集合的无重复特性

HashSet 无重复原则有两个方法同时起作用

equals hashCode

默认比较的是两个对象的地址

若第二个对象地址与之前的一致 不再存入

如果想要改变其比较的规则 可以重写上述两个方法

TreeSet 无重复原则有一个方法起作用

compareTo

上述这个方法不是每一个对象都有的

若想要将某一个对象存入TreeSet集合中 需要让对象所属的类实现接口Comparable

实现接口后将compareTo方法重写 返回值int 负数靠前排布 正数排列靠后

如果没有实现这个接口但进行比较，就会抛出异常ClassCastException造型异常

public int compareTo(Person o) {
    return this.name.compareTo(o.name);
}

//如果有两个参数及以上
public int compareTo(Person o) {
   int value= this.name.compareTo(o.name);
   if (value!=0){
       return value;
   }
    return this.age-o.age;//age是int类型 所以可以直接进行运算
}

Map集合

Map 映射 通过某一个key可以直接定位到一个value值

存储的方式以 键值对 存储 key-value

key无序无重复 value无序可重复

key无序还是一样，指的是存入顺序与取得顺序不一致

key无重复当然指的是 元素不能一致

HashMap

1.包 java.util

2.如何创建对象 HashMap() HashMap(int initialCapacity)

3.基本方法

增删改查

增put(key,value) 存放一组映射关系 key-value

1.key存储的顺序与取得顺序不同

2.不同的key可以存储相同的value

3.key若有相同的 则将 原有的value覆盖而不是拒绝存入(跟set刚好相反)

删E = remove(key);

改put(key,value1) put(key,value2) 在新增一个就覆盖之前那个相当于修改

replace(key,newValue)

查E = get(key) //key存在返回value,key不在返回的是null

遍历map集合? key不一定什么样

获取到所有的key 遍历key 通过key获取value

Set<Integer> keys=hashmap.keySet();//获取map集合的全部keys
Iterator<Integer> it=keys.iterator();//通过迭代器遍历keys
while(it.hasNext()){ 
    Integer key=it.next();
    String value=hashmap.get(key);
}		

Set<Key> = keySet()获取全部的key //返回结果是Set

Set<Entry> = entrySet(); //获取全部的Entry(Node)对象 返回结果是Set

Set<Map.Entry<Integer,String>> keys=hashmap.entrySet();//
Iterator<Map.Entry<Integer,String>>  it=keys.iterator();//
while(it.hasNext()){ 
    Map.Entry<Integer,String> entry=it.next();
    Integer key=entry.getKey();
    String value=entry.getValue();
    System.out.println(key+"---"+value);
}	//不写Map.就需要导包 java.util.Map.Entry

 size();

4.除了上述几个常用的方法外 其他API中提供的方法

clear containsKey(key) containsValue(value)

getOrDefault(key,defaultValue);如果key存在就返回对应的value 若没有找到则返回给defaultValue的值

isEmpty()

putAll(map)

putIfAbsent(key,value);//如果key不存在才向集合内添加 如果key存在就不添加啦

无重复原则

若想要将某一个对象存入HashMap集合中 需要让对象所属的类重写toString和hashCode

一般在重写toString时还要重写一个hashCode

5.map集合在什么情形下用?

1.想要存储一组元素

数组 or 集合 如果存储的元素以后长度不变用数组 如果长度以后不确定 用集合

2.如果发现长度以后不确定--->集合

List Set Map

List家族有序的 存储有顺序用这个

ArrayList(Vector) 更适合遍历轮询

LinkedList 更适合插入和删除

Stack LIFO后进先出

Set家族无重复 存储元素希望自动去掉重复元素用这个

HashSet 性能更高

TreeSet 希望存进去的元素自动去重复 同时还能自动排序

Map家族k-v 通过唯一的k快速找寻v用这个

HashMap 性能更高

TreeMap 希望存进去的元素key自动排序

6.登录小流程

能体会每一个不同集合的特点

7.HashMap底层的数据结构存储

散列表的形式 数组+链表

Person对象存入HashMap中? 可以

hashCode方法---->不同的对象 可以产生相同的hashCode码的

如果发现code码一致就会在当前数组后面后面串一个Node

不同的hashCode码-->不同的对象

TreeMap

TreeMap 自然有序 按照Unicode编码自然有序

map集合中的key需要可比较的 key的对象需要实现Comparable接口

1.java.util包

2.构造方法

无参数 带map参数

3.常用方法

put get remove replace size

4.底层数据结构的存储

1.8红黑二叉树