疯狂Java学习笔记(016)

1.类集合

集合框架
Collection接口
List接口
ArrayList类
Iterator迭代器接口
Vector类
LinkedList类

2.集合类

　　集合是存储对象最常用的一种方式（容器）。Java中，集合也是类，真正用来存储东西的是某种集合类的实例对象。

3.集合类和数组的区别

　　数组：

长度是固定的；
可以存储基本数据类型，也可以存储对象的引用；
必须是相同类型的数据；

　　集合：

长度是可变的
只能用于存储对象的引用
对象可以是不同类型。

4.Collection接口概述

Collection层次结构中的根接口
Collection表示一组对象，这些对象也称collection的元素。
一些collection允许有重复元素，而另一些不允许。
Iterable中不装任何数据，它是用来迭代的

5.Collection接口,在java.util下

　　List接口：可存放重复元素，元素存取是“有序”的。

　　Set接口：不可以存放重复元素，通常元素存取是“无序”的，也有一些实现类元素是“有序”的。

　　　“有序”“无序”指的是存放元素时是否会记住元素存放的顺序，并非对元素进行“排序”。

6.Collection接口中的方法

　　添加操作：

boolean add(Object object)：添加参数为一个元素，如果将一个集合当成一个元素，它的size应该是1.

// 使用接口多态,集合中应该对元素的类型加以限制，出黄线是因为没加泛型
  Collection c = new ArrayList();
  c.add("abv");
  c.add(new Integer(10));
  c.add(10);//自动装箱成包装类对象！这个是JDK1.5之后才有的
  c.add(new Date());

boolean addAll(Collection coll)：将另一个集合中所有元素一次添加到本集合中，是将元素打散放到另一个集合里

　Collection c2 = new ArrayList<>();
  c2.addAll(c);
  c2.add("abv");//c2里是可以存放相同的字符串的

  System.out.println(c2.size());
  System.out.println(c.size());
  //两个打印的内容是一样的，长度都是4

　　删除操作：

boolean remove(Object object):删除集合中的一个指定的元素
- Collection s1 = new ArrayList<>();
    s1.add("abc");
    s1.add("abc");
    s1.add("abcd");
  
    s1.remove("abc");//通过查api文档，只删除单个实例，也就是只删除一个。查找ArrayList中的remove方法
    System.out.println(s1.size());
boolean removeAll(Collection coll)：删除两个集合的交集
-   Collection s1 = new ArrayList<>();
    s1.add("abc");
    s1.add("abc");
    s1.add("abcd");
  
    Collection s2 = new ArrayList<>();
    s2.add("abcd");
    s2.add("abcd");
    s2.add("abcd");
  
    s2.removeAll(s1);
  
    System.out.println(s2.size());//打印完值为0，就是只要两个有一样的都删掉

　　查询操作：

int size()
- Collection s1 = new ArrayList<>();
    s1.add("abc");
  
    Collection s2 = new ArrayList<>();
    s2.add("abcd");
    s2.add("abcd");
    s2.add("abcd");
  
  s1.addAll(s2);//这个打印完的结果就是4
  System.out.println(s1.size());
    s1.add(s2);//这个打印完的结果就是2
    System.out.println(s1.size());

　　判断操作：

boolean isEmpty()；是否为空
- 　　c1.isEmpty( );
boolean contains(Object obj)：是否包含元素
- 　　c2.contains("abc")
boolean containsAll(Collection c)：是否包含令一个集合中所有的元素。如果c中有两个“abv”,而另一个由一个“abv”,也算包含
- s1.add("abc");
    s1.add("abc");
    s1.add("abcd");
    s1.add("abcdefgh");
- s2.add("abcd");
  s2.add("abcd");
- System.out.println(s1.containsAll(s2));//就是s2有两个，s1只有一个，也算s1包含s2;

7.Collection接口中的方法：迭代器，是遍历集合的方式

　　迭代操作：Iterator iterator()：返回一个在此集合上的迭代器！

　　iterator()方法的返回值是一个接口，真实返回是实现子类的对象，不同的集合类返回的是不同的迭代器对象，

　　说明：

迭代器不保证取出元素的顺序和存入的顺序一致。如list是可以重复的，arraylist是保证存取顺序，而set不保证顺序。
迭代器本事时一个接口，该方法返回的时一个迭代器实例对象。通常使用的是接口多态使用迭代器。
各个集合中的子类有不同的实现。

　　迭代器中常用的两个方法：

boolean hasNext():判断是否有下一个元素
Object next():取出下一个元素

8.迭代器读取元素示意图

　　指针最开始指向得是第一个元素得前方，而next返回值是上一个指针指向得元素，比如说现在图中得指针指得是第一个前方，判断后，.next()则是第一个元素。返回的也是这个值。API中这个next翻译的不是很准确。

Collection c = new ArrayList();//创建集合对象

Iterator it = c.iterator(); //获取此集合的迭代器

while(it.haxNext()){　　 //遍历这个集合，这里用while来遍历，也就是迭代。

　　Object o =it.next();

}

