java入门详细教程之集合的理解与应用

一、Collenction集合

数组和集合的区别

长度

数组的长度是不可变的,集合的长度是可变的
数据类型

数组可以存基本数据类型和引用数据类型

集合只能存引用数据类型,如果要存基本数据类型,需要存对应的包装类

Collection 集合概述和使用

Collection集合概述：
- 是单例集合的顶层接口，表示一组对象，这些对象也称为Collection的元素
- JDK不提供此接口的任何之间实现，它提供更具体的子接口如（Set和List）实现
创建Collection集合的对象
- 多态的方式
- 具体的实现类ArrayList
Collection集合常用方法

Collection集合的遍历

迭代器介绍
- 迭代器，集合的专用遍历方式
  - iterator iterator():返回此结婚中元素的迭代器，通过集合对象的iterator（）方法得到
iterator总的常用方法
- boolean hasNext()：判断下一个位置是否有元素可以被取出来，如果有则返回true，否则返回false
- E netx（）：指针下移，将下移后的位置上的元素返回
Collection集合的遍历

public class IteratorDemo1 {
    public static void main(String[] args) {
        //创建集合对象
        Collection<String> c = new ArrayList<>();

        //添加元素
        c.add("hello");
        c.add("world");
        c.add("java");
        c.add("javaee");

        //Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到
        Iterator<String> it = c.iterator();

        //用while循环改进元素的判断和获取
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }
    }
}

迭代器遍历的原理

当通过Collection集合，调用iterator()方法获取迭代器对象后，迭代器默认指向集合的0索引元素前面，然后通过hasNext()方法来判断当前指向的下一个位置是否存在元素，如果存在元素则通过next()方法移动到下一个索引位置，并将移动后位置上的元素返回。
迭代器中删除的方法

void remove(): 删除迭代器对象当前指向的元素，能够删除相邻的重复元素。

remove()只能在每次调用next()后调用一次。

public class IteratorDemo2 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("b");
        list.add("c");
        list.add("d");

        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String s = it.next();
            if("b".equals(s)){
                //指向谁,那么此时就删除谁.
                it.remove();
            }
        }
        System.out.println(list);
    }
}

增强for循环

介绍
- 它是JDK5之后出现的,其内部原理是一个Iterator迭代器
- 实现Iterable接口的类才可以使用迭代器和增强for
- 简化数组和Collection集合的遍历
格式

for(集合/数组中元素的数据类型变量名 : 集合/数组名) {

// 已经将当前遍历到的元素封装到变量中了,直接使用变量即可

}
代码

public class MyCollectonDemo1 {
    public static void main(String[] args) {
        ArrayList<String> list =  new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");
        list.add("f");

        //1,数据类型一定是集合或者数组中元素的类型
        //2,str仅仅是一个变量名而已,在循环的过程中,依次表示集合或者数组中的每一个元素
        //3,list就是要遍历的集合或者数组
        for(String str : list){
            System.out.println(str);
        }
    }
}

注意点

增强for遍历的过程中 str相当于是一个第三方变量，第三方变量的修改不影响集合元素的值。
集合三种遍历方式的选择

fori：当要使用索引的时候，使用普通for循环

增强for：当只需要对集合进行遍历时，使用增强for

iterator：当要对集合中元素进行删除时，使用迭代器

二、List集合

List集合的概述和特点

List集合的概述
- 有序集合,这里的有序指的是存取顺序
- 用户可以精确控制列表中每个元素的插入位置,用户可以通过整数索引访问元素,并搜索列表中的元素
- 与Set集合不同,列表通常允许重复的元素
List集合的特点
- 存取有序
- 可以重复
- 有索引

List集合的特有方法

public class MyListDemo2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        method1(list);
        method2(list);
        method3(list);
        method4(list);
    }

    private static void method4(List<String> list) {
        //E get(int index)    返回指定索引处的元素
        String s = list.get(0);
        System.out.println(s);
    }

    private static void method3(List<String> list) {
        //E set(int index,E element)  修改指定索引处的元素，返回被修改的元素
        //被替换的那个元素,在集合中就不存在了.
        String result = list.set(0, "qqq");
        System.out.println(result);
        System.out.println(list);
    }

    private static void method2(List<String> list) {
        //E remove(int index)    删除指定索引处的元素，返回被删除的元素
        //在List集合中有两个删除的方法
        //第一个 删除指定的元素,返回值表示当前元素是否删除成功
        //第二个 删除指定索引的元素,返回值表示实际删除的元素
        String s = list.remove(0);
        System.out.println(s);
        System.out.println(list);
    }

    private static void method1(List<String> list) {
        //void add(int index,E element)  在此集合中的指定位置插入指定的元素
        //原来位置上的元素往后挪一个索引.
        list.add(0,"qqq");
        System.out.println(list);
    }
}

三、数据结构

数据结构之栈和队列

栈结构

先进后出
队列结构

先进先出

数据结构之数组和链表

数组结构

查询快、增删慢
队列结构

查询慢、增删快

ArrayList源码分析

四、List集合实现类

集合子类的特点

ArrayList集合

