Java—Collection，List，泛型，数据结构

1.集合概述

ArratList

LinkList

HashSet

LinkedHashSet

HashMap

LinkedHashMap

以上集合类的基本功能都是一样的，存储和管理大量对象引用。

每个集合类采用的不同的数据结构存储元素，不同的数据结构直接导致对集合操作（增删改查）的性能不一样。

ArrayList内部采用的是数组存储元素，增删慢，查询快。

常见数据结构：数组，栈，队列，树，哈希表，链表……

Java 集合体系图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1qIKVr0p-1577022526586)(d:\Users\Administrator\Desktop\，。.png)]

Collection接口中的方法：

增： public boolean add(E e);//把给定的对象添加到当前集合中。
删： public boolean remover(E e);//把给定的对象在当前集合中删除
    //删除时，使用的是equelse方法，比较内容，自创的引用类型需要重写equelse方法。
    //只删除匹配的第一个
    public void clear();//清空集合
改： [无]
查:  public boolean contains(object obj);判断当前集合中是否有包含给定的对象
     public boolean isEmpty();//判断当前集合是否为空 ，是空返回true
     public int size();//返回集合中元素个数。
示例：
	package com.day05.迭代器;

import java.util.ArrayList;
import java.util.Collection;

public class Test {
    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();//多态方式创建，Conllection是接口
        //增
        list.add("北");
        list.add("京");
        list.add("欢");
        list.add("迎");
        System.out.println(list.add("你"));//true
        //查
        System.out.println(list.contains("你"));//true
        System.out.println(list.isEmpty());//false
        //删
        System.out.println(list.remove("你"));//true
        System.out.println(list);//[北, 京, 欢, 迎]
        //清空
        list.clear();
        System.out.println(list);//[]
        
        Object[] object = list.toArray();//把集合中的元素，存储到数组中

    }

}

迭代器

对集合经常要进行便利操作，为此java专门推出来一个借口Iterator，专门对集合进行遍历。

迭代器Iterator接口的使用

1.使用步骤

1）获取迭代器

	调用Collection接口的的Iterator<E> iterator(),返回的是一个Iterator的实现类，返回在此collection的元素上进行迭代的迭代器。
2）调用方法
public E next（）；返回迭代的下一个元素。
public boolean hasNext（）；如果仍有元素可以迭代，返回true。
一个迭代器，只可以对一个数组执行一次操作，因为迭代器是从上到下迭代的，不可以倒着迭代。
package demo02_迭代器;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Test {

    public static void main(String[] args) {
        //多态
        Collection<String> list = new ArrayList<>();
        /**
         * public boolean add(E e) ： 把给定的对象添加到当前集合中 。
         * 对应ArrayList添加元素返回的都是true
         * 对HashSet当添加重复元素时返回的时false
         */
        list.add("风清扬");
        list.add("令狐冲");
        list.add("田伯光");
        list.add("岳不群");
        /**
         * 1)获取迭代器
         * 调用Collecton接口中的Iterator<E> iterator()，返回的时一个Iterator的实现类。
         * 返回在此 collection 的元素上进行迭代的迭代器。
         * 2)调用方法
         * public boolean hasNext() :如果仍有元素可以迭代，则返回 true。
         * public E next() :返回迭代的下一个元素。
         */
        Iterator<String> it = list.iterator();

//        System.out.println(it.hasNext());
//        System.out.println(it.next());
//
//        System.out.println(it.hasNext());
//        System.out.println(it.next());
//
//        System.out.println(it.hasNext());
//        System.out.println(it.next());
//
//        System.out.println(it.hasNext());
//        System.out.println(it.next());
//
//        System.out.println(it.hasNext());
//        System.out.println(it.next());//NoSuchElementException
        while (it.hasNext()){
            System.out.println(it.next());
        }

    }
}

迭代器的常见问题

1.一次hashNext（），多次next（）；

package demo03_迭代器_常见问题;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class Test {
    public static void main(String[] args) {
        //多态
        Collection<String> list = new ArrayList<>();
        list.add("风清扬");
        list.add("令狐冲");
        list.add("田伯光");
*//       
list.add("岳不群");
        //迭代器*
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String s = it.next();
            System.out.println(it.next());//相当于调用了两次这个方法，会跳跃着打印
        }
    }
}



2.并发修改异常
package demo04_迭代器_常见问题二;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class Test {

    public static void main(String[] args) {
        //多态
        Collection<String> list = new ArrayList<>();
        list.add("风清扬");
        list.add("令狐冲");
        list.add("田伯光");
        list.add("岳不群");

        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String s = it.next();
            if("岳不群".equals(s)){
//                list.remove(s);//ConcurrentModificationException
                it.remove();//在使用迭代器进行集合遍历的同时想删除集合元素 一定要使用迭代器提供删除方法
            }
            System.out.println(s);
        }
        System.out.println(list);
    }
}

增强for循环，foreach ，专门用来遍历集合和数组。

for（数据类型  变量名 ：数组或者集合名）{

}
    对于引用类型，增强for，编译后就是迭代器进行遍历集合，在删除时不能够使用集合提供的删除方法，要是用迭代器的，否则集合长度发生变化，会报错。
    对于基本类型，编译后就是普通的for循环

泛型

1.好处，提高集合的安全性。如果不依靠泛型强制规定集合之中存储的元素的类型，集合可以存储任意类型。不利于管理。

泛型类

package com.day05.泛型.Test;
class a<T,B>{//可多个
    public void shou(T t,B b){}
}
public class Test {
    public static void main(String[] args) {
        a<String,Integer> My = new a<>();//创建对象时候，设置的数据类型
        My.shou("123",1);
    }
    
    
}

泛型方法

package com.day05.泛型.Test;

public class FanXing {
    public static void main(String[] args) {
        //调用时候，设置统一的类型
        FanXing.<String,String,String>fun("1","2","3");
    }
    //定义一个方法，要求可以接受任意三个类型的参数类型
    //但是在调用时候，三个参数类型一致
    private static <T,B,C> void fun(T t,B b,C c){//可多ge 
    }
    
}

泛型接口

package com.day05.泛型.Test;
interface A<T>{
    public abstract  void show(T t);
}
public class Demo implements A<Integer> {
    public static void main(String[] args) {
        
    }

    @Override
    public void show(Integer integer) {
        show(1);
    }
}