黑马程序员 <a href="http://www.itheima.com" target="blank">java培训</a>

第十五天笔记

1.Calendar类的概述和获取日历字段方法

A.Calendar的概述

作用：它也是一个可以描述时间的类

注意：Calendar类是java.util包下的，它是一个抽象类

使用calendar类可以更加方便的对时间进行操作。

B. Calendar类的基本使用

Calendar类中提供get方法，它可以通过指定的日历字段来获取时间的值

Public int get（int filed）

参数：给定的日历字段

返回值：这个字段对应的值

2.Calendar类的add和set方法

A．add方法

作用：可以直接对日历字段对应的值进行操作（+或者-）

Public abstract void add（int filed，int amount）

参数：

Filed：要操作的日历字段

Amount：要对字段进行+ -的操作

B．set方法

作用:可以直接对日历字段的值进行操作

set(int field,int value) 对field字段修改值为value

set(int year,int month,int date)

set(int year,int month,int date,int hour,int minute)

set(int year,int month,int date,int hour,int minute,int second)

package lm.calendar;

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

public class CalendarDemo1 {
/**
 * 笔试题:求出一个指定年份中的所有周六与周日的日期？
 * @throws ParseException 
 * 
 */
    public static void main(String[] args) throws ParseException {
        //键盘键入一个年份
      Scanner sc=new Scanner(System.in);
      System.out.println("请输入任意一个年份");
      String s=sc.nextLine();
     //将string字符串转换为日期
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy");
      Date date =sdf.parse(s);
    
       
      //创建一个calendar
       GregorianCalendar ca=new GregorianCalendar();
       ca.setTime(date);
       //System.out.println(ca);
      // ca.get();
       Date date1=new Date();
       date1=ca.getTime();
       
       //得到每年的第一天是星期几
       int n=ca.get(GregorianCalendar.DAY_OF_WEEK);
       ca.set(GregorianCalendar.DAY_OF_WEEK, n+7-n);
       Date date11=ca.getTime();
       int month=ca.get(GregorianCalendar.WEEK_OF_MONTH);
       System.out.println(month);
       for(int i=0;i<12;i++){
       ca.roll(GregorianCalendar.WEDNESDAY, 1);
       Date date12=ca.getTime();
       System.out.println(date12);}
       
       
     
    }

}

3.如何获取任意年份的2月的天数

4.对象数组的概述和使用

A．数组的特点

存储同一类型的数据

数组中的元素是有顺序的

数组的长度是固定的

数组是一个容器，用于存储数据

B．怎样声明一个数组

静态声明：类型[] 数组名={}

动态声明：类型[] 数组名=new 类型[长度] 动态

类型[] 数组名=new 类型[]{}

C.上面说的类型是指数组元素的类型

D．对象数组

声明对象数组的时候，要使用元素的类型来描述

Student[] sts={s1,s2,s3};

注意：数组本身就是一种引用类型

5.数组对象的内存图解

6.集合的由来与数字的区别

A．集合

集合是一个容器，是用于存储对象的

B．数组和集合

有了数组以后，在开发中可能还会遇到这样的问题：

向容器中装入数据，数量不定

向容器中装入数据，类型不定

C．集合的特点

集合长度可以根据元素的个数改变而改变

集合中元素类型可以不一样

集合可以有顺序也可以没有顺序

7.集合的继承体系图解

8.Collection集合的功能描述

1．添加功能

Public boolean add（Object obj）{}

作用：将obj添加到集合中，返回值代表是否添加成功。

Public boolean addAll(Collection c){}

作用：将c集合中的所有元素添加到指定的集合中

2.查找功能

Public Iterator iterator（）{}

得到一个迭代器，可以遍历集合

3.删除功能

Public boolean remove（object obj）

将集合中obj元素删除，返回值代表是否被删除成功

Public boolean removeAll（Collection c）

将集合中与c集合中相同的元素删除

Public void clear（）

4.修改功能

它没有直接定义修改操作，因为需要考虑每一个集合的数据结构进行操作。

5.集合中的判断操作

A．boolean contains（odject o）

判断集合是否包含指定元素o

B．boolean containsAll（odject o）

判断集合中是否包含指定的子集c

C．boolean isEmpty()

判断集合是否为空，如果为空则返回true

6.获取集合长度：

Public void size（）

