Java入门（二十八）

Java入门（二十八）

集合

• 集合类的特点：提供了一种存储空间可变的存储模型，存储的数据容量可以随时发生变化。
• 集合最主要的用处就是存储和取出数据的。比如说我有数据：张三、李四、王五，他是单列的，这样的数据在集合中是通过collection集合来实现的。所以collection集合也被称为单列集合。
  
• 再在他前面加上数据，这样每个数据张三、李四、王五他都是由双列组成的，这样的数据存储在集合中是通过map来实现的，所以map集合也被称为双列集合。
  
• 单列集合中出现了问题，张三、李四、张三中，张三出现了两次，这种集合是通过collection下的list实现，所以元素是可以重复的。
  
• 假如我们实际上得到的是张三和李四，第二个张三在集合中没有存储成功。这种集合就是由set实现的。set集合元素他是不可重复的。
• 写集合他都是接口，并不能直接创建对象并使用，所以还需要使用类。
• ArrayList是最常用的集合类之一，还要学一个LinkedList类。
• 在Set下面，重点学习HashSet和TreeSet
• 在Map下面重点学习HashMap
  
• 学习的是接口，使用的是实现类。接口是不能直接创建对象并实例化的，必须通过实现类创建并实例化。

Collection集合概述和使用

• E表示集合中的元素类型，他是一个接口继承了Iterable。Collection是集合层次结构中的根，集合表示一组被称为其元素的对象。一些集合允许重复元素，其他集合不允许。jdk不提供此接口的任何实现，他提供更具体的子接口实现，如Set和List。
• 可以通过ArrayList集合类来创建collection集合的对象
• Collection是单例集合的顶层接口，他表示一组对象，这些对象也称为Collection的元素。
• 创建Collection集合的对象采用多态的方式创建。
• add方法是用来添加数据的，add参数类型是E，

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

public class CollectionDemo01 {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<String>();
        c.add("hello");
        c.add("world");
        c.add("java");
        //输出集合对象
        System.out.println(c);
    }
}

• 可以看到ArrayList中重写了toString方法，他是把指定的元素拼接成字符串在控制台输出的。
  

Collection集合的常用方法

方法名	说明
boolean add(E e)	添加元素
boolean remove(Object o)	从集合中移除指定的元素
void clear()	清空集合中的元素
boolean contains(Object o)	判断集合中是否存在指定的元素
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合中元素的个数

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

public class CollectionDemo02 {
    public static void main(String[] args) {
        //首先创建集合对象
        Collection<String> c = new ArrayList<>();
        System.out.println(c.add("hello"));
        //输出集合对象
        System.out.println(c);
    }
}

• true说明添加元素成功，集合里有了一个元素。继续添加，发现这个集合是可以存储重复元素的。并且存储元素的时候每次返回的都是true
  
• ArrayList难道每次存储元素都是true吗？来看看ArrayList类中的源码，在这里面找add方法(可以用structure查找）
  
  
• 可以看到他最终返回的是true，调用add方法永远返回的都是true。
• 试下移除world元素

        System.out.println(c.remove("world"));
        System.out.println(c);

• 这次移除一个不存在的元素，看输出结果，变成了false，原来的元素都还在。

        c.add("hello");
        c.add("world");
        c.add("java");
        //输出集合对象
//        System.out.println(c.remove("world"));
        System.out.println(c.remove("javaee"));
        System.out.println(c);

• 接下来用clear方法，这个方法用void，所以直接用对象来调用就可以了。
  
• 再来用contains判断集合中是否有某元素
  
• 判断集合是否为空
  
• 测试元素在集合中的长度
  

Collection集合的遍历

• Iterator是迭代器，集合的专用遍历方式。Collection集合将使用迭代器来遍历。
  
  
• 迭代器是一个接口，在java.util下。迭代器有泛型，和集合中的是一致的。
  
• 主要的方法获取元素、判断迭代有无元素，移除元素。
• Iterator iterator(): 返回集合中元素的迭代器，通过集合的iterator()方法得到。迭代器通过是通过iterator()方法得到，所以说他是依赖于集合而存在的。
• E next()：返回迭代中的下一个元素
• boolean hasNext()：如果迭代具有更多元素，则返回true

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

public class CollectionDemo03 {
    public static void main(String[] args) {
        Collection<String> c = new ArrayList<String>();
        c.add("hello");
        c.add("world");
        c.add("java");
        // Iterator<E> iterator() ，返回刺激和中元素的迭代器，通过集合的iterator()方法得到
        Iterator<String> it = c.iterator();
    }
}

• Iterator是一个接口，调用iterator方法会得到什么呢？这个需要看源码来看一下。这里看到他访问到了Collection.java里面
  
• 但是最终要看实现方法，所以我们要找ArrayList集合，打开结构图，找到iterator方法
  
• 最终我们看到这个方法他返回了一个itr，而这个返回值类型是一个借口，他最终返回的是该接口的实现类对象。Itr应该实现了这个Iterator接口
  
• Itr类就在下面 。Itr是一个类，实现了接口，并且Itr这个类定义在ArrayList集合里面，由此可见Itr是一个内部类。重写next方法、hasNext方法等。是通过多态的方法来得到Iterator对象。
  
• 来使用他的方法，next方法得到了他的hello

System.out.println(it.next());

• 每来一次next()，就能得到下一个元素。
  
• 如果调用的次数超过了元素个数，就会抛出NoSuchElementException的异常，表示被请求的元素不存在。
  
  
• 来看迭代器的另一个方法，hasNext，他是用来做判断的。

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

• 当超出元素个数的时候，会先判断有没有这个元素，当返回true的时候才进来获取这个元素。如果返回false，就根本进不来。获取元素之前就要做一个判断，假如集合中的元素比较多，那么这样写的会比较复杂，需要用循环改进。
  
• 用while循环改进，这样无论代码里面有多少元素就都可以获取到。

        while(it.hasNext()){
//            System.out.println(it.next());   
            String s = it.next();  //拿到字符串有可能会有其他操作，而部署将他输出
            System.out.println(s);
        }

集合的使用步骤

• 首先添加三个元素
  
• 添加迭代器，判断是否有元素
  
• 通过it.next()方法，就获取到了hello这个元素。然后输出hello这个元素，再循环回去判断。
  
• 集合的使用步骤：

1. 创建集合对象
2. 添加元素：①创建元素②添加元素到集合
3. 遍历集合：①通过集合对象获取迭代器对象②通过迭代器对象的hasNext()方法判断是否还有元素③通过迭代器next()方法获取下一个元素

案例：Collection集合存储学生对象并遍历

• 需求：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合。
• 所以集合的泛型就不能再写String了，要写学生Student对象。
• 思路：

1. 定义学生类
2. 创建Collection对象
3. 创建学生对象
4. 把学生添加到集合
5. 遍历集合（迭代器方式）

• 学生类里面有两个成员属性 name 和 age。有无参构造方法和带参构造方法，get,set方法

public class Student {
    private String name;
    private int age;
    public Student(){};
    public Student(String name,int age){
        this.name = name;
        this.age = age;
    }
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        this.age=age;
    }
}

