黑马程序员技术交流社区

标题: 【黑马程序员杭州】JavaEE课程笔记day17-集合 [打印本页]

作者: 小江哥 时间: 2018-1-9 14:30
标题: 【黑马程序员杭州】JavaEE课程笔记day17-集合
本帖最后由小江哥于 2018-1-9 14:34 编辑

今日内容介绍

u 集合&迭代器

u 增强for & 泛型

u 常见数据结构

u List子体系

第1章  集合&迭代器
1.1  集合体系结构
1.1.1    集合体系图

在最顶层的父接口Collection中一定定义了所有子类集合的共同属性和方法,因此我们首先需要学习Collection中共性方法,然后再去针对每个子类集合学习它的特有方法

1.1.2 案例代码一:

[Java] 纯文本查看 复制代码

 package com.itheima_01;

 

import java.util.ArrayList;

 

/*

 *  ArrayList

 *  集合的体系结构：

 *  由于不同的数据结构（数据的组织，存储方式），所以Java为我们提供了不同的集合，

 *  但是不同的集合他们的功能都是相似，不断的向上提取，将共性抽取出来，这就是集合体系结构形成的原因

 * 

 *  体系结构：

 *      怎么学习?最顶层开始学习，因为最顶层包含了所有的共性

 *      怎么使用？使用最底层，因为最底层就是具体的实现

 * 

 *  Collection

 *  List

 *  ArrayList

 */

public class CollectionDemo {

    public static void main(String[] args) {      

        //创建集合对象

        ArrayList al = new ArrayList();

        //添加元素

        al.add("hello");

        al.add("world");

        al.add("java");

        //遍历集合

        for(int x = 0;x < al.size();x++) {

            System.out.println(al.get(x));

        }

       

    }

}

1.2 Collection中的常用功能

boolean add(Object e): 向集合中添加元素

void clear():清空集合中所有元素

boolean contains(Object o):判断集合中是否包含某个元素

boolean isEmpty():判断集合中的元素是否为空

boolean remove(Object o):根据元素的内容来删除某个元素

int size():获取集合的长度

Object[] toArray():能够将集合转换成数组并把集合中的元素存储到数组中

1.2.1 案例代码二:

[Java] 纯文本查看 复制代码

package com.itheima_01;

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

/*
* Collection
*       boolean add(E e)
*       void clear()
*       boolean contains(Object o)
*       boolean isEmpty()
*       boolean remove(Object o)
*       int size()
*       Object[] toArray()
* Iterator<E> iterator()

*
*/
public class CollectionDemo2 {
public static void main(String[] args) {
      //创建集合对象
      //Collection c = new Collection();//Collection是接口，不能实例化
      Collection c = new ArrayList();//多态，父类引用指向子类对象

      //boolean add(E e)
      System.out.println(c.add("hello"));//永远可以添加成功，因为ArrayList他允许重复
      System.out.println(c.add("world"));

      //void clear()：清空集合
      //c.clear();

      //boolean contains(Object o)  :判断集合中是否包含指定元素
      //System.out.println(c.contains("java"));

      //boolean isEmpty() :是否为空
      //System.out.println(c.isEmpty());


      //boolean remove(Object o) :删除元素
      //System.out.println(c.remove("java"));

      //int size() :返回集合中的元素个数
      //System.out.println(c.size());

      //Object[] toArray()  :将集合转换成一个Object类型的数组
      Object[] objs = c.toArray();
      for (int i = 0; i < objs.length; i++) {
         System.out.println(objs);
      }
      System.out.println(c);
}
}

1.3 迭代器

java中提供了很多个集合，它们在存储元素时，采用的存储方式不同。我们要取出这些集合中的元素，可通过一种通用的获取方式来完成。

Collection集合元素的通用获取方式：在取元素之前先要判断集合中有没有元素，如果有，就把这个元素取出来，继续在判断，如果还有就再取出出来。一直把集合中的所有元素全部取出。这种取出方式专业术语称为迭代。

集合中把这种取元素的方式描述在Iterator接口中。Iterator接口的常用方法如下

hasNext（）方法：判断集合中是否有元素可以迭代

next（）方法：用来返回迭代的下一个元素，并把指针向后移动一位。

1.3.1 案例代码三:

[Java] 纯文本查看 复制代码

 package com.itheima_02;

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