获取集合的长度，相当于数组中的length功能

7.转换方法

Public object[] toArray();

将集合转换成数组

8.boolean retainAll（Collection<?> c）

得到两个集合中共同的元素

package cn.itcast.collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Datel
public class CollectionDemo2 {

    public static void main(String[] args) {
        // add();
        // remove();
        // clear();

        // contains();

        // isEmpty();
        // size();
        toArray();
    }

    // 演示toArray方法
    public static void toArray() {
        Collection c = new ArrayList(); // 接口回调

        c.add("a");
        c.add("b");
        c.add("c");
        c.add("a");
        Object[] arr = c.toArray();

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

    // 演示size操作
    public static void size() {
        Collection c = new ArrayList(); // 接口回调

        System.out.println(c.size());
        c.add("a");
        c.add("b");
        c.add("c");
        c.add("a");
        System.out.println(c.size());

    }

    // 演示isEmpty操作
    public static void isEmpty() {
        Collection c = new ArrayList(); // 接口回调

        System.out.println(c.isEmpty());
        c.add("a");
        c.add("b");
        c.add("c");
        c.add("a");
        System.out.println(c.isEmpty());

    }

9.Collection集合的基本功能测试

package cn.itcast.collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Datel
public class CollectionDemo2 {

    public static void main(String[] args) {
        // add();
        // remove();
        // clear();

        // contains();

        // isEmpty();
        // size();
        toArray();
    }

    // 演示toArray方法
    public static void toArray() {
        Collection c = new ArrayList(); // 接口回调

        c.add("a");
        c.add("b");
        c.add("c");
        c.add("a");
        Object[] arr = c.toArray();

        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

    // 演示size操作
    public static void size() {
        Collection c = new ArrayList(); // 接口回调

        System.out.println(c.size());
        c.add("a");
        c.add("b");
        c.add("c");
        c.add("a");
        System.out.println(c.size());

    }

    // 演示isEmpty操作
    public static void isEmpty() {
        Collection c = new ArrayList(); // 接口回调

        System.out.println(c.isEmpty());
        c.add("a");
        c.add("b");
        c.add("c");
        c.add("a");
        System.out.println(c.isEmpty());

    }

10.Collection集合的高级功能测试

1.addAll-------并集

2.removeAll----差集

3.containsAll---只是判断是否是子集

4.retainAll----交集

注意:retainAll方法的返回值，boolean类型的代表提集合对象中的元素是否发生了改变

ublic class CollectionDemo3 {

    public static void main(String[] args) {
        // addAll();

        // removeAll();

        // containsAll();
        retainAll();
    }
    //retainAll方法得到两个集合中相同 的元素
    public static void retainAll() {

        Collection c = new ArrayList();

        // c.add("a");
        //
        // c.add("b");
        //
        // c.add("c");
        // c.add("l");

        Collection cc = new ArrayList();
        cc.add("d");
        cc.add("e");
        cc.add("f");
        cc.add("k");

        boolean flag = c.retainAll(cc);

        System.out.println(flag);

        System.out.println(c);
        System.out.println(cc);

    }

    // containsAll
    public static void containsAll() {

        Collection c = new ArrayList();

        c.add("a");

        c.add("b");

        c.add("c");

        Collection cc = new ArrayList();
        cc.add("a");
        cc.add("d");

        boolean flag = c.containsAll(cc);

        System.out.println(flag);

        System.out.println(c);
        System.out.println(cc);

    }

    // removeAll方法简单说就是求出两个集合相减的结果
    public static void removeAll() {

        Collection c = new ArrayList();

        c.add("a");

        c.add("b");

        c.add("c");

        Collection cc = new ArrayList();
        cc.add("a");
        cc.add("d");

        boolean flag = c.removeAll(cc);

        System.out.println(flag);

        System.out.println(c);
        System.out.println(cc);

    }

    // addAll方法简单说就是将两个集合内容合并
    public static void addAll() {

        Collection c = new ArrayList();

        c.add("a");

        c.add("b");

        c.add("c");

        Collection cc = new ArrayList();
        cc.add("张三");
        cc.add("李四");

        boolean flag = c.addAll(cc);
        System.out.println(flag);
        System.out.println(c);
        System.out.println(cc);
    }

}

11.集合的遍历之集合转换数组遍历

可以将集合通过toArray方法将集合转换成Object[]，在对数组遍历.

ublic class CollectionDemo4 {

    public static void main(String[] args) {

        // 1.向集合中存储10个100以内的随机数
        Collection nums = new ArrayList();
        // A:使用Random类来获取随机数
        Random ran = new Random();
        // B :使用for循环来获取10个随机数
        for (int i = 0; i < 10; i++) {
            int n = ran.nextInt(100);
            nums.add(n); // 集合中不能装基本数据类型，集合的元素只能是Object
            // 注意:在jdk1.5后，提供自动拆箱与装箱功能，所以在向集合中添加基本类型数据时，会自动的包装成其对应的包装类对象。
        }
        
        System.out.println(nums);
        System.out.println("-----------------------");

        // 2.将集合转换成数组，在对数组遍历
        Object[] objs = nums.toArray();

        for (int i = 0; i < objs.length; i++) {
            int obj = (Integer) objs[i]; // 自动拆箱功能
            System.out.println(obj);
        }
    }
}

12.Collection存储自定义对象并遍历

//将集合中存储自定义对象
public class CollectionDemo5 {

    public static void main(String[] args) {
        // 1.创建一个集合
        Collection c = new ArrayList();

        // 2.向集合中添加三个Person对象.
        Person p1 = new Person(1, "张三丰");
        Person p2 = new Person(2, "滤镜");
        Person p3 = new Person(3, "曹操");
        c.add(p1);
        c.add(p2);
        c.add(p3);

        // 3.通过toArray方法转换成Object数组
        Object[] objs = c.toArray();

        // 4.遍历数组
        for (int i = 0; i < objs.length; i++) {
            Person p = (Person) objs[i];
            System.out.println(p);
        }
    }
}

class Person {
    private int id;
    private String name;

    public Person(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person [id=" + id + ", name=" + name + "]";
    }

}

13.集合的遍历值迭代器

在Collection接口中有一个方法

Public Iterator iterator();

就可以得到一个对Collection进行遍历的迭代器。

通过iterator方法得到的是一个java.util.Iterator接口类型的对象。

Iterator中的方法:

hasNext

public boolean hasNext()

作用:只是判断集合中是否有下一个元素进行迭代。

public Object next();

作用:得到下一个元素。

remove

在对集合通过迭代器进行遍历时，我们一般会使用循环进行操作。

ublic class CollectionDemo8 {
5.    
6.        public static void main(String[] args) {
7.            // 1.向集合中装入三个学
8.            // 1.1 创建集合
9.            Collection c = new ArrayList();
10.            // 1.2 向集合中装入学生对象
11.            c.add(new Student(1, "tom", "男"));
12.    
13.            c.add(new Student(2, "fox", "女"));
14.    
15.            c.add(new Student(3, "james", "女"));
16.            // 2.使用迭代器对集合进行遍历
17.            // // 2.1.得到迭代器
18.            // Iterator it = c.iterator();
19.            //
20.            // while (it.hasNext()) {
21.            // // 2.2.判断是否有元素进行迭代
22.            // // 2.3.将集合中元素迭代出来
23.            // Student obj = (Student) it.next();
24.            //
25.            // // 2.4.输出
26.            // System.out.println(obj);
27.            // }
28.    
29.            // 将第二个步骤不在使用while循环来遍历，而使用for
30.    
31.            for (Iterator it = c.iterator(); it.hasNext();) {
32.                Student obj = (Student) it.next();
33.                System.out.println(obj);
34.            }
35.        }
36.    }
37.    
38.    class Student {
39.        private int id;
40.        private String name;
41.        private String sex;
42.    
43.        public Student(int id, String name, String sex) {
44.            super();
45.            this.id = id;
46.            this.name = name;
47.            this.sex = sex;
48.        }
49.    
50.        public int getId() {
51.            return id;
52.        }
53.    
54.        public void setId(int id) {
55.            this.id = id;
56.        }
57.    
58.        public String getName() {
59.            return name;
60.        }
61.    
62.        public void setName(String name) {
63.            this.name = name;
64.        }
65.    
66.        public String getSex() {
67.            return sex;
68.        }
69.    
70.        public void setSex(String sex) {
71.            this.sex = sex;
72.        }
73.    
74.        @Override
75.        public String toString() {
76.            return "Student [id=" + id + ", name=" + name + ", sex=" + sex + "]";
77.        }
78.    
79.    }

14.迭代器的原理及源码解析

通过分析发现以下情况:

每一个集合的迭代器不一样
迭代器的实现类都是内部类。

问题:为什么每一个具体集合的迭代器不一样，还是内部类哪?

转为每一个集合它的底层实现(数据结构)不一样，所以在遍历的方式上也不同。

那么，每一个集合有一个自己的迭代器类的实现

做成内部类的原因，内部类可以方便的去访问外部类的成员，

这样在遍历集合中元素时更加方便。

伪代码

Interface Collection{

Iterator iterator();

}

Interface Iterator{

Boolean hasNext();

Object next();

}

Class MyArrayList implements Collection{

//采用自己的数据结构存储数据

Object[] objs;

Class myItr implements Iterator{

Boolean hasNext(){}

Object next(){}

}

Class MyHasSet implements Collection{

//采用自己的数据结构存储数据

Class myItrator implements Iterator{

Boolean hasNext(){}

Object next(){}

}

16.List存储字符串并遍历

List集合—有顺序可重复.

因为List集合是Collection集合的子接口，

List集合中包含了Collection中所有方法。

但是List集合中也有一些特殊的方法(是List集合特有)

17.List集合的特点

1.add public void add(int index,Object obj);

* 将obj元素插入到index索引位置，后面的元素顺延。 2.get public Object get(int index);

* 获取指定index索引位置上的元素。 3.indexOf public int indexOf(Object obj)

* 获取obj在集合中第一次出现的索引值，如果没有返回-1. 4.lastIndexOf public int

* lastIndexOf(Object obj) 获取obj在集合中第一次出现的索引值(从后向前查找)，如果没有返回-1. 5.remove

* public Object remove(int index); 将index索引位置上的元素移除，返回值就是移除的元素。 6.set

* public Object set(int index,Object obj)

* 将index索引位置的元素使用obj替换，返回值是被替换掉的元素。 7.subList public List subList(int

* fromIndex,int toIndex); 得到从formIndex到toIndex的一个子集。只包含开始，不包含结束

19.List存储学生对象并遍历

public class ListDemo2 {

    public static void main(String[] args) {
        // add();
        // get();
        // indexOf();
        // remove();
        // set();
        subList();
    }

    // subList
    public static void subList() {
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        list.add("e");

        List sub = list.subList(1, 3);
        System.out.println(sub);
        
        System.out.println(list);
    }

    // set
    public static void set() {
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        System.out.println(list);// [a,b,c]
        Object obj = list.set(1, "ok");
        System.out.println(list); // [a,ok,c]
        System.out.println(obj); // b
    }

    // remove
    public static void remove() {
        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        Object obj = list.remove(2);
        System.out.println(list);
        System.out.println(obj);
    }

    // add
    public static void add() {

        List list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        System.out.println(list);

        list.add(1, "ok");
        System.out.println(list);
    }

    // get
    public static void get() {

        List list = new ArrayList();
        list.add(10);
        list.add(20);
        list.add(30);

        Object obj = list.get(1);
        System.out.println(obj);
    }

    // indexOf
    public static void indexOf() {

        List list = new ArrayList();
        list.add("a");
        list.add("b");
        list.add("c");
        int index = list.indexOf("bbb");
        System.out.println(index);
    }

}

20.ListIterator的特有功能

ListIterator可以做双向遍历 Iterator只能做从上到下遍历
ListIterator可以在遍历过程中执行 add set remove

Iterator只能做remove

public class ListDemo4 {

    public static void main(String[] args) {

        // 1.创建一个List集合
        List list = new ArrayList();

        // 2.向集合中添加元素
        for (int i = 0; i < 10; i++) {
            list.add(i);
        }
        // 3.使用ListIterator进行遍历
        // 3.1 hasNext next 从上到下
        // ListIterator lit = list.listIterator();
        // for (; lit.hasNext();) {
        // System.out.println(lit.next());
        // }
        // System.out.println("------------------------------------------");
        //
        // // 3.2 hasPrevious previous 从下向上遍历
        // for (; lit.hasPrevious();) {
        // System.out.println(lit.previous());
        // }
        ListIterator lit = list.listIterator(3);

        // System.out.println(lit.previous());

        // System.out.println(lit.next());

    }
}