• 在测试类里面

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

public class CollectionDemo {
    public static void main(String[] args) {
        //创建Collection集合对象
        Collection<Student> c = new ArrayList<Student>();
        //创建学生对象
        Student s1 = new Student("林青霞",30);
        Student s2 = new Student("张曼玉",35);
        Student s3 = new Student("王祖贤",33);
        //把学生添加到集合
        c.add(s1);
        c.add(s2);
        c.add(s3);
        //遍历集合（迭代器方式）
        Iterator<Student> it = c.iterator();
        while (it.hasNext()){
            Student s = it.next();
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}

_List集合概述和特点

• List集合描述信息在帮助文档查看
  
• List使用需要导包，List泛型是使用元素中的类型。List是一个接口，继承自Collection接口，所以Collection有的功能，List都可以使用。List被称为有序集合，也称为序列。用户可以精确控制每个元素的插入位置，可以通过整数索引访问元素，并搜索。与set集合不同，列表集合通常允许重复元素。
• List集合特点：有序：存储和取出的元素顺序一致 。可重复：存储的元素可以重复。

import java.util.ArrayList;
import java.util.List;

public class ListDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list = new ArrayList<String>();
        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        //输出集合对象
        System.out.println(list);
    }
}

• 可重复
  
• 遍历list集合。list继承自collection，collection遍历方法list也可以用。这里采用迭代器方式遍历。

        Iterator<String> it = list.iterator();
        while(it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }

List集合的特有方法

方法名	说明
void add(int index, E element )	在此集合中的指定位置插入指定的元素
E remove(int index)	删除指定索引处的元素，返回被删除的元素
E set(int index, E element)	修改指定索引处的元素，返回被修改的元素
E get(int index)	返回指定索引处的元素

import java.util.List;
import java.util.ArrayList;
public class ListDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list = new ArrayList<String>();
        //添加元素
        list.add("hello");
        list.add("world");
        list.add("java");
        //输出集合对象
        System.out.println(list);
    }
}

• 测试一下集合的方法，在指定位置添加元素

        // void add(int index,E element),在此集合中的制定位置插入指定的元素
        list.add(1,"javaee");

• 越界就会异常
  
• remove。这个假如越界同样异常

        //E remove(int index), 删除指定索引处的元素，返回被删除的元素
        System.out.println(list.remove(1));

• set方法

        //E set(int index,E element)，修改指定索引处的元素，返回被修改的元素
        System.out.println(list.set(1,"javaee"));

• 可以通过索引，获取指定索引处元素

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

• 用for循环改进遍历

        for (int i = 0;i<list.size();i++){
            String s = list.get(i);
            System.out.println(s);
        }

_List集合存储学生对象并遍历

• 需求：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合。
• 思路：

1. 定义学生类
2. 创建List集合对象
3. 创建学生对象
4. 把学生添加到集合
5. 遍历集合（迭代器方式，for循环方式）

• 定义学生类

public class Student {
    private String name;
    private int age;
    public Student(){};
    public Student(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }
}

• 创建List集合对象。

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ListDemo {
    public static void main(String[] args) {
        //创建List集合对象
        List<Student> list = new ArrayList<Student>();
        //创建学生对象
        Student s1 = new Student("林青霞",36);
        Student s2 = new Student("张曼玉",35);
        Student s3 = new Student("王祖贤",40);
        //把学生添加到集合
        list.add(s1);
        list.add(s2);
        list.add(s3);
        //迭代器方式
        Iterator<Student> it = list.iterator();
        while(it.hasNext()){
            Student s = it.next();
            System.out.println(s.getName()+","+s.getAge());
        }
        System.out.println("-----------------");
        //for循环方式
        for ( int i = 0;i<list.size();i++){
            Student s = list.get(i);
            System.out.println(s.getName()+","+s.getAge());
        }
    }
}