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 -> Object
        for(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() 返回此向量的组件的枚举。           iterator
                 hasMoreElements()                    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>{
    @Override
    public void show(String s) {
        
    }
}

方法2

 class MyListImpl<T> implements MyList<T>{
    @Override
    public 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 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<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);
        }
    }