底层是数组结构实现，查询快、增删慢
LinkedList集合

底层是链表结构实现，查询慢、增删快

LinkedList集合的特有功能

public class MyLinkedListDemo4 {
    public static void main(String[] args) {
        LinkedList<String> list = new LinkedList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
//        public void addFirst(E e)	在该列表开头插入指定的元素
        //method1(list);

//        public void addLast(E e)	将指定的元素追加到此列表的末尾
        //method2(list);

//        public E getFirst()		返回此列表中的第一个元素
//        public E getLast()		返回此列表中的最后一个元素
        //method3(list);

//        public E removeFirst()		从此列表中删除并返回第一个元素
//        public E removeLast()		从此列表中删除并返回最后一个元素
        //method4(list);
      
    }

    private static void method4(LinkedList<String> list) {
        String first = list.removeFirst();
        System.out.println(first);

        String last = list.removeLast();
        System.out.println(last);

        System.out.println(list);
    }

    private static void method3(LinkedList<String> list) {
        String first = list.getFirst();
        String last = list.getLast();
        System.out.println(first);
        System.out.println(last);
    }

    private static void method2(LinkedList<String> list) {
        list.addLast("www");
        System.out.println(list);
    }

    private static void method1(LinkedList<String> list) {
        list.addFirst("qqq");
        System.out.println(list);
    }
}

LinkedList源码分析

五、泛型

泛型概述【理解】

泛型的介绍

泛型是JDK5中引入的特性，它提供了编译时类型安全检测机制
泛型的好处
1. 把运行时期的问题提前到了编译期间
2. 避免了强制类型转换
示例代码

public static void main(String[] args) {
    ArrayList list = new ArrayList();
    list.add("aaa");
    list.add("bbb");
    list.add("ccc");
    list.add(123);

    Iterator it = list.iterator();
    while(it.hasNext()){
        String next = (String) it.next();
        int len = next.length();
        System.out.println(len);
    }
}

泛型的定义格式

<类型>: 指定一种类型的格式.尖括号里面可以任意书写,一般只写一个字母.例如: <E> <T>
<类型1,类型2…>: 指定多种类型的格式,多种类型之间用逗号隔开.例如: <E,T> <K,V>

泛型类【应用】

定义格式

修饰符 class 类名<类型> {  }

public class Generic<T> {
    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

public class GenericDemo1 {
    public static void main(String[] args) {
        Generic<String> g1 = new Generic<String>();
        g1.setT("杨幂");
        System.out.println(g1.getT());

        Generic<Integer> g2 = new Generic<Integer>();
        g2.setT(30);
        System.out.println(g2.getT());

        Generic<Boolean> g3 = new Generic<Boolean>();
        g3.setT(true);
        System.out.println(g3.getT());
    }
}

泛型方法【应用】

定义格式

修饰符 <类型> 返回值类型 方法名(类型 变量名) {  }

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

public class GenericDemo2 {
    public static void main(String[] args) {
	    Generic g = new Generic();
        g.show("柳岩");
        g.show(30);
        g.show(true);
        g.show(12.34);
    }
}

泛型接口【应用】

定义格式

修饰符 interface 接口名<类型> {  }

泛型接口实现类1

定义实现类时,定义和接口相同泛型,创建实现类对象时明确泛型的具体类型

public class GenericImpl1<T> implements Generic<T> {
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

泛型接口实现类2

定义实现类时,直接明确泛型的具体类型

public class GenericImpl2 implements Generic<Integer>{
     @Override
     public void show(Integer t) {
          System.out.println(t);
     }
}

类型通配符

类型通配符: <?>
- ArrayList<?>: 表示元素类型未知的ArrayList,它的元素可以匹配任何的类型
- 但是并不能把元素添加到ArrayList中了,获取出来的也是父类类型
类型通配符上限: <? extends 类型>
- ArrayListList <? extends Number>: 它表示的类型是Number或者其子类型
类型通配符下限: <? super 类型>
- ArrayListList <? super Number>: 它表示的类型是Number或者其父类型
泛型通配符的使用

public class GenericDemo4 {
    public static void main(String[] args) {
        ArrayList<Integer> list1 = new ArrayList<>();
        ArrayList<String> list2 = new ArrayList<>();
        ArrayList<Number> list3 = new ArrayList<>();
        ArrayList<Object> list4 = new ArrayList<>();

        method(list1);
        method(list2);
        method(list3);
        method(list4);

        getElement1(list1);
        getElement1(list2);//报错
        getElement1(list3);
        getElement1(list4);//报错

        getElement2(list1);//报错
        getElement2(list2);//报错
        getElement2(list3);
        getElement2(list4);
    }
  
    // 泛型通配符: 此时的泛型?,可以是任意类型
    public static void method(ArrayList<?> list){}
    // 泛型的上限: 此时的泛型?,必须是Number类型或者Number类型的子类
    public static void getElement1(ArrayList<? extends Number> list){}
    // 泛型的下限: 此时的泛型?,必须是Number类型或者Number类型的父类
    public static void getElement2(ArrayList<? super Number> list){}

}