/*
* 集合的遍历方式：
*    1.toArray(),可以把集合转换成数组，然后遍历数组即可
*    2.iterator(),可以返回一个迭代器对象，我们可以通过迭代器对象来迭代集合
*
* Iterator：可以用于遍历集合
* E next()  :返回下一个元素
*  boolean hasNext()  ：判断是否有元素可以获取
*
*  注意：Exception in thread "main" java.util.NoSuchElementException
*  使用next方法获取下一个元素，如果没有元素可以获取，则出现NoSuchElementException

*/
public class IteratorDemo {
public static void main(String[] args) {
      //method();
      //创建集合对象
      Collection c = new ArrayList();
      //添加元素
      c.add("hello");
      c.add("world");
      c.add("java");

      //获取迭代器对象
      Iterator it = c.iterator();

      //Object next()  :返回下一个元素
      //boolean hasNext()  ：判断是否有元素可以获取

      /*if(it.hasNext())
         System.out.println(it.next());
      if(it.hasNext())
         System.out.println(it.next());
      if(it.hasNext())
         System.out.println(it.next());
      if(it.hasNext())
         System.out.println(it.next());*/

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

private static void method() {
      //创建集合对象
      Collection c = new ArrayList();
      //添加元素
      c.add("hello");
      c.add("world");
      c.add("java");
      //获取数组
      Object[] objs = c.toArray();
      //遍历数组
      for (int i = 0; i < objs.length; i++) {
         System.out.println(objs);
      }
}

}

1.4 并发修改异常:

并发修改异常产生原因:

当使用迭代器遍历集合的时候,使用了集合中的增加/删除方法,导致并发修改异常产

1.4.1 案例代码四:

[Java] 纯文本查看 复制代码

package com.itheima_02;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

import java.util.List;

import java.util.ListIterator;

/*

 * 需求：判断集合中是否包含元素java，如果有则添加元素android

 * Exception in thread "main" java.util.ConcurrentModificationException:并发修改异常

 * 迭代器是依赖于集合的，相当于集合的一个副本，当迭代器在操作的时候，如果发现和集合不一样，则抛出异常

 *

 * 解决方案:

 *      你就别使用迭代器

 *      在使用迭代器进行遍历的时候使用迭代器来进行修改

 */

public class IteratorDemo3 {

    public static void main(String[] args) {

        //method();

       

        //创建集合对象

        //Collection c = new ArrayList();

        List c = new ArrayList();

        //添加元素

        c.add("hello");

        c.add("world");

        c.add("java");

       

        //我们可以通过遍历来获取集合中的每一个元素，然后进行比较即可

        /*Iterator it = c.iterator();

        while(it.hasNext()) {

            String s = (String)it.next();

            if(s.equals("java")) {

                c.add("android");

            }

        }*/

       

        ListIterator lit = c.listIterator();

        while(lit.hasNext()) {

            String s = (String)lit.next();

            if(s.equals("java")) {

                lit.add("android");

            }

        }

       

        System.out.println(c);

    }

 

    private static void method() {

        //创建集合对象

        Collection c = new ArrayList();

        //添加元素

        c.add("hello");

        c.add("world");

        c.add("java");

        //判断集合中是否包含元素java

        if(c.contains("java")) {

            c.add("android");

        }

        System.out.println(c);

    }

 

}

并发修改异常解决方案:

A:不使用迭代器遍历集合,就可以在遍历的时候使用集合的方法进行增加或删除

B:依然使用迭代器遍历,那么就需要使用Iterator的子接口ListIterator来实现向集合中添加

第2章  增强for&泛型

2.1    泛型
2.1.1    泛型的引入

在前面学习集合时，我们都知道集合中是可以存放任意对象的，只要把对象存储集合后，那么这时他们都会被提升成Object类型。当我们在取出每一个对象，并且进行相应的操作，这时必须采用类型转换

2.1.1.1 案例代码五:

[Java] 纯文本查看 复制代码

package com.itheima_03;

 

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

 

/*

 * 使用集合存储自定义对象并遍历

 * 由于集合可以存储任意类型的对象，当我们存储了不同类型的对象，就有可能在转换的时候出现类型转换异常，

 * 所以java为了解决这个问题，给我们提供了一种机制，叫做泛型

 * *           

 */

public class GenericDemo {

    public static void main(String[] args) {

        //创建集合对象

        Collection  c = new ArrayList();

        //创建元素对象

        Student s = new Student("zhangsan",18);

        Student s2 = new Student("lisi",19);

        //添加元素对象

        c.add(s);

        c.add(s2);

        //遍历集合对象

       

        Iterator  it = c.iterator();

        while(it.hasNext()) {

             String str = (String)it.next();

             System.out.println(str);

           

     

        }

    }

}

 

class Student {

    String name;

    int age;

