基本数据类型对象包装类：

　　为了方便操作基本数据类型值，将其封装成了对象，在对象中定义了属性和行为丰富了该数据的操作。 用于描述该对象的类就称为基本数据类型对象包装类。

　　byte——Byte　　short——Short　　int——Integer　　long——Long　　

　　float——Float　　double——Double　　char——Character

　　boolean——Boolean

　该包装对象主要用于基本类型和字符串之间的转换。

　　基本类型---->字符串

　　　　1、基本类型数值 + “”

　　　　2、用于String类中的静态方法valueOf(基本类型数值);

　　字符串---->基本类型

　　　　1、使用包装类中的静态方法  xxxx parseXxx("xxx类型的字符串");

　　　　　　int parseInt("intString");

　　　　　　long parseLong("longString");

　　　　　　注： 只有Character 没有parse方法。

　　　　2、如果字符串被Integer进行对象的封装

　　　　　　可以使用另一个非静态的方法， intValue();

　　　　　　将一个Integer 对象转换成基本类型值。

　　进制转换 ：

　　　　十进制----> 其他进制

　　　　　　toBinaryString

　　　　　　toOctalString　　toHexString

　　　　其他进制--->十进制

　　　　　　parseInt( "string" ,radix); // radix----其他进制2，8，16。。。、

集合框架：

　　　　集合类的由来：

　　　　　　对象用于封装特有数据，对象多了需要存储，如果对象的个数不确定。就编使用集合容器进行存储。

　　　　集合的特点：

　　　　　　1、用于存储对象的容器； 2、集合的长度是可变的； 3、集合中不可以存储基本数据类型值。

　　　　集合容器因为内部数据结构不同，有多种具体容器。 不断的向上抽取，进形成了集合框架。

　　框架的顶层 Collection接口：

　　　Collection的常见方法：

　　1、添加：

　　　　boolean add(Object obj);

　　　　boolean addAll(Collection coll);

　　2、删除

　　　　boolean remove(Object obj);

　　　　boolean removeAll(Collection coll);

　　　　void clear();

　　3、判断

　　　　boolean contains(Object obj);

　　　　boolean containsAll(Collection coll);

　　　　boolean isEmpty(); 　　//判断集合中是否有元素

　　4、获取

　　　　int size();

　　　　Iterator iterator(); 　　//取出元素的方式 ： 迭代器

　　　　该对象必须依赖于具体容器，因为每一个容器的数据结构都不同。

　　　　所以该迭代器对象是在容器中进行内部实现的。

　　　　对于使用容器者而言，具体的实现不重要，只要通过 容器获取到该实现的迭代器的对象即可， 也就是iterator 方法。

　　　　Iterator 接口就是对所有的Collection 容器进行元素取出的公共接口。

　　5、其他

　　　　boolean retainAll(Collection coll);　　取交集

　　　　Object[]  toArray();　　将集合转换成数组

————集合补充部分

　　集合框架的工具类。

　　　Collections　：

　　　　public static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
　　　　　　参数：
　　　　　　　　list - 要搜索的列表
　　　　　　　　key - 要搜索的键
　　　　　　　　c - 排序列表的比较器　null 值指示应该使用元素的自然顺序。
　　　　　List<String> list = new ArrayList<String>();
　　　　　list.add("fdssfse");
　　　　　list.add("ds");
　　　　　　替换：　　replaceAll(list,"ds", "dfj");
　　　　　　反转：　　reverse(list);

　　　　重要：
　　　　　　 Collections.reverseOrder() : 返回一个反转排序的比较器。
　　　　　　 Collections.shuffle(list); 把集合list 中的元素进行随机的排序。
　　

　　Arrays:
　　　　　　用于操作数组的工具类。里面都是静态方法。

　　　　Arrays.asList(数组名) ： 将数组变成List集合。
　　　　　　把数组变成List集合有什么好处？
　　　　　　　　---> 可以使用集合的思想和方法来操作数组中的元素。
　　　　　　注意： 将数组变成集合，不可以使用集合的增删方法。 因为数组的长度是固定
　　　　　　　　　　可以用 contains get indexOf() subList() .....
　　　　　　　　　如果增删 会出现UnsupportedOperationException 异常

　　　如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转换成集合中的元素；
　　　如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。

　　　　集合名.toArray(指定类型的数组) ：集合变数组
　　　　　　　Collection 接口中的toArray 方法
　　　　　　ArrayList<String> a1 = new ArrayList<String>();
　　　　　　a1.add("fdsf");
　　　　　　a1.add("fdsfag");

　　　　　　String[] arr = a1.toArray(new String[a1.size()]);

　　　　　　1、指定类型的数组到底要定义多长呢？
　　　　　　　　当指定类型的数组长度小于集合的size，那么该方法内部会创建一个新的数组，长度为集合的size。
　　　　　　　　当指定类型的数组长度大于集合的size，就不会新创建数组，而是使用传递进来的数组。
　　　　　　　　所以创建一个一个刚刚好的数组最优。
　　　　　　2、为什么要将集合转换为数组？
　　　　　　　　　　为了限定对元素的操作，不需要进行增删了。

　　高级for 循环：
　　　　　格式：
　　　　　for(数据类型 变量名 ： 被遍历的集合（Collection）或者数组) 　　　　　　　　　　{

　　　　　}

　　　　　对集合进行遍历。
　　　　　　　只能获取集合元素，但是不能对集合进行操作。

　　　　　迭代器除了遍历，还可以进行remove集合中的元素动作。
　　　　　如果是用ListIterator ，还可以在遍历过程中对集合进行增删改查的动作。

　　　传统for、高级for的区别：
　　　　　　高级for有一个局限性，必须有被遍历的目标 ； 建议在遍历数组的时候，还是希望是用传统for，因为传统for可以定义脚标。

　　可变参数： 格式 ：如 int...
　　　　其实就是上一次数组参数的简写形式；
　　　　不用每一次都手动的建立数组对象；
　　　　只要将要操作的元素作为参数传递即可；
　　　　隐式将这些参数封装成了数组。

　　方法的可变参数： 在使用的时候注意，一定要定义在可变参数列表的最后面。

　　
　　静态导入：
　　　　当类名重名时，需要指定具体的包名。
　　　　当方法重名时，需要指定具备所属的对象或者类。
　　import static java.util.Arrays.*; 导入的是Arrays这个类中的所有静态成员
　　import static java.lang.System.*; 导入了System类中的所有静态成员。

　　其他对象 :

　　(System)： 类中的方法和属性都是静态的

　　　　out ：标准输出， 默认是控制台
　　　　in ：标准输入， 默认是键盘
　　　　描述系统一些信息；
　　　　获取系统属性信息： Properties getProperties();

　　　因为properties 是Hashtable的子类， 也就是Map集合一个子类对象。
　　　那么可以通过map的方法取出该集合中的元素。
　　　该集合中存储都是字符串，没有泛型定义。

　　　　如何在系统中自定义一些特有的信息呢？
　　　　　　System.setProperty("mykey","myvalue");

　　　　获取指定属性信息
　　　　　　String value = System.getProperty("os.name");

　　　　在JVM启动时，动态加载一些属性信息：
　　　　　　String v = System.getProperty("haha");
　　　　　　// DOS 命令中 java -Dhaha="fdsfk" 类名
　　　　
　　　　获取所有属性信息：
　　　　　　for(Object obj : prop.keySet()) {
　　　　　　　　String value = (String)prop.get(obj);
　　　　　　　　System.out.println(obj+"::"+value);
　　　　　　}

　(Runtime):
　　　　该类并没有提供构造函数；
　　　　说明不可以new对象，那么会直接想到该类中的方法都是静态的；
　　　　发现该类中还有非静态方法；
　　　　说明该类肯定会提供了方法获取本类对象，而且该方法是静态的，并返回值类型是本类类型。
　　　　
　　　　由这个特点可以看出该类使用了单例设计模式。

　　　　该方式是 static Runtime getRuntime();

　　Runtime r = Runtime.getRuntime();
　　r.exec("winmine.exe"); 　　//打开路径下的可执行程序

　　Process p = r.exec("notepad.exe SystemDemo.java"); //用notepad应用程序打开 后面的文件。
　　p.destroy(); // 结束进程

　　Date类：

　　　　Date d = new Date();
　　　　Sysem.out.println(d); //打印的时间看不懂，希望有些格式
　　　　
　　　　//将模式封装到SimpleDateFormat对象中
　　　　SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 E hh：mm：ss");

　　　　//调用format方法让模式格式化指定Date对象
　　　　String time = sdf.format(d);

　　   Calendar类：

　　　　设置时间： set（year，month， days）；
　　　　添加或者减去：
　　　　　　add(int field, int amount) 
　　　　　　　　　field - 日历字段
　　　　　　　　　amount - 为字段添加的日期或时间量
          根据日历的规则，为给定的日历字段添加或减去指定的时间量。

　　附加小练习： 1、获取任意年的二月有多少天。
　　　　　　　　　　思路：根据指定年设置一个时间就是 c.set(year,2,1);//某年的3月1日；
　　　　　　　　　　　　　c.add(Calenar.DAY_OF_MONTH,-1); //3月1日 往前推一天就是 2月的最后一天。
　　　　　　　　2、获取昨天的现在这个时刻。
　　　　　　　　　　　c.add(Calenar.DAY_OF_MONTH,-1)
　　　
　　　Math—Random ：
　　　　 double d = Math.ceil(16.34); //ceil返回大于指定数据的最小整数
　　　　　double d1 = Math.floor(12.34); //floor返回小于指定数据的最大整数
　　　　　　
　　　　　long l = Math.round(12.54); //四舍五入

　　　　　//output ： 17.0　　12.0　　13

　　　　//产生一个1~10的随机数
　　　　Random r = new Random();
　　　　for(int x=0; x<10; x++) {
　　　　　　//int d = (int)(Math.Random)*10+1;
　　　　　　int d = r.nextInt(10)+1;
　　　　}

　　附加小练习：1、给定一个小数 ，保留小数后两位