9.List接口中常用类*******

　　ArrayList:线程不安全，，底层用的是数组，查询快,增删慢，底层使用的是数组，因为是引用数据类型，所有的元素保存的是地址值。

　　LinkedList:线程不安全，底层用的是链表，增删速度快，查询慢，底层使用的是链表

　　Vector:线程安全，但速度慢，已被ArrayList代替

　　弹栈FILO （first in last out）LIFO(last in first out)，关于弹栈压栈

10.List接口的方法&增强for

　　特有方法：(凡是和索引有关的方法，都是List接口特有的)

void add(int index,Object element);
remove（int index）;
Object get(int index);
Object set(int index,Object element);

　　增强for:

　　for(Object obj :c){ } 其中，Object是元素类型，obj是迭代变量名，c是集合名

11.List接口遍历的方式，ArrayList用前两种

第一种：迭代器遍历（从Collection中继承来的）
第二种：增强for循环（迭代器的简化写法）
第三种：普通for循环配合使用get（index）方法

12.迭代器接口：Iterator

　　迭代是取出集合中元素的一种方式，因为Collection中有iterator方法，所以每一个子类集合对迭代器。象都具备

　　方法一：（常用）

　　Iterator iter = l.iterator();

　　while(iter.hasNext()){

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

}

　　方法二：

for(Iterator iter = iterator();iter.hasNext();){

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

}

13.迭代器注意事项

　　迭代器在Collection接口中是通用的。

　　迭代器的next方法返回值类型是Object,所以要记得类型转换。

***********************************

习题代码：

**********************************

代码练习：

1.从键盘录入年份,显示当年的二月份有多少天?(使用Calendar类的方法实现)

package com.test1;

import java.util.Calendar;
import java.util.Scanner;

/*
 * 从键盘录入年份,显示当年的二月份有多少天?(使用Calendar类的方法实现)
 */
class Demo3 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("input a year:");
        
        int year = sc.nextInt();
        
        //
        Calendar c = Calendar.getInstance();
        c.set(Calendar.YEAR, year);
        c.set(Calendar.MONTH, 1);
        
        System.out.println(c.getActualMaximum(Calendar.DAY_OF_MONTH));
        
        
    }
}

2.从键盘录入两个时间(包含年-月-日),显示二者之间的天数差

package com.test1;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

/*
 * 从键盘录入两个时间(包含年-月-日),显示二者之间的天数差
 */
public class Demo4 {

    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        System.out.println("input two date:(yyyy-MM-dd)");
        String first = sc.next();
        String second = sc.next();
        
        //
        Date d1 = new SimpleDateFormat("yyyy-MM-dd").parse(first);
        Date d2 = new SimpleDateFormat("yyyy-MM-dd").parse(second);
        
        System.out.println((d2.getTime() - d1.getTime()) / 1000 / 3600 / 24);
    }

}

3.给出生日，求来到世界多少天。

package com.test1;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

/*
 * 给出生日,求来到世界多少天!
 */
public class Demo1 {

    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);
        
        System.out.println("input your birthday:(yyyy-MM-dd)");
        
        String birthday = sc.next();
        //
        Date date = new SimpleDateFormat("yyyy-MM-dd").parse(birthday);
        long time = date.getTime();
        System.out.println((System.currentTimeMillis() - time) / 1000 / 3600 / 24);
    }

}

4.将自定义对象存储到集合中,并遍历.

package com.test;

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

/*
 * 将自定义对象存储到集合中,并遍历
 */

class Student{
    private String name;
    private int 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;
    }
    public Student(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Student() {
        super();
    }
    
}

public class Demo {

    public static void main(String[] args) {
        Collection c = new ArrayList();
        //创建元素并添加到集合中
        Student s1 = new Student("toms", 10);
        Student s2 = new Student("Tyson", 12);
        Student s3 = new Student("Jerry", 13);

        c.add(s1);
        c.add(s2);
        c.add(s3);
        
        //
        Iterator it = c.iterator();
        while(it.hasNext()){
            Student s = (Student) it.next();
            System.out.println(s.getName() +","+ s.getAge());
        }
        
        System.out.println("---------------");
        for (Object obj : c) {
            Student s = (Student) obj;
            System.out.println(s.getName() +","+ s.getAge());
        }
        
    }

}

5.从键盘录入一个字符串,将其中的三个字符组成的单词抽取到一个集合中,并遍历输出（待补全）

package com.test;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/*
 * 从键盘录入一个字符串,将其中的三个字符组成的单词抽取到一个集合中,并遍历输出
 */
public class Demo2 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        
        System.out.println("input a string:");
        
        String line = sc.nextLine();
        Matcher m = Pattern.compile("\b[a-zA-Z]{3}\b").matcher(line);
        //创建集合
        List list = new ArrayList();
        while(m.find()){
            list.add(m.group());
        }
        //
        for (Object obj : list) {
            System.out.println(obj);
        }
        
    }

}