    public Student(String name,int age) {

        this.name = name;

        this.age = age;

    }

}

以上代码会发生强制转换异常,原因就是Stringstr = (String)it.next() ,存入集合的是Student,而强转为String,String与Student之间没有任何子父关系不能强转,未使用泛型前有可能发声强制转换异常的问题

2.1.2 泛型的使用

当类上定义<>的时候就可以使用泛型,例如ArrayList类的定义:

class ArrayList<E>,那么我们在创建ArrayList对象的时候就可以指定<>中E的类型

ArrayList<String>al=new ArrayList<String>(),那么String就把E替换掉了

2.1.2.1 案例代码六:

[Java] 纯文本查看 复制代码

package com.itheima_03;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

 

/*

 * 使用集合存储自定义对象并遍历

 * 由于集合可以存储任意类型的对象，当我们存储了不同类型的对象，就有可能在转换的时候出现类型转换异常，

 * 所以java为了解决这个问题，给我们提供了一种机制，叫做泛型

 *

 * 泛型：是一种广泛的类型，把明确数据类型的工作提前到了编译时期，借鉴了数组的特点

 * 泛型好处：

 *          避免了类型转换的问题

 *          可以减少黄色警告线

 *          可以简化我们代码的书写

 *

 * 什么时候可以使用泛型？

 *      问API，当我们看到<E>，就可以使用泛型了

 *         

 */

public class GenericDemo {

    public static void main(String[] args) {

        //创建集合对象

        Collection<Student> c = new ArrayList<Student>();

        //创建元素对象

        Student s = new Student("zhangsan",18);

        Student s2 = new Student("lisi",19);

        //添加元素对象

        c.add(s);

        c.add(s2);

        //遍历集合对象

       

        Iterator<Student> it = c.iterator();

        while(it.hasNext()) {

            //String str = (String)it.next();

            //System.out.println(str);

           

            Student stu = it.next();

            System.out.println(stu.name);

        }

    }

}

 

class Student {

    String name;

    int age;

   

    public Student(String name,int age) {

        this.name = name;

        this.age = age;

    }

}

2.2 增强for

增强for循环是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。

格式：

for(元素的数据类型变量 : Collection集合or数组){

}

它用于遍历Collection和数组。通常只进行遍历元素，不要在遍历的过程中对集合元素进行增删操作。

2.2.1 案例代码七:

[Java] 纯文本查看 复制代码

package com.itheima_04;

import java.util.ArrayList;

import java.util.Collection;

 

/*

 * foreach:增强for循环，一般用于遍历集合或者数组

 * 格式：

 *      for(元素的类型 变量 : 集合或者数组对象) {

 *          可以直接使用变量;

 *      }

    注意：在增强for循环中不能修改集合，否则会出现并发修改异常。

   

    public interface Iterable<T>

    实现这个接口允许对象成为 "foreach" 语句的目标。

 

 */

public class ForEachDemo {

    public static void main(String[] args) {

         //创建集合对象

        Collection<String> c = new ArrayList<String>();

        //添加元素

        c.add("hello");

        c.add("world");

        c.add("java");

       

        //增强for循环遍历集合

        /*for(Object obj : c) {

            System.out.println(obj);

        }*/

       

       

        /*for(String s : c) {

            System.out.println(s.toUpperCase());

        }*/

       

        for (String string : c) {

            c.add("android");

            System.out.println(string);

        }

    }

}

第3章常见数据结构
3.1 数组

数组，采用该结构的集合，对元素的存取有如下的特点：

查找元素快：通过索引，可以快速访问指定位置的元素

增删元素慢 ,每次添加元素需要移动大量元素或这创建新的数组

3.2 链表

链表，采用该结构的集合，对元素的存取有如下的特点：

A:多个节点之间，通过地址进行连接。例如，多个人手拉手，每个人使用自己的右手拉住下个人的左手，依次类推，这样多个人就连在一起了。

B:查找元素慢：想查找某个元素，需要通过连接的节点，依次向后查找指定元素

C:增删元素快：

增加元素：只需要修改连接下个元素的地址即可。

删除元素：只需要修改连接下个元素的地址即可

3.3 栈&队列

A:堆栈，采用该结构的集合，对元素的存取有如下的特点：

先进后出（即，存进去的元素，要在后它后面的元素依次取出后，才能取出该元素）。例如，子弹压进弹夹，先压进去的子弹在下面，后压进去的子弹在上面，当开枪时，先弹出上面的子弹，然后才能弹出下面的子弹。

B:队列，采用该结构的集合，对元素的存取有如下的特点：

先进先出（即，存进去的元素，要在后它前面的元素依次取出后，才能取出该元素）。例如，安检。排成一列，每个人依次检查，只有前面的人全部检查完毕后，才能排到当前的人进行检查。

第4章 List子体系
4.1 List子体系特点

A:有序的（存储和读取的顺序是一致的）

B:有整数索引

C:允许重复的

4.2 List的特有功能

void add(int index, E element) :将元素添加到index索引位置上

E get(int index) :根据index索引获取元素

E remove(int index):根据index索引删除元素

E set(int index, Eelement):将index索引位置的的元素设置为element

4.2.1 案例代码八:

[Java] 纯文本查看 复制代码

package com.itheima_05;

import java.util.ArrayList;

import java.util.List;

/*

 * List:

 *      有序的（存储和读取的顺序是一致的）

 *      有整数索引

 *      允许重复的

 *

 * List的特有功能：

 *          void add(int index, E element) 

 *          E get(int index) 

 *          E remove(int index) 

 *      E set(int index, E element)

 * 

 *   增删改查

 

 

 *  

 */

public class ListDemo {

