零基础学习java（七）

java语言基础知识

1：正则表达式：
(1)符合一定规则的字符串。(2)规则：A：字符 x 字符 x\\ 反斜线字符 \r 回车\n 换行。
B：字符类：[abc] a、b 或 c（简单类。 [^abc] 任何字符，除了 a、b 或 c（否定）。 
[a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内。[0-9] 0-9的数字字符。
C：预定义字符类 . 任何字符 \d 数字：[0-9]。\w 单词字符：[a-zA-Z_0-9]在正则表达式中可以组成单词的字符。 
D：边界匹配器 ^ 行的开头  $ 行的结尾\b 单词边界 (出现的地方不能是单词字符。)
E：数量词：X? X，一次或一次也没有 X* X，零次或多次 X+ X，一次或多次 
X{n} X，恰好 n 次。          X{n,} X，至少 n 次。     X{n,m} X，至少 n 次，但是不超过 m 次9 
(3)正则表达式的功能：
A:判断功能 String -- public boolean matches(String regex)。
B:分割功能 String -- public String[] split(String regex)。
C:替换功能 String -- public String replaceAll(String regex,String replacement)。
D:获取功能 Pattern -- public static Pattern compile(String regex)。
  public Matcher matcher(String input)Matcher -- public boolean find()。           public String group()。
2：Random用于产生随机数的类。
(1)构造方法： Random:没有种子。每次产生的都是变化的。
Random(long seed):有种子。种子一样，产生的随机数一致。
(2)成员方法： int nextInt():返回int范围 int nextInt(int n):返回[0,n)范围
3：System系统类，提供了一些静态的功能供我们使用。
(1)成员方法： A:public static void gc() 运行垃圾回收器。  B:public static void exit(int status)
终止当前正在运行的 Java 虚拟机。参数用作状态码；根据惯例，非 0 的状态码表示异常终止。 
C:public static long currentTimeMillis()返回以毫秒为单位的当前时间。
D:public static void arraycopy(Object src,  int srcPos,     Object dest,   int destPos, int length)
4：Date/DateFormat/Calendar
(1)Date 日期类。可以精确到毫秒。
A:构造方法 Date()，             Date(long time)。B:成员方法void setTime(long time) long getTime()。
C:如何得到毫秒值：Date --getTime() System -- currentTimeMillis()
如何设置日期的毫秒值： Date -- Date(long time) Date -- setTime(long time)
(2)DateFormat 对日期进行格式化和解析的类。
A:Date -- Stringpublic final String format(Date date)
B:String -- Datepublic Date parse(String source)
(3)Calendar 日历类。把时间给分割成一个个的日历字段，
   你可以通过get方法根据给定的日历字段获取对应的值。来组合一个完整的时间。
A:根据给定的日历字段获取对应的值public int get(int field)。
B:设置年月日：      public final void set(int year,int month,int date)。
C:根据给定的日历字段和值，来决定是加还是减去对应的值。public void add(int field,int amount)。

5：Collection
(1)我们学习的是面向对象的语言，是以对象为主。如果想操作多个对象，就必须首先把这个多个对象给存储起来。到目前位置，我们仅仅只能使用数组来做这个事情。而数组有一个弊端，就是对象的个数必须是固定的。这个时候，java就提供了另外的一种容器：集合。
(2)数组和集合的区别?
A:数组 长度固定，元素可以是基本类型，也可以是引用类型。只能存储同一种数据类型。
B:集合 长度可变，元素只能是引用类型。可以存储不同的数据类型。
(3)Collection继承体系结构图：
Collection
————|--List
————————|--ArrayList
————————|--Vector
————————|--LinkedList
————|--Set
————————|--HashSet
————————|--TreeSet
分析：从具体到抽象 实现：从抽象到具体 学习：抽象使用：具体
(4)Collection集合的功能概述
A:添加功能
boolean add(Object e):                       //往集合中添加一个元素。
boolean addAll(Collection c):              //往集合中添加一个集合的元素。
B:删除功能
void clear():                                         //移除集合中的所有元素。
boolean remove(Object o):                 //移除集合中指定的一个元素。
boolean removeAll(Collection c):       //移除集合中指定的一个集合的元素。
C:判断功能
boolean contains(Object o)                //判断集合中是否包含指定的元素。
boolean containsAll(Collection c)       //判断集合中是否包含指定的一个集合的元素。
boolean isEmpty()                              //判断集合是否为空。
D:迭代器   Iterator iterator()               //用于获取集合中的元素。
E:长度功能 int size()                    //获取集合中元素的个数。
F:交集功能 boolean retainAll(Collection c)
G:转换为数组 Object[] toArray()      //把集合转换为数组。
(5)迭代器 A:迭代器是集合的一种遍历方式。    B:迭代器的使用步骤     a:通过集合对象获取迭代器对象。
b:通过迭代器对象判断是否有元素。 c:通过迭代器对象获取元素，并移动到下一个位置。
C:每种具体的集合的迭代器的具体实现是在每个具体集合类中。以内部类的方式实现的。
6：List的特点
List 元素有序(存储顺序和取出顺序一致)，可重复。set元素无序，唯一。
(1)List集合的特有功能：(自己补齐 补齐方法的返回值类型和方法说明)
A:添加功能：add(int index,Object) 在指定的位置添加元素。
B:删除功能：remove(int index) 删除指定索引位置的元素，并返回该元素。
C:修改功能：set(int index,Object obj) 用指定的元素修改指定位置的元素，并把修改前的元素返回。
D:获取功能：get(int index) 根据给定的索引，获取元素。
(3)List集合存储字符串并遍历。
a:迭代器 b:普通for(get()和size()结合使用)List集合存储自定义对象并遍历。
(4)ListIterator的使用：
A:可以逆向遍历，但是要先正向遍历，一般不用。
B:并发修改异常的问题： 用迭代器迭代元素的时候，不能通过集合去改变集合。
解决方案： a:集合遍历，集合修改。b:列表迭代器遍历，列表迭代器修改。

7：List的3个儿子

ArrayList:     底层数据结构是数组，查询快，增删慢。        线程不安全，效率高。
Vector:         底层数据结构是数组，查询快，增删慢。         线程安全，效率低。
LinkedList: 底层数据结构是链表，查询慢，增删快。 线程不安全，效率高。
(1)我们到底使用谁呢：看需求：要安全吗?要：Vector不要：ArrayList或者LinkedList查询多：ArrayList增删多：LinkedList。什么都不知道，就用ArrayList。
(2)Vector的特有功能：a:添加元素addElement(Object obj)。b:遍历元素 elementAt(int index)elements()
(3)LinkedList的特有功能及案例：a:添加功能addFirst()、addLast()。b:删除功能： removeFirst()、removeLast()。
c:获取功能 getFirst()、getLast()。
8：泛型
(1)一种把明确数据类型的工作推迟到创建对象或者调用方法的时候才去明确的特殊的数据类型。
默认情况下，泛型指的是Object类型。
(2)泛型的格式： <数据类型>
(3)泛型的好处：A:优化了程序设计，解决了黄色警告线问题。B:把运行时期的异常提前到了编译期间。
C:避免了强制类型转换。
(4)泛型的弊端： 用泛型限定了集合以后，集合中只能存储同一种数据类型。
(5)泛型在什么时候用 看API，如果看到了<>，就说明这里要使用泛型。 一般来说，就是在集合中用。
(6)集合的小问题：A:集合可以存储不同类型的元素，在遍历的时候，给出不同的判断即可。

Object obj = it.next();
if(obj instanceof String) {
...
}else if(obj instanceof Integer) {
}

B:集合中存储的基本类型，其实存储的不是基本类型，而是对应的包装类类型。

         (7)泛型类

class Demo {
public void show(QQ qq) {
...
}
}

(8)泛型方法

class Demo {
public  void method(T t) {
...
}
}

(9)泛型接口

interface Inter {
void show(QQ qq);
}
//方式1
class InterImpl implements Inter {
public void show(String s){

}
} 
//方式2
class InterImpl implements Inter {
public void show(QQ qq){
...
}
}

9：增强for
(1)格式： for(Collection集合或者数组中的元素的数据类型 变量 : Collection集合或者数组的名称) {
使用变量即可。这个变量其实就是集合或者数组中的元素。
}
(2)好处： 简化了集合或者数组的遍历。 (3)把以前集合的案例用增强for改进遍历。

ArrayList array = new ArrayList();
array.add("hello");
array.add("world");
array.add("java");
for(String s : array) {
System.out.println(s);
}

10:Set
(1)Collection 下List 有序，可重复。Set 无序，唯一。
(2)HashSet ：如何保证元素唯一性的底层数据结构是哈希表(散列表)。具体的是由一个元素是单向链表的数组组成。
它依赖于两个方法：hashCode()和equals()方法。执行顺序：先判断hashCode()是否相同，如果相同继承执行equals()方法，看其返回值：true:元素重复，不存储。false:元素不重复，存储。如果不同存储。
注： 看到HashXxx结构的集合就要知道被该集合存储的元素要重写hashCode()和equals()方法。而且是自动生成的。
(3)TreeSet 底层数据结构是二叉树。
如何保证元素的唯一性的， 根据比较的返回值是否是0来决定。
如何保证元素的排序的呢 A:自然排序 元素具备比较性让集合中被存储的元素所属的类实现Comparable接口。   B:比较器排序 集合具备比较性，在创建集合对象的时候，让构造方法接收一个Comparator接口的子类对象。
(4)LinkedHashSet底层由链表和哈希表组成。由链表保证有序。由哈希表保证唯一。
11：集合的遍历方式
Collection 迭代器，增强for。List 普通for
Set：A:迭代器，增强for可以看成是一种方案。B:一般来说，仅仅是为了遍历，我们选择增强for。
C:如果在遍历的时候，要使用到索引，必须使用普通for。