泛型

泛型：
(1)为什么会出现泛型？
因为集合存放的数据类型不固定，故往集合里面存放元素时，存在安全隐患，
如果在定义集合时，可以想定义数组一样指定数据类型，那么就可以解决该类安全问题。
JDK1.5后出现了泛型，用于解决集合框架的安全问题。
泛型是一个类型安全机制。
(2)泛型定义格式：通过<>来定义要操作的引用数据类型
ArrayList<String> al = new ArrayList<String>;
(3)泛型的好处：
**将运行时期出现的ClassCastException(类型转换异常)问题转移到编译时期；
**避免了强制转换的麻烦
(4)什么时候定义泛型？
泛型在集合框架中很常见，只要见到<>就要定义泛型。其实<>就是用来接收类型的。
当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可
(5)泛型的形式
**泛型类：即自定义泛型类
A：当类中要操作的引用数据类型不确定时，早起定义Object来完成扩展，现在定义泛型来完成
B：局限性：泛型类定义的泛型，在整个类中有效，如果该泛型类的方法被调用，
  当泛型类的对象明确要操作的类型后，所有要操作的类型就被固定。
**泛型方法：泛型放在返回值前面，修饰符的后面
A:为了避免泛型类的局限性，让不同方法可以操作不同的类型，而且类型还不确定，
 则可以将泛型定义在方法上
B:特殊之处：静态方法不可以反问类上定义的泛型
 如果静态方法操作的应用数据类型不确定，可以讲泛型定义在静态方法上
**泛型接口：
当泛型定义在接口上时，则子类中要指定实现接口类型，同时还可以子类也可以定义为泛型类
(6)泛型的高级应用：？通配符
**当指定两种泛型的集合，则迭代时也要定义两种泛型的迭代器，麻烦，此时可通过将迭代器的泛型
 改为？，如Iterator<?> it=al.iterator();
**两种泛型限定
向上限定： ? extends E  ;E可以接收E类型或者E的子类
向下限定： ? super E  ;E可以接收E类型或者E的父类
14、高级for循环
(1)JDK1.5新特性，代替迭代器使用时的不爽，简化书写，底层原理是迭代器凡是支持迭代器的都支持高级for循环
  高级for循环，只用于集合和数组的遍历，集合只能用Collection不能用Map集合
  只能把Map集合转化成Set集合，才能用for循环。
(2)格式
for(数据类型 变量名:被遍历的集合(Collection)或者数组)
{

}
        (3)局限性：
必须要有遍历的目标
对集合或者数组进行遍历时，只能获取集合元素，不能对集合元素进行操作
迭代器除了遍历，还可以进行remove操作集合中的元素
列表迭代器还可以在遍历过程中进行增删改查的操作
(4)传统for循环和高级for循环的区别
高级for循环有一个局限性，就是必须要有遍历的目标(集合或者数组)
遍历数组时建议使用传统for循环，因为可以定义角标，比如打印100次helloworld时用传统for循环方便
15、可变参数
(1)数组的可变参数
格式：
int... arr
(3)方法的可变参数
格式：
public static void show(String str，int... arr)
{


}
注意：可变参数一定要放在参数列表的最后面
16、静态导入：
**import static java.util.Arrays.*  导入的是Arrays这个类中所有的静态方法
**当类名重名时，需要制定具体的报名
**当方法重名时，需要制定具体所属的对象或者类
17、Collections类：
(1)此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。
(2)静态方法摘要：
static <T> boolean addAll(Collection<? super T> c, T... elements) 
将所有指定元素添加到指定 collection 中。
static <T> void fill(List<? super T> list, T obj) 
使用指定元素替换指定列表中的所有元素。
static <T> boolean replaceAll(List<T> list, T oldVal, T newVal) 
使用另一个值替换列表中出现的所有某一指定值。 
static void reverse(List<?> list) 
反转指定列表中元素的顺序。 
static <T> Comparator<T>  reverseOrder() 
返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序
static <T> Comparator<T> reverseOrder(Comparator<T> cmp) 
返回一个比较器，它强行逆转指定比较器的顺序。 
(3)Collections类特牛的方法：
集合有一个共同的缺点，那就是线程不安全，被多线程操作时，容易出现问题，虽然可以自己加锁
但是麻烦。Collections提供特牛的方法，就是给它一个不同步的集合，它返回一个同步的安全的集合


static <T> Collection<T> synchronizedCollection(Collection<T> c) 
返回指定 collection 支持的同步（线程安全的）collection。 
static <T> List<T>  synchronizedList(List<T> list) 
返回指定列表支持的同步（线程安全的）列表。 
static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) 
返回由指定映射支持的同步（线程安全的）映射。 
static <T> Set<T> synchronizedSet(Set<T> s) 
返回指定 set 支持的同步（线程安全的）set。 
static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m)
返回指定有序映射支持的同步（线程安全的）有序映射。 
static <T> SortedSet<T>  synchronizedSortedSet(SortedSet<T> s)
返回指定有序 set 支持的同步（线程安全的）有序 set。 
18、Arrays类：
此类包含用来操作数组（比如排序和搜索）的各种方法。里面都是静态方法。
如果指定数组引用为 null，则此类中的方法都会抛出 NullPointerException。
(1)静态方法摘要：
static <T> List<T> asList(T... a)
返回一个受指定数组支持的固定大小的列表。
注意：
A:该方法将一个数组变成集合后，不可以使用集合的增删方法，因为数组的长度是固定的！
         如果增删，则发生UnsupportedOprationException(不支持操作异常)
B:如果数组中的元素都是基本数据类型，则该数组变成集合时，会将该数组作为集合的一个
 元素出入集合
C:如果数组中的元素都是对象，如String，那么数组变成集合后，数组中的元素就直接转成
 集合中的元素