    public static void main(String[] args) {

        //创建的列表对象

        List list = new ArrayList();

       

        //void add(int index, E element)  : 在指定索引位置添加指定元素

        list.add(0, "hello");

        list.add(0, "world");

        list.add(1, "java");

       

        //E get(int index)  :根据索引返回元素

        /*System.out.println(list.get(0));

        System.out.println(list.get(1));

        System.out.println(list.get(2));*/

        //System.out.println(list.get(3));

       

        /*for (int i = 0; i < list.size(); i++) {

            System.out.println(list.get(i));

        }*/

       

        //E remove(int index)  : 删除指定元素并返回

       

        //System.out.println(list.remove(5));

       

        //E set(int index, E element) : 将指定索引位置的元素替换为指定元素，并将原先的元素返回

        System.out.println(list.set(0, "android"));

       

        System.out.println(list);

    }

}

4.3 LinkedList特有功能

LinkedList底层使用的是链表结构,因此增删快,查询相对ArrayList较慢

void addFirst(E e) :向链表的头部添加元素

voidaddLast(E e):向链表的尾部添加元素

EgetFirst():获取链头的元素,不删除元素

EgetLast():获取链尾的元素,不删除元素

EremoveFirst():返回链头的元素并删除链头的元素

EremoveLast():返回链尾的元素并删除链尾的元素

4.3.1 案例代码九:

[Java] 纯文本查看 复制代码

package com.itheima_06;

import java.util.LinkedList;

/*
* List的常用子类：
*    ArrayList
*       底层是数组结构，查询快，增删慢
*    LinkedList
*       底层结构是链表，查询慢，增删快
*
* 如何选择使用不同的集合？
*    如果查询多，增删少，则使用ArrayList
*    如果查询少，增删多，则使用LinkedList
*    如果你不知道使用什么，则使用ArrayList
*
* LinkedList的特有功能：
*       void addFirst(E e)
*       void addLast(E e)
         E getFirst()
         E getLast()
         E removeFirst()
         E removeLast()
*
*/
public class LinkedListDemo {
public static void main(String[] args) {
         LinkedList list = new LinkedList();
         list.add("hello");
         list.add("world");

         //void addFirst(E e)  :将元素添加到索引为0的位置
         //void addLast(E e) ：将元素添加到索引为size()-1的位置
         list.addFirst("java");
         list.addLast("android");

         //E getFirst()  :获取索引为0的元素
         //E getLast()  ：获取索引为size()-1的元素
         //System.out.println(list.getFirst());
         //System.out.println(list.getLast());

         //E removeFirst() :删除索引为0的元素并返回
         //E removeLast() ：删除索引为size()-1的元素并返回
         System.out.println(list.removeFirst());
         System.out.println(list.removeLast());


         System.out.println(list);
}
}

4.4 案例代码九

[Java] 纯文本查看 复制代码

package com.itheima_07;

import java.util.ArrayList;

import java.util.List;

 

/*

 * 需求：定义一个方法，返回指定列表中指定元素的索引位置

 *

 * 判断元素是否存在

 *

 */

public class ListTest {

    public static void main(String[] args) {

        List list = new ArrayList();

        list.add("hello");

        list.add("world");

        list.add("java");

       

        //int index = index(list,"php");

        //System.out.println(index);

       

        //boolean flag = contains(list, "php");

        //System.out.println(flag);

       

        boolean flag = list.contains("php");

        System.out.println(flag);

    }

   

    public static int index(List list,Object other) {

        for(int x = 0;x < list.size();x++) {

            //获取列表中的元素

            Object obj = list.get(x);

            //使用列表中的元素和指定的元素进行比较

            if(obj.equals(other)) {

                return x;

            }

        }

        //查找不到指定的元素

        return -1;

    }

   

    public static boolean contains(List list,Object other) {

        //获取指定元素在指定列表中的索引位置

        int index = index(list,other);

        //如果索引位置大于等于0，则认为元素存在，否则不存在

        if(index >= 0) {

            return true;

        }

        else {

            return false;

        }

    }

   

   

   

}

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2