常用对象API(基本数据类型对象包装类)
package cn.itcast.wrapper.demo;
public class WrapperDemo {
public static void main(String[] args) {
/*
* 基本数据类型包装类：为了方便操作基本数据类型值，将其封装成了对象，在对象中定义了属性和行为丰富了该数据的操作。
* 用于描述该对象的类就称为基本数据类型包装类。
* byte--Byte(右边为类的描述)
* short--Short（下面有些错乱，自己去辨别）
* int--Integer
* long--Long
* char--Float
* float--Double
* double--Character
* boolean--Boolean
*
* 该包装对象主要用基本类型和字符串之间的转换。
*
* 基本类型--->字符串
* 1.基本类型数值+""
2.用String类中的静态方法ValueOf（基本类型数据）
字符串---》基本类型
1.使用包装类中的静态方法 xxx paraseXxx("xxx类型的字符串");
int pareInt("intstring");
long parseLong(String s);(需要掌握其规律性)
boolean parseBoolean("booleanstring");
只有Character没有parse方法
2.如果字符串被Integer进行对象的封装。可使用另一个非静态的方法，intValue();
将一个Integer对象转成基本数据类型值。
*/
//int num;
System.out.println(Integer.MAX_VALUE);//可以打印整型数据的最大值、最小值
System.out.println(Integer.toBinaryString(6));//-6的二进制就是+6的二进制形式取反+1
System.out.println(Integer.toBinaryString(-6));
int num=4;
Integer i=new Integer(num); //这样就可以就把基本数据类型变成对象了。查看API文档里面的构造函数
System.out.println(i.intValue());//不过这样做没有什么意义,本来就可以直接打印4.
System.out.println(Integer.parseInt("123")+1);//这个就是parseInt的用法，而这里可以用静态。
//System.out.println(Integer.parseInt("123abc")+1); 会有异常，可以测试出里面是否输入的是否是数字。必须得传数字格式的字符串。
if(Boolean.parseBoolean("true"))
System.out.println(num);//不知道为什么这条语句不输出结果呢？？？上面不是为真吗？ 后来输出结果了。
Integer b=new Integer("123");
System.out.println(b.intValue());
/*
* 整数具备不同的进制体现。
* 十进制-->其他进制
*
*
* 其他进制-->十进制
*
*
*/
System.out.println(Integer.toBinaryString(60));
System.out.println(Integer.toOctalString(60));
System.out.println(Integer.toHexString(60));
System.out.println(Integer.toString(60,16));//将60转化为16进制，后面的参数就是你想要转换的进制数
//其他进制-->十进制
System.out.println(Integer.parseInt("110",10));
System.out.println(Integer.parseInt("110",2));//输出为6，把前面当作2进制输出
Integer a=new Integer("3");
Integer c=new Integer(3);
System.out.println(a==c);//只要是2个new，显然就会不同。
System.out.println(a.equals(c));//true，因为Integer覆盖了Object里面的方法，其实比较的是数值是否相同。
System.out.println(a.compareTo(c));//结果为0，说明比较对象相同
}
}常用对象API(基本数据类型对象包装类-JDK1.5自动装箱拆箱)
package cn.itcast.wrapper.demo;
public class WrapperDemo2 {
public static void main(String[] args) {
int num=4;
Integer i=4;//i=new Integer(4); 自动装箱jdk1.5后出现的新特性，简化书写了而已。其实在内存中还是原来的处理方式。
i=i+6;//i=new Integer(i.intValue()+6);其实i这个对象变为基本数据类型,自动拆箱
Integer a=new Integer(127);
Integer b=new Integer(127);
System.out.println(a==b); //false
System.out.println(a.equals(b));//true
Integer x=127; //jdk1.5以后，自动装箱，如果装箱的是一个字节，那么该数据会被共享而不会重新开开辟空间。如果为129
Integer y=127;
System.out.println(x==y);//true当超过127后就为false
System.out.println(x.equals(y));//true
}
}集合框架
用于存储对象的容器。集合本身其实也是一种对象。数组是固定长度，集合是可变长度的。
特点：
1. 用于存储对象的容器。
2. 集合的长度是可变的
3. 集合中不可以存储基本数据类型值。
在Java.util（工具）包里面
集合容器因为内部的数据结构不同，有多种具体容器。不断的向上抽取，就形成了集合框架。框架的顶层就是Collection接口：
Collection的常见方法：（集合框架中的常用方法）
1. 添加
Boolean add(E e)把E理解为Object就可以，其实jdk1.4的时候就是Object，jdk1.5添加了新特性。
Boolean addAll(Collection coll)一次添加一堆对象
2. 删除
Delete
Boolean remove(Object obj);
Boolean removeAll(Collection coll);
Void clear();//将集合中的所有元素都删除
3. 判断
Boolean contains(Object obj);
Boolean containsAll(Collection coll);
4. 获取
int size();
迭代器：专门用于取出集合中方法的元素。
Iteartor Iterator();返回值也特有趣，返回值是迭代器对象。
5. 其他
Boolean retainAll(Collection coll);取交集
Object[] toArray();将集合转化为数组
上述方法演示：
package cn.itcast.p3.collection.demo;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo {
public static void main(String[] args) {
Collection coll=new ArrayList();//创建子类对象（需要去查API）。然后再导下包(ctrl+shift+o键就可以实现快捷键导包)。
//show(coll);
Collection c1=new ArrayList();
Collection c2=new ArrayList();
show(c1,c2);
}
public static void show(Collection c1,Collection c2) {
//给c1添加元素
c1.add("abc1");
c1.add("abc2");
c1.add("abc3");
c1.add("abc4");
//给c2添加元素
c2.add("abc2");
c2.add("abc6");
c2.add("abc7");
System.out.println("c1:"+c1);
System.out.println("c2:"+c2);
//演示addAll
//c1.addAll(c2);
/*演示removeAll
//boolean b=c1.removeAll(c2);//将2个集合中的相同元素从调用removeAll的集合中删除。
//System.out.println("removeAll"+b);
*
*/
/*演示containsAll
boolean b=c1.contains(c2);
System.out.println("containsAll"+b);//不包含后面的集合，所以打印false
*/
//演示retainAll
boolean b=c1.retainAll(c2);//取交集，删除不同元素和removeAll功能相反。
System.out.println("c1:"+c1);
}
public static void show(Collection coll) {//需要导包，刚刚谷歌输入法的ctrl+shift+o与现在的导包操作相互冲突。
//1。添加元素。add。
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
//2.删除元素。remove
coll.remove("abc2");//集合的remove是会改变集合的长度
//清空集合
// coll.clear();
System.out.println(coll.contains("abc3"));
System.out.println(coll);//直接可以将里面的字符串打印出来【abc1,abc2,abc3】
}
}迭代器的使用
package cn.itcast.wrapper.demo;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class ItetatorDemo {
public static void main(String[] args) {
Collection coll = new ArrayList();
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
coll.add("abc4");
//使用了Collection中的iterator()方法。调用集合中的迭代器方法，是为了获取集合汇中的迭代器对象。
// Iterator it =coll.iterator();
// System.out.println(it.next());
//System.out.println(it.next());//next方法会自动往后走着去取。 分别打印abc1，abc2但是这样去取有点麻烦，可以如下循环
// while(it.hasNext()) {
// System.out.println(it.next());
// }
for(Iterator it=coll.iterator();it.hasNext(); ) {//和上面的循环一模一样的效果，开发多用这个，可以节约内存。
System.out.println(it.next());
}
}
}迭代器的原理（有点懵比）
Collection下面有很多子类
娃娃机的例子：
夹子就是迭代器，操作杆和按钮就是实现规则，至于夹子如何实现是内部的事情。
（不能到里面拿夹子，就跟不能直接new 对象一样的道理。我把夹子封装成一个对象定义在容器里面，具备移动、抓、放到功能，不能直接new夹子对象，但是可以获取到夹子对象。投币之后获取到夹子对象，有了操作它的资格。这个对象就可以用了，调用它的功能就可以。夹子每一个容器都有可能不一样）
获取：该对象依赖于具体容器，因为每一个容器的数据结构不同。所以该迭代器对象是在容器中内部实现的。对于使用容器者而言，具体的实现不重要。只要通过容器获取到该实现的迭代的对象即可。也就是iterator方法。
Itetator接口对所有的Collection容器进行元素取出的公共接口。
常用对象API(集合框架-List和Set的特点)
Collection
接口List有许多的子类：有序（存入和取出的顺序一致），元素都有索引（角标），元素可以重复。
Set：元素不能重复，一般无序，但也有可能有序。
常用对象API(集合框架-List集合的常见方法)
List特有的常见方法：有一个共性特点都可以操作角标。
1. 添加
Void add(index,element)
Void add(index,collection)
2.删除
Object remove(index)
3.修改
Object set(index,element)
4.查找（获取）
Object get(index)
Int indexOf(object)
Int lastIndexOf(object)
List subList(from,to);包含头不包含尾
演示：
package cn.itcast.p4.list.demo;
import java.util.ArrayList;
import java.util.List;
public class ListDemo {
public static void main(String[] args) {
List list =new ArrayList();
show(list); //导包的时候要小心，list有狠多包，导入util包即可。
}
private static void show(List list) {
//添加元素
list.add("abc1");
list.add("abc2");
list.add("abc3");
System.out.println(list);
//插入元素
//list.add(1, "abc9");
//删除元素
//System.out.println("remove:"+list.remove(2));
//修改元素
//System.out.println("set:"+list.set(1, "abc8"));
//获取元素
//System.out.println("get:"+list.get(0));
//获取子列表
System.out.println("sublist:"+list.subList(1, 2));//包含1，不包含2.角标从0开始算起
System.out.println(list);//凡是能操作角标的全是特有方法，List集合能够完成对元素的增删改查。
}
}常用对象API(集合框架-ListIterator接口)
package cn.itcast.p4.list.demo;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class ListDemo2 {
public static void main(String[] args) {
List list=new ArrayList();
//show(list);
list.add("abc1");
list.add("abc2");
list.add("abc3");
ListIterator it=list.listIterator();//获取列表迭代器对象
//它可以实现在迭代过程中完成对元素的增删改查，只有list集合具备该迭代功能。
while(it.hasNext()) {
Object obj=it.next();
if(obj.equals("abc2")) {
it.add("abc9");//现在不用集合了
}
}
while(it.hasPrevious()) {
System.out.println("previous:"+it.previous());
System.out.println(list);
}
/*Iterator it =list.iterator();
while(it.hasNext()) {
Object obj=it.next();//用object接收下 出现该异常java.util.ConcurrentModificationException去API文档下查看下该异常是怎么一回事
//在迭代过程中不要使用集合操作元素，容易出现异常。
//可以使用Iterator接口的子接口ListITerator来完成在迭代中对元素进行更多的操作
if(obj.equals("abc2")) {
list.add("abc9"); //添加到这个元素迭代器并不知道。因为现在迭代器操作这些元素，而在迭代器操作的过程中，你又用集合在操作这些元素。所以引发异常。
//迭代器只有3个方法，但是Iterator的子接口有很多方法可以使用。
}
else
System.out.println("next:"+obj);
}
System.out.println(list);*/
}
private static void show(List list) {
list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
Iterator it =list.iterator();
while(it.hasNext()) {
System.out.println("next:"+it.next());
}
//list特有的取出元素方式之一
for(int x=0;x<list.size();x++)
System.out.println("get:"+list.get(x));
}
}常用对象API(集合框架-List常用子类的特点)
如上图所示，虚线框的都是接口。真正使用的时候，一般使用的都是接口的子类。
List：
1. Vector：内部是数组数据结构，是同步的。增删、查询都很慢
2. ArrayList：内部是数组数据结构，是不同步，也即是线程不安全。替代了Vector。反之效率更高。但是遇到多线程怎么办呢？（加锁或者其他处理方式，vector已经淘汰，不会再用了。）查询速度快
3. LinkedList：链接列表实现，内部是链表数据结构，对增删速度很快。 非同步（效率更高）
链表为什么查询慢？虽然是挨个判断，但是因为相邻的空间不连续的，相对较慢。链表也可以有编号，但是地址不连续是硬伤，查询还是慢。