19、数组变集合以及集合变数组的对比：
(1)数组变集合：
方法：static <T> List<T> asList(T... a) 返回一个受指定数组支持的固定大小的列表。
好处：可以使用集合的思想和方法操作数组中的元素，数组是一个对象，但是数组中的功能很少
(2)集合变数组：
方法：Collction中的toArray方法
好处：可以限定对集合元素的操作，防止对集合的元素进行增删，因为数组长度是固定的。


20、Collections类和Arrays类的使用。(重点)
A:Collections
排序
二分查找
发转
B:Arrays
把数组变成字符串输出
排序
二分查找
21、System：
(1)描述系统信息的类
(2)该类没有构造方法，该类的方法和属性都是静态的
(3)字段摘要：
static InputStream in  “标准”输入流。   
static PrintStream out  “标准”输出流。         
(4)方法摘要：
static void exit(int status) 终止当前正在运行的 Java 虚拟机。 
static void gc() 运行垃圾回收器。
static Properties getProperties()  确定当前的系统属性          
static String getProperty(String key) 获取指定键指示的系统属性。     
static String getProperty(String key, String def) 获取用指定键描述的系统属性。 
static void setIn(InputStream in) 重新分配“标准”输入流。           
static void setOut(PrintStream out) 重新分配“标准”输出流。 
static void setProperties(Properties props) 将系统属性设置为 Properties 参数。           
static String setProperty(String key, String value) 设置指定键指示的系统属性。
22、Runtime:
(1)每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。
  可以通过 getRuntime 方法获取当前运行时。 应用程序不能创建自己的 Runtime 类实例。
(2)该类没有构造函数，也就是它不能直接创建对象，但是它里里面的方法又不是静态的
  ，故它一定有一个方法返回本类对象
(3)故该类是单例设计模式，保证在内存中只有一个对象
(4)方法摘要：
Process exec(String command) 在单独的进程中执行指定的字符串命令
void gc() 运行垃圾回收器。
static Runtime getRuntime() 返回与当前 Java 应用程序相关的运行时对象
void exit(int status) 通过启动虚拟机的关闭序列，终止当前正在运行的 Java 虚拟机
23、Date:
(1)Date接口表示特定的瞬间，精确到毫秒
(2)构造方法
Date() 分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
Date(long date) 分配Date对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，
即1970年1月1日00:00:00GMT）以来的指定毫秒数。
(3)方法摘要：
int compareTo(Date anotherDate) 比较两个日期的顺序。          
boolean equals(Object obj) 比较两个日期的相等性。
24、Calendar：
(1)直接已知子类： GregorianCalendar 
(2)构造方法：
protected  Calendar() 构造一个带有默认时区和语言环境的 Calendar。         
protected  Calendar(TimeZone zone, Locale aLocale)  构造一个带有指定时区和语言环境的 Calendar。         
(3)方法摘要：
static Calendar getInstance() 使用默认时区和语言环境获得一个日历。




四、jdk1.5的新特性
(1)静态导入：
**import语句可以导入一个类或某个包中的所有类
**import static语句导入一个类中的某个静态方法或所有静态方法
 静态导入后，静态方法前面就不用写类名.方法的方式类调用
**语法举例： 
import static java.lang.Math.sin;//导入一个静态方法
import static java.lang.Math.*; //导入一个类中的所有静态方法
**静态导入使用注意：
当类名重复时，需要制定具体的包名；
当方法重名时，需要制定具体所属的对象或者类
(2)可变参数：
**可变参数的特点：
*可变参数只能出现在参数列表的最后；
*...位于变量类型和变量名之间，前后有无空格都可以;
*调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，
在方法体中以数组的形式访问可变参数。
**可变参数举例：
*变量类型... 变量名 如 int... arr 表示可变参数数组
*public static void show(String str , int... arr){}
(3)增强for循环：
**语法：
for ( type 变量名：集合变量名 )  { … } 
**注意事项：
迭代变量必须在( )中定义！
集合变量可以是数组或实现了Iterable接口的集合类
**举例： 
public static int add(int x,int ...args) {
int sum = x;
for(int arg:args) {
sum += arg;
}
return sum;
}
**增强for循环代替了迭代器使用的不爽，简化书写
**增强for循环局限性：
对集合或者数组进行遍历时，只能取元素，不能对集合进行操作
(4)基本数据类型的自动装箱和拆箱
**基本数据类型
byte ---> Byte
short ---> Short
int ---> Integer
long ---> Long
float ---> Float
double ---> Double
char ---> Character
boolean ---> Boolean
**例子：
**装箱：自动把一个基本数据类型的数据装箱成一个该类型数据的对象引用
Integer i = 3;(jdk1.5之前这样写是不行的，编译报错)
**拆箱：自动把一个基本数据类型的对象引用拆箱成一个基本数据类型的数据，再参与运算
Integer i = 12;
sop(i+4);
**享元模式：
Integer num1 = 12;
Integer num2 = 12;
System.out.println(num1 == num2);//打印true


Integer num5 = Integer.valueOf(12);
Integer num6 = Integer.valueOf(12);
System.out.println(num5 == num6);//打印true


Integer num3 = 129;
Integer num4 = 129;
System.out.println(num3 == num4);//打印false


为什么前面的返回true而后面的运算返回false呢？
对于基本数据类型的整数，装箱成Integer对象时，如果该数值在一个字节内,(-128~127)，
一旦装箱成Integer对象后，就把它缓存到磁里面，当下次，又把该数值封装成Integer对象时
会先看磁里面有没有该对象，有就直接拿出来用，这样就节省了内存空间。因为比较小的整数，
用的频率比较高，就没必要每个对象都分配一个内存空间。
这就是享元模式！比如26个英文字母，10个阿拉伯数字