Java全栈基础篇--集合
集合
集合：集合是java中提供的一种容器，可以用来存储多个数据。
特点： 长度不固定，还可以存储不同的数据（但是一般都用同一类型）
集合和数组既然都是容器，它们有啥区别呢？
-
数组的长度是固定的。集合的长度是可变的。
-
数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候，使用集合进行存储。
集合的体系
Collection 常用的方法
基本功能
-
public boolean add(E e)： 把给定的对象添加到当前集合中 。 -
public void clear():清空集合中所有的元素。 -
public boolean remove(E e): 把给定的对象在当前集合中删除。 -
public boolean contains(E e): 判断当前集合中是否包含给定的对象。 -
public boolean isEmpty(): 判断当前集合是否为空。 -
public int size(): 返回集合中元素的个数。 -
public Object[] toArray(): 把集合中的元素，存储到数组中。
高级功能
boolean addAll(Collection c) 添加一个集合到当前集合 boolean removeAll(Collection c) 移除一个集合元素
boolean retainAll(Collection c) 两个集合都有的元素，思考元素去哪里?boolean又是什么意思? boolean containsAll(Collection c) 判断当前集合是否包含指定集合的元素 一个还是所有?
集合的遍历
public static void main(String[] args) {
Collection c = new ArrayList();
c.add("hello");
c.add("java");
c.add("collection");
//遍历集合
Object[] arr = c.toArray();
//String -> Object
for(int i=0;iterator 迭代器
迭代器的介绍
专门为集合提供遍历的一种技术
迭代器的怎么使用
Collection c = new ArrayList();
Student student = new Student("张三",18);
Student student2 = new Student("李四",28);
Student student3 = new Student("王老吉",38);
c.add(student);
c.add(student2);
c.add(student3);
Iterator iterator = c.iterator();
while (iterator.hasNext()){
Student s = (Student) iterator.next();
System.out.println(s);
}迭代器的原理
数据结构
数据结构的有什么用?
数据结构：研究数据的存储
现实世界的存储，我们使用的工具和建模。每种数据结构有自己的优点和缺点，想想如果Google的数据用的是数组的存储，我们还能方便地查询到所需要的数据吗？而算法，在这么多的数据中如何做到最快的插入，查找，删除，也是在追求更快。
我们java是面向对象的语言，就好似自动档轿车，C语言好似手动档吉普。数据结构呢？是变速箱的工作原理。你完全可以不知道变速箱怎样工作，就把自动档的车子从 A点 开到 B点，而且未必就比懂得的人慢。写程序这件事，和开车一样，经验可以起到很大作用，但如果你不知道底层是怎么工作的，就永远只能开车，既不会修车，也不能造车。当然了，数据结构内容比较多，细细的学起来也是相对费功夫的，不可能达到一蹴而就。我们将常见的数据结构：堆栈、队列、数组、链表和红黑树 这几种给大家介绍一下，作为数据结构的入门，了解一下它们的特点即可。
常见的数据结构
数据存储的常用结构有：栈、队列、数组、链表和红黑树。我们分别来了解一下：
栈，队列
数组与链表
数组： 利于查询 ，不利于增删改
链表：不利于查询 ，利于增删改
（根据需求，选择对应的数据形式，进行存储）
List 接口的方法
void add(int index, E element)
Object get(int index)
ListIterator listIterator() 返回列表中的列表迭代器（按适当的顺序）。
Object set(int index, E element)
用指定的元素（可选操作）替换此列表中指定位置的元素。
ListIterator listIterator() ： 此方法重要；不但可以正向还可以反向，还可以进行添加和修改
ConcurrentModificationException 并发修改异常
在迭代器在迭代元素时，用集合去操作，出现上现的异常
解决方法是：
迭代器在进行迭代元素时，就用迭代器去修改（包括添加）
集合遍历元素时，就用集合去修改
List 子类特点
ArrayList类
底层数组 ： 查询快，增删改慢
线程不安全： 不安全，效率高
Vecktor类
底层数组 ： 查询快，增删改慢
线程安全： 安全，效率低
LinkedList类
底层链表 ： 查询慢，增删改快
线程不安全： 不安全，效率高
AarryList的方法使用
四种遍历
ArrayList list = new ArrayList();
list.add("hello");
list.add("world");
list.add("java");
//数组
Object[] arr = list.toArray();
for(int i=0; iVector类特有方法
addElement(E obj)
将指定的组件添加到此向量的末尾，将其大小增加1。
elementAt(int index) 返回指定索引处的组件。
elements() 返回此向量的组件的枚举。
firstElement() 返回此向量的第一个组件（索引号为 0的项目）。
JDK升级原因：
-
效率
-
简化书写
-
安全
/*
* Vector类特有的方法
* addElement(E obj) 将指定的组件添加到此向量的末尾，将其大小增加1。 add()
elementAt(int index)返回指定索引处的组件。 get()
elements() 返回此向量的组件的枚举。 iterator
hasMoreElements() hasNext()
nextElement() next()
firstElement() 返回此向量的第一个组件（索引号为 0的项目）。
* */
Vector vector = new Vector();
vector.addElement("hello");
vector.addElement("world");
vector.addElement("java");
// for(int i=0;iLinkedList类特有的方法
addFirst(E e) 在该列表开头插入指定的元素。
addLast(E e) 将指定的元素追加到此列表的末尾。
泛型
泛型： 是一种把类型明确的工作推迟到创建对象或者调用方法的时候，才去明确的特殊类型， 参数化类型，把类型当做参数一样进行传递
格式：
＜数据类型＞
此处数据类型只能是引用类型
好处：
1. 把运行时报的错误，提前到了编译期间
1. 避免了强制转换
1. 优化程序的设计，解决了黄色警告线
泛型的应用：
-
类上定义泛型
public class ObjectTool {
private T obj;
public T getObj() {
return obj;
}
public void setObj(T obj) {
this.obj = obj;
}
} 方法上定义泛型
在方法中定义泛型，相当于可以传任意类型的参数
public void show(T t){
System.out.println(t);
} -
接口上定义泛型
方法1
class MyListImpl implements MyList{
@Override
public void show(String s) {
}
} 方法2
class MyListImpl implements MyList{
@Override
public void show(T s) {
}
} 泛型通配符
: 任意类型
: 向下限定 ， E及子类
: 向上限定 ， E及父类
增加for遍历集合
语法：
for(数据类型 变量名: 数组名或集合){
}
集合遍历 ，推荐使用增加for
静态导入
注意事项：1. 方法必须是静态
2. 注意不要和本类的方法同名，如果同名，记得加前缀，由此可见，静态导入的方式，意义不太
import static java.lang.Math.abs;
import static java.lang.Math.max;
public static void main(String[] args) {
System.out.println(abs(-100));
System.out.println(java.lang.Math.max(100,200));
}可变参数
可变参数：定义时方法时不知道参数具体个数，可以使用此技术
格式：
修饰符 返回值 类型 方法名（数据类型... 参数名）{
}
// ... 表示是可变参数
注意事项
-
可以了可变参数，此变量相当于是一个数组
-
如果方法里有多个参数，其它包含可变参数，那可变参数必须放在最后
数组转集合
Arrays.asList 此方法可以将数组转集合，但是本质还是数组，所以不能操作集合改变数组大小的方法
List list = Arrays.asList("hello","world","java");
System.out.println(list);
System.out.println(list.get(0));
//UnsupportedOperationException
//list.add("java ee");
list.set(1,"hahaha");
for(String str:list){
System.out.println(str);
} Set 接口
特点： 不包含重复的元素，无序（指的是存数据 ，和取数据的顺序是否一致）
HashSet子类
无序，唯一性
HashSet 如何实现唯一性(看源码)
HashSet 的底层是使用的HashMap
根据源码分析，得到要保证HashSet里的元素的唯一性，涉及到了Hash值 和equals方法
interface Collection{
....
}
interface Set extends Collection{
...
}
class HashSet implements Set{
// Collection 就相当于单身， Map 一对夫妻
private transient HashMap map;
public HashSet() {
map = new HashMap<>();
}
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
}
class HashMap implements Map{
final float loadFactor;
static final float DEFAULT_LOAD_FACTOR = 0.75f;
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node[] tab; Node p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
} 自定义对象，使用HashSet; 如果想实现当所有属性相同时，认为是重复，不添加；
需要重写hashcode 和 equals
去重原理
HashSet 的底层是HashMap, hashMap的底层是哈希表（数组和链表的结合）
LinkedHashSet 子类
底层数据结构：哈希表+链表
保证了唯一性，
链表保存有序（存储和取出是一致）
LinkedHashSet hs = new LinkedHashSet();
hs.add("hello");
hs.add("world");
hs.add("java");
hs.add("hello");
for(String str :hs){
System.out.println(str);
} TreeSet 子类
特点：排序 和唯一
排序 ： 自然排序（就是升序）和比较器排序
public static void main(String[] args) {
TreeSet treeSet = new TreeSet();
treeSet.add(66);
treeSet.add(18);
treeSet.add(12);
treeSet.add(66);
treeSet.add(77);
for(Integer integer: treeSet){
System.out.println(integer);
}
} Map体系
概述
现实生活中，我们常会看到这样的一种集合：IP地址与主机名，身份证号与个人，系统用户名与系统用户对象等，这种一一对应的关系，就叫做映射。Java提供了专门的集合类用来存放这种对象关系的对象，即java.util.Map接口。
我们通过查看Map接口描述，发现Map接口下的集合与Collection接口下的集合，它们存储数据的形式不同，如下图。
-
Collection中的集合，元素是孤立存在的（理解为单身），向集合中存储元素采用一个个元素的方式存储。 -
Map中的集合，元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成，通过键可以找对所对应的值。 -
Collection中的集合称为单列集合，Map中的集合称为双列集合。 -
需要注意的是，
Map中的集合不能包含重复的键，值可以重复；每个键只能对应一个值。
Map接口中的常用方法
-
public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。 -
public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。 -
public V get(Object key)根据指定的键，在Map集合中获取对应的值。 -
boolean containsKey(Object key)判断集合中是否包含指定的键。 -
public Set: 获取Map集合中所有的键，存储到Set集合中。keySet() -
public Set: 获取到Map集合中所有的键值对对象的集合(Set集合)。