寒假实训第六天（集合和泛型）

 06-集合框架(重点)

本节 内容测试代码以单元测试方式来演示，如果自己想用可以换成main方法来去运行

数组存储的缺点

1、数组-旦初始化后，斯度和类型就确定了;

2、数组中提供的方法有限、对于增删改等操作不方便，效率也不高

3、能够解决有序、可重复,但对于无序和不可重复的需求时，不能够满足

基本概念

当需要在Java程序中记录单个数据内容时，则声明一个变量即可;当需要在Java程序中记录多个类型相同的数据内容时，则声明-一个-维数组即可;当需要在Java程序中记录多 个类型不同的数据内容时，则创建一个对象即可;当需要在Java程序中记录多个类型相同的对象数据时，则创建-个对象数组即可; 当需要在]ava程序中记录多个类型不同的对象数据时，则准备个 集合即可;

集合框架

Java中集合框架的顶层框架是: java.util.Collection集合 和java.util.Map集合。

其中Collection集合中存取元素的基本单位是:单个元素。其中Map集合中存取元素的基本单位是: 单对元素。



Collection集合(重点)常用方法.

boolean add(E e)        向集合中添加对象

boolean contains(Object o)          判断是否包含指定对象

boolean remove (Object o）           -从集合中删除对象

void clear();                    清空集合

int size(); -                 返回包含对象的个数

boolean isEmpty();        - 判断是否为空

Object[] toArray();-   将集 合转换成数组

将数组转换成集合? kan看代码

Iterator<E> iterator()   遍历 集合中的元素

Iterator对象称为迭代器，主要用于遍历collection集合中的元素

boolean hasNext ()   如果仍有元素可以迭代，则返回true.

E next()      返回迭代的下一个元素。

注意:集合对象每次调用iterator ()方法都得到-个全新的迭代器对象，默认游标都在集合的第一个元素之前。使用foreach循环遍历集合元素- JDK1.5提供，可以迭代访问col1ection和数组

遍历时不需要获取collection或数组的长度，也不需要使用索引访问

本质上，底层也是调用iterator

格式:

for (要遍历的元素类型:遍历后自定义元素名称:要遍历的结构名称) {

System. ou.println (遍历后自定义元素名称) ;

练习上述代码，注释很详细

public class CollectionTest {
   @Test
    public void collectionTest(){
        Collection collection = new ArrayList();//接口类型的引用指向实现的对象，形成多态
        System.out.println(collection);
        //向集合中添加元素，该方法的形参要求是Object类型
        boolean b = collection.add("one");//添进去的话就返回true
        System.out.println(collection);
        System.out.println("b = " + b);
        collection.add(2);
        System.out.println(collection);
        collection.add("张三");
        System.out.println(collection);
        collection.add(2.15);
        System.out.println(collection);
       System.out.println("--------------------");
      //判断是否包含对象
       b = collection.contains("two");
       System.out.println("b = " + b);
       b = collection.contains("one");
       System.out.println("b = " + b);
       //判读是否为空
       b = collection.isEmpty();
       System.out.println("b = " + b);
       System.out.println("=======================");
       System.out.println("集合中的元素有：" + collection);
       b = collection.remove("one");
       System.out.println("b = " + b);
       System.out.println("集合中的元素有：" + collection);
       System.out.println("+======================");
       //将集合转化成数组
       Object[] objects = collection.toArray();
      //遍历数组中的元素
       for (int i = 0;i < objects.length;i++){
           System.out.println(objects[i]);
       }
       //将数组转成集合
       List objects1 = Arrays.asList(objects);
       System.out.println(objects1);
       System.out.println("++++++++++++++++++++++");
       //迭代器遍历元素 方式二
       Iterator it = objects1.iterator();
       // b = it.hasNext();
       //System.out.println("b = " + b);//true
       //Object obj = it.next();
       //System.out.println("元素：" + obj);
       while(it.hasNext() == true){
           Object obj1 = it.next();
           System.out.println(obj1);
        }
       System.out.println("======================");
       //遍历集合中元素 方式三
       for (Object o : objects1){
           System.out.println(o);
       }

   }

结果

[]
[one]
b = true
[one, 2]
[one, 2, 张三]
[one, 2, 张三, 2.15]
--------------------
b = false
b = true
b = false
=======================
集合中的元素有：[one, 2, 张三, 2.15]
b = true
集合中的元素有：[2, 张三, 2.15]
+======================
2
张三
2.15
[2, 张三, 2.15]
++++++++++++++++++++++
2
张三
2.15
======================
2
张三
2.15

List集合(重点)

基本概念

java.util.List集合是Collection集合的子集合，该集合中允许有重复的元素并且有先后放入次序。该集合的主要实现类有: ArrayList类、LinkedList类、 Stack类、 Vector类。 中ArrayList类的底层是采用动态数组进行数据管理的，支持下标访问，增删元素不方便。其中LinkedList类的底层 是采用双向链表进行数据管理的，访问不方便，增删元素方便。其中Stack类的底层 是采用动态数组进行数据管理的，该类主要用于描述一种具有后进先出特征的数据结构，叫做栈(last in first out LIFO)。其中Vector类的底层 是采用动态数组进行数据管理的，该类与ArrayList类相比属于线程安全的类，效率比较低。

常用的方法

void add(int index, E element)   向集合中指定位置添加元素

boolean addAll(int index, Collection<? extends> C)   向集合中添加所有元素

E get(int index)    从集合中获取指定位置元素

E set(int index,E element) - 修改指定位置的元素

E remove   (int index)      删除指定位置的元素

List<E> subList (int fromIndex,int toIndex); 一获取子Iist， 前闭后开

注意: subList获取的List与原1ist占有相同的存储空间，对子list的操作会影响到原list。

看个例子

@Test
 public void listTest(){
    List list = new ArrayList();
    int size = list.size();
    System.out.println(size);
    System.out.println(list);
    //向集合中添加元素
    list.add(0,"one");
    list.add(1,2);
    list.add(2,3.01);
    list.add(3,'3');
    System.out.println(list);
    List list1 = new ArrayList();
    list1.add("next");
    list1.add("on");
    list.addAll(list1);
    System.out.println(list);
    //根据下标查看集合中指定位置的元素
    Object o = list.get(0);
    System.out.println(o);
    //根据下标修改指定集合位置的元素
    Object object = list.set(2,"haha");
    System.out.println("下标为2的位置修改为：" + object);//以前位于该指定位置上的元素
    System.out.println(object);
    System.out.println(list);
    //根据下标删除集合指定位置的元素
    o = list.remove(0);
    System.out.println("删除的元素为：" + o);
    System.out.println("=================");
    System.out.println(list);
    //获取子集合，前闭后开
    List list2 = list.subList(0,3);
    System.out.println("list集合：" + list);
    System.out.println("list2集合：" + list2);
    //subList获取的List与原来的List占有相同的存储空间，对子List的操作会影响到原来的List
    list2.remove(2);
    System.out.println("list集合：" + list);
    System.out.println("list2集合：" + list2);
    //改完原来集合再去输出子集合就不对了原因是
    // subList 返回的是原始集合的视图，而不是一个新的独立集合。
    // 这意味着对子集的修改会反映到原始集合上，反之亦然。
    // 但是，如果你尝试修改原始集合，而子集仍然存在，就会抛出异常。
    list.add("heihei");
    System.out.println(list);
    //System.out.println(list2);

}

结果

0
[]
[one, 2, 3.01, 3]
[one, 2, 3.01, 3, next, on]
one
下标为2的位置修改为：3.01
3.01
[one, 2, haha, 3, next, on]
删除的元素为：one
=================
[2, haha, 3, next, on]
list集合：[2, haha, 3, next, on]
list2集合：[2, haha, 3]
list集合：[2, haha, next, on]
list2集合：[2, haha]
[2, haha, next, on, heihei]

泛型机制

基本概念

通常情况下集合中可以存放不同类型的对象，是因为将所有对象都看做Object类型放入的，因此从集合中取出元素时也是Object类型，为了表达该元素真实的数据类型,则需要强制类型转换，而强制类型转换可能会弓|发类型转换异常。为了避免上述错误的发生，从jdk1 .5开始增加泛型机制，也就<数据类型>的方式来明确要求该集合中可以存放的元素类型，若放入其它类型的元素则编译报错，如:

List<String> 1t1 = new LinkedList<String>() ;

泛型机制的本质

型机制的本质就是参数化类型，也就是让数据类型作为参数传递，中E相当于形式参数负责占位，而使用集合时<>中的数据类型相当于实际参数，实际参数主要用于给形式参数初始化，一旦初始化成功，以后所有的E全部被实参取代，如:

//其中i叫做形式参数，负责占位

其中E叫做形式参数，负责占位

Queue集合(重点)

基本概念

java.util.Queue集合是Collection集合的子集合，与List集合属 于平级关系。该集合的主要用于描述具 有先进先出特征的数据结构，叫做队列first in first out FIFO)该集合的主要实现类是LinkedList类，因为该类在增删方面比较有优势。

常用的方法

boolean add(E e)一将指定的元素插入此队列(如果立即可行且不会违反容量限制)， 在成功时返回true, 如果当前没有可用的空间，则抛出Illega1StateException.

E element() -获取，但是不移除此队列的头。

boolean offer(E e)一将指定的元素插入此队列(如果立即可行且不会违反容量限制)，当使用有容量限制的队列时，此方法通常要优于add(E)， 后者可能无法插入元素，而只是抛出-一个异常。

E peek()一获取但不移除此队列的头;如果此队列为空，则返回null.

E poll()一获取并移除此队列的头，如果此队列为空，则返回null。

E remove() 一获取并移除此队列的头。

                             抛出异常              返回特殊值                   

插入                       add(e)                      offer(e)

移除                     remove()                      poll() 

检查                      element()                    peek()

练习:准备-个Queue集合,将数据11、22、 33、 44、 55依次入队并打印，然后查看队首元素并打印，然后将队列中所有数据依次出队并打印。

@Test
public void queueTest(){
   //准备一个queue集合
  Queue<Integer> queue = new LinkedList<>();
  //将数据11,22,33,44,55,依次入队并打印
  for (int i = 1;i <= 5;i++){
      queue.offer(i*11);
      System.out.println(queue);
  }
  //查看队首元素并打印
    Integer it = queue.peek();
    System.out.println("队首元素：" + it);
    //队列中元素依次输出
    System.out.println("==================");
    //poll
    int len = queue.size();
    for (int i = 0;i < len;i++){
        Integer it1 = queue.poll();
        System.out.println(it1);
    }
}

[11]
[11, 22]
[11, 22, 33]
[11, 22, 33, 44]
[11, 22, 33, 44, 55]
队首元素：11
==================
11
22
33
44
55
 

作业:查询java.til.Stack类以及相关方法， 实现将11、22、33、 44、 55依次入栈并打印，查看栈顶元素并打印，然后依次出栈并打印。

这个也很相似差不多看一眼

 @Test
    public void stackTest(){
        //实现将11、22、33、44、55依次入栈并打印，查看栈顶元素并打印，然后依次出栈并打印。
       Stack<Integer> stack = new Stack<>();
       boolean b = stack.empty();
       System.out.println("栈是否为空：" + b);
       for (int i = 1;i < 6;i++){
           stack.push(i*11);
           System.out.println(stack);
       }
       //查看栈顶元素
       Integer it = stack.peek();
       System.out.println("栈顶元素：" + it);
       //栈中元素依次输出
       int len = stack.size();
       for (int i = 0;i <= len;i++){//和上面相似
            Integer it1 = stack.pop();
            System.out.println(it1);

        }
    }
}

栈是否为空：true
[11]
[11, 22]
[11, 22, 33]
[11, 22, 33, 44]
[11, 22, 33, 44, 55]
栈顶元素：55
55
44
33
22
11

今天结束了，期待明天