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<? extends E> 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 -> Objectfor(int i=0;i<arr.length;i++){String s = (String)arr[i];System.out.println(s);}}

terator 迭代器

迭代器的介绍

专门为集合提供遍历的一种技术

迭代器的怎么使用

 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; i<arr.length;i++){String s = (String)arr[i];System.out.println(arr[i]);}//迭代器Iterator iterator = list.iterator();while (iterator.hasNext()){System.out.println(iterator.next());}//列表迭代器ListIterator listIterator = list.listIterator();while (listIterator.hasNext()){System.out.println(listIterator.next());}//size  get()for(int i=0; i<list.size();i++){String s = (String)list.get(i);System.out.println(arr[i]);}

Vector类特有方法

addElement(E obj)

将指定的组件添加到此向量的末尾，将其大小增加1。

elementAt(int index) 返回指定索引处的组件。

elements() 返回此向量的组件的枚举。

firstElement() 返回此向量的第一个组件（索引号为 0的项目）。

JDK升级原因：

效率
简化书写
安全

/** Vector类特有的方法* addElement(E obj) 将指定的组件添加到此向量的末尾，将其大小增加1。   add()elementAt(int index)返回指定索引处的组件。   get()elements() 返回此向量的组件的枚举。           iteratorhasMoreElements()                    hasNext()nextElement()                         next()firstElement() 返回此向量的第一个组件（索引号为 0的项目）。* */Vector vector = new Vector();vector.addElement("hello");vector.addElement("world");vector.addElement("java");//        for(int i=0;i<vector.size();i++){
//            System.out.println(vector.elementAt(i));
//        }
//        System.out.println(vector.firstElement());Enumeration enumeration = vector.elements();while (enumeration.hasMoreElements()){System.out.println(enumeration.nextElement());}

LinkedList类特有的方法

addFirst(E e) 在该列表开头插入指定的元素。

addLast(E e) 将指定的元素追加到此列表的末尾。

泛型

泛型：是一种把类型明确的工作推迟到创建对象或者调用方法的时候，才去明确的特殊类型，参数化类型，把类型当做参数一样进行传递

格式：

＜数据类型＞

此处数据类型只能是引用类型

好处：

1. 把运行时报的错误，提前到了编译期间
1. 避免了强制转换
1. 优化程序的设计，解决了黄色警告线

泛型的应用：

类上定义泛型

public class ObjectTool<T> {private T obj;public T getObj() {return obj;}public void setObj(T obj) {this.obj = obj;}
}

方法上定义泛型

在方法中定义泛型，相当于可以传任意类型的参数

  public <T> void show(T t){System.out.println(t);}

接口上定义泛型

方法1

 class MyListImpl implements MyList<T>{@Overridepublic void show(String s) {}
}

方法2

 class MyListImpl<T> implements MyList<T>{@Overridepublic void show(T s) {}
}

泛型通配符

<?> : 任意类型

<? extends E> : 向下限定， E及子类

<? supter 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<String> 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<E,Object> 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<K,V>[] tab; Node<K,V> 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<K,V> 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<K,V>)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 1sttreeifyBin(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 keyV 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<String> hs = new LinkedHashSet<String>();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<Integer> treeSet = new TreeSet<Integer>();treeSet.add(66);treeSet.add(18);treeSet.add(12);treeSet.add(66);treeSet.add(77);for(Integer integer: treeSet){System.out.println(integer);}}