集合：
List和Set
List可重复，Set可重复
重不重复就是用equals比较的结果
查看集合中是否包含给定的元素
没重写equals还是判断是否是同一个对象，用的双等于
c.contanins(元素); 判断集合中是否包含某元素
包含取决于集合中的元素是否有与给定元素equals比较为true的
但是没有放进集合也有可能不包含。
给定的元素与集合中的每一个元素equals比较。
集合的其他方法
public static void main(String[] args) {
Collection c = new ArrayList();
int s1 = c.size();
System.out.println("size:"+s1);
/*
* boolean isEmpry()
* 查看集合中是否不含有任何元素
* 就是是空的吗？
*/
boolean e1 = c.isEmpty();
System.out.println(e1);
//增加元素
c.add("111");
c.add(123);
int s2 = c.size();
System.out.println("size:"+s2);
boolean e2 = c.isEmpty();
System.out.println(e2);
c.clear();
boolean e3 = c.isEmpty();
System.out.println(e3);
}
addAll、containsAll
一般也在集合中放同一类的元素
addALL方法
public static void main(String[] args) {
Collection conn1 = new ArrayList();
conn1.add("java");
conn1.add(".net");
conn1.add("c#");
conn1.add("php");
System.out.println(conn1);
Collection conn2 = new ArrayList();
conn2.add("android");
conn2.add("ios");
//addALL就是把另一个List中的元素放入这个List中
conn1.addAll(conn2);
System.out.println(conn1);
}
Collection conn3 = new ArrayList();
conn3.add("java");
conn3.add("ios");
//查看当前集合中是否保护给定集合中的所有元素，
//也是根据元素的equals来判断的。
boolean b = conn1.containsAll(conn3);
System.out.println("全包含:"+b);
}
删除 remove
传入参数： 要删除什么传入什么，然后比较用的是equals
boolean remove(object o)
从当前集合中删除给定元素
删除元素是根据元素的equals的结果判断
remove只删除第一个遇到的元素
使用迭代器遍历List中元素：
public class CollectionIterator {
public static void main(String[] args) {
Collection c = new ArrayList();
c.add("a");
c.add("b");
c.add("c");
c.add("d");
c.add("e");
/*
* Iteartor是一个接口
* java希望我们使用统一的方式遍历所有集合
* 使用迭代器遍历集合必须遵循以下过程
* 问，取，删（删除不是必须操作）
*
*/
Iterator it =c.iterator();
/*
* boolean hashNext（）
* 询问迭代器，遍历的集合是否还有元素可以取出
* 用while循环判断，有就继续取出，在list中都认为是object，什么都能取出来
* 然后用object 接受 取出的，然后在给他强制转换为字符串
*/
while (it.hasNext()){
Object obj = it.next();
String str = (String)obj;
System.out.println(str);
//可以直接： String str = (String)it.next();
}
}!!!
尽量使用字面量.equals(变量)
这样可以避免空指针异常的产生
如果在迭代器中 it.remove();要在前面it.next()才行，然后remove删除当前next出来的元素
。。。。。
另一种遍历集合的方法(java5.0后)
比迭代器更方便：
public static void main(String[] args) {
Collection c = new ArrayList();
c.add("one");
c.add("two");
c.add("three");
c.add("four");
//新循环
for(Object a:c){
String str = (String)a;
System.out.println(str);
}当然也可以用新循环遍历数组
泛型机制：
在类后面加个尖括号 ，一般一个字母，这个类型叫T，也可以叫别的。声明了T这么一个类型。
于是可以 在定义属性时 返回值可以定义为 T这个类型
在用的时候给真实类型
如：
在写一个类，
public class TypeDemo<T>{
private int x;
public TypeDemo(int x){
this.x =x;
}
public String toString(){
return x+"";
}然后在实例化时给到底是什么类型的
TypeDemo<String> t = new TypeDemo<String>(“qw”);在类中的get，set方法中也要设置返回值为T
！！！！！
尖括号中只能写引用类型不能是基本类型也就是说要是用int就要：写 Integer
不能写基本类型，先不告诉他什么类型，后面用的时候告诉他
在集合中的泛型
public static void main(String[] args) {
//所有的集合都支持泛型，那么一般一个集合的类型一样的话，可以直接用泛型指定为什么类型
Collection<String> c = new ArrayList();
c.add("one");
c.add("two");
c.add("three");
c.add("four");
//因为泛型定义了是String，那么直接就可以赋值输出了
for(String o:c){
System.out.println(o);
}
}
迭代器也可以用泛型
Iterator<String>List
分为：
ArrayList和LinkList
ArrayList 内部是数组实现的 适用查找
LinkList内部是用于链表实现的 适用增删
List除了继承Coleection定义的方法外，还根据其线性表的数据结构定义了一系列方法，其中最长远的就是基于下标的get和set方法：
get(int index)
获取集合中指定下标对应的元素，下标从0开始
set(int index ,E element)
将给定的元素存入给定位置，并将原位置的元素返回。
相当于给替换了，然后把集合中的元素取出来。
List<String> c = new ArrayList();
c.add("one");
c.add("two");
c.add("three");
c.add("four");
System.out.println(c.get(1));
System.out.println(c.set(1, "five"));
System.out.println(c.get(1));
}List集合的插入和删除
插入指定位置
List<String> list = new ArrayList();
list.add("one");
list.add("two");
list.add("three");
/*
* void add(int index ,T t)
* 将给定的元素添加到给定的位置上
* 原位置以及后续的元素顺序向后移动
* 插入操作
*/
System.out.println(list);
list.add(1,"123");
System.out.println(list);同样，remove是删除指定下标的元素，然后返回值是删除的元素。
List获取子集的方法：
public class ListDemo3 {
public static void main(String[] args) {
List<Integer> list = new ArrayList();
for (int i=0;i<10;i++){
list.add(i);
}
System.out.println(list);
/*
* List subList(int start, int end)
* 获取当前集合的子集
*/
List<Integer> list1 = list.subList(3, 8);
System.out.println(list1);
}
！！！！！！！
修改子集元素会影响原集合
！！！！！！
List转换为数组：
集合转成数组容易，但是数组只能转为List
public static void main(String[] args) {
Collection<String> c = new ArrayList<String>();
c.add("one");
c.add("two");
c.add("thiree");
//直接用toArray的话返回的是Object
//Object[] array =c.toArray();
//但是向方法里面传个数组就直接可以定义它的类型
String [] array=c.toArray(new String[c.size()]);
//如果传入的数组不够长，他会自己创建个同类型的数组
//长度够就用
}数组转为List
public static void main(String[] args) {
String [] array = {"1","2","3","4","5"};
List<String> list = Arrays.asList(array);
//但是转换为List后，不能在增加了。是只读的
}可以增加的话就在自己创建个List
public static void main(String[] args) {
String [] array = {"1","2","3","4","5"};
List<String> list = Arrays.asList(array);
//但是转换为List后，不能在增加了。是只读的’
//要想添加就要复制个,可以直接把另一个List在创建List时直接传入，就相当于复制了一哈
List<String> list2 = new ArrayList(list);
list2.add("6");
System.out.println(list2);
}
集合的排序：
public static void main(String[] args) {
List<Integer> c = new ArrayList();
Random random = new Random();
for(int i=0;i<10;i++){
c.add(random.nextInt(100));
}
System.out.println(c);
//通过Collections这个集合的工具类
//我们可以对List集合进行孜然排序
Collections.sort(c);
System.out.println(c);
}
如果List中的是对象的话，不能用Collections.sort排序，如果用的话要是可以排序的
使用Colletions的sort方法进行排序的集合，要求元素必须实现Comparable接口，只有实现了该接口才认为是可比较的元素
那么就可以让那个对象被实例的类实现接口 Comparable
即：
类 implements Comparable<类（就是这个类，说明和自己比）>{
}这个是比较大小的方法
返回值不关注具体的值，只关注取值范围
返回值<0： 当前对象比给定的对象小
返回值=0： 两个对象相等
返回值>0： 当前对象比给定的对象大
在下面就实现方法 compare(类 o){
在这里可以自己定义比较规划，定义比较什么，规定什么大，什么小。
return 两个值的差
}就是用泛型说明比较的就是自己这个类，然后下面传入的参数也就变成了这个类
实现了接口就可以比较对象的大小了~~~
对于字符串排序的话，按首字母排序，相同看第二个~~
对于汉字的排序的话，按照 Unicode排序的。
如果要让他按我想的排序，就是按字符串长短排序
不能重写~
比较器：
写个类，然后实现接口 Comparator{
public int compare(String o1, String o2){
return o1.length()-o2.length()；
}
}然后在比较之前创建一个比较器，实例化这个类
Comparator com = new 那个类();然后把创建的比较器和list一起传入Collection，调用sort排序方法进行比较，就按自己定义的排序方式来比较
Collections.sort(list,com);
何时使用匿名内部类
当我们需要用到一个实例，而该实例所属的类需要实现一个接口或者继承一个类，并且该实例仅在这里用一次，不会再其他地方使用时，我们就应当选取使用匿名内部类的形式创建实例
例如：
使用比较器
Comparator com = new Comparator(){
public int compare(Object o1,Object o2){
return 0;
}
};还是可以使用泛型
Comparator com = new Comparator<类名>(){
public int compare(类名 o1,类名 o2){
return o1.属性-o2.属性;
}
};
然后Collections.sort(list,com);
