2015-4-16
一、List集合
1、List集合特有方法
特有方法：
voidadd(int index, E element) ： 在当前集合中指定位置 添加给定的元素
Objectget(int index) 返回集合中指定位置的元素。
intindexOf(Object o)返回此集合中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。
Eremove(int index)移除列表中指定位置的元素（可选操作）。
Eset(int index, E element)用指定元素替换列表中指定位置的元素
ListIterator<E>listIterator() 返回此列表元素的列表迭代器（按适当顺序）。
2、int indexOf(Object o)
3、添加新元素
普通for：
添加的新元素在原有集合是末尾
List Iterator (迭代器)：
插在找到元素的后面
4、常见数据结构
常见的数据结构：链表、栈、队列、树、数组、哈希表
特点：
栈：先进后出，（如：弹夹）
队列：先进先出（如：排队购票）
数组：长度固定，可通过索引获取元素，增删慢，查找快。
数组内添加新元素步骤图：
链表：增删快，查找慢
将多个节点链接起来
节点：有指针域与数据域组成
指针域：就是用来存储地址的
数据域：就是用来存储数据的
5、List与vector、LinkList的性能优劣
ArrayList：
底层：数组结构，增删慢，查询快
线程不同步，效率高，不安全
Vector：
底层：数组结构，增删慢，查询快
线程同步，效率低，安全
LinkedList：
底层：链表结构，增删快，查询慢
线程不同步，效率高，不安全
二、Vector集合
1、Vector集合概述
底层数据结构是数组，查询快，增删慢
线程安全，效率低
2、Vector集合特有方法
public void addElement(Eobj)
public E elementAt(intindex)
public Enumerationelements()
三、LinkList集合
1、概述
底层数据结构是链表，查询慢，增删快
线程不安全，效率高
2、特有方法
public void addFirst(Object e)将指定元素插入此列表的开头
public void addLast(Objecte)将指定元素添加到此列表的结尾。
public Object getFirst()返回此列表的第一个元素
public Object getLast()返回此列表的最后一个元素。
public Object removeFirst()移除并返回此列表的第一个元素。
public Object removeLast()移除并返回此列表的最后一个元素。
四、ArrayList集合
1、概述
略。
2、举例
例子一：选择排序算法
方式一：创建新集合的方式
a：创建新集合
b：遍历原有集合，得到每一个元素
c：判断当前元素在新集合是否存在
存在：
不进
不存在：
当前元素存储进来
代码如下：
ArrayList list = newArrayList();
list.add("Java");
list.add("HTML");
list.add("CSS");
list.add("CSS");
list.add("CSS");
list.add("JavaScript");
//控制比较的次数
for (int i = 0; i< list.size()-1; i++) {
//控制比较的元素
for (intj = i+1; j < list.size(); j++) {
//list.get(i) 和 list.get(j)
//判断当前两个元素的值，是否相同，如果相同，删除后面的元素
if(list.get(i).equals(list.get(j))) {
//删除后面元素
list.remove(j);
j--;
}
}
}
//显示结果
System.out.println(list);方式二：选择排序剔除重复元素
ArrayList list =new ArrayList();
list.add("Java");
list.add("HTML");
list.add("CSS");
list.add("CSS");
list.add("CSS");
list.add("JavaScript");
//控制比较的次数
for (int i = 0; i< list.size()-1; i++) {
//控制比较的元素
for (intj = i+1; j < list.size(); j++) {
//list.get(i) 和 list.get(j)
//判断当前两个元素的值，是否相同，如果相同，删除后面的元素
if(list.get(i).equals(list.get(j))) {
//删除后面元素
list.remove(j);
j--;
}
}
}
//显示结果
System.out.println(list);例子二：把一个新字符串中旧字符串里没有的字符串添加到旧字符串
ArrayList
去除集合中自定义对象的重复值(对象的内容相同) 需要重写equals方法
分析：
1：已有一个集合
2: 创建新集合
3: 遍历原有集合，得到每一个元素
4: 判断当前元素在新集合中是否存在
不存在，添加到新集合
//1：已有一个集合
ArrayList list =new ArrayList();
//添加元素
list.add(newTeacher("苍老师", 28));
list.add(newTeacher("陈老师", 29));
list.add(newTeacher("陈老师", 29));
list.add(newTeacher("陈老师", 29));
list.add(newTeacher("冠希老师", 30));
list.add(newTeacher("冠希老师", 30));
list.add(newTeacher("冠希老师", 30));
list.add(newTeacher("冠希老师", 30));
//2: 创建新集合
ArrayList newList= new ArrayList();
//3: 遍历原有集合，得到每一个元素
for (int i=0;i<list.size(); i++) {
Teachert = (Teacher)list.get(i);
//判断当前对象，在新集合中是否存在
if(!newList.contains(t)) {
newList.add(t);
}
}
//打印新集合结果：
for (int i = 0; i< newList.size(); i++) {
Teachert = (Teacher)newList.get(i);
System.out.println(t.getName()+ "---" + t.getAge());
}例子三：栈集合的实现（Java中有Stack类）
压栈：Push（）
出栈：Pop（）
是否为空：IsEmpty（）
实现栈的基本方法：
//用LinkedList模拟栈数据结构的集合
private LinkedList list =new LinkedList();
//入栈
public void push(Objectobj){
list.addFirst(obj);
}
//弹栈
public Object pop(){
returnlist.removeFirst();
}
//判断栈是否为空
public boolean isEmpty(){
returnlist.size() == 0;
}五、泛型
1、概述
泛型是一种特殊的类型，它把指定类型的工作推迟到客户端代码声明并实例化类或方法
的时候进行。
也被称为参数化类型，可以把类型当作参数一样传递过来，在传递过来之前我不明确，但
是在使用的时候我就用明确了。
泛型的由来：通过案例引入
早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的
问题。也就存在这隐患，所以Java提供了泛型来解决这个安全问题。
2、泛型的好处：
提高了程序的安全性
将运行期遇到的问题转移到了编译期
省去了类型强转的麻烦
3、在哪里使用泛型
接口上使用泛型
类上使用泛型
方法上使用泛型
4、使用与不使用泛型的区别：
ArrayListlist = new ArrayList();
list.add("A");
list.add("B");
list.add("C");
//list.add(123);//类型转换异常，Integer 不能转换成 String类型
for(int i = 0; i < list.size(); i++) {
Strings = (String)list.get(i);
System.out.println(s);
}
System.out.println("-------------------");
//泛型版本
ArrayList<String>list2 = new ArrayList<String>();
list2.add("A1");
list2.add("B1");
list2.add("C1");
//list2.add(123);
for(int i = 0; i < list2.size(); i++) {
Strings = list2.get(i);
System.out.println(s);
}5、泛型应用在类、方法上
定义在类上：
说明：<QQ> 定义一个泛型
QQ 使用当前这个泛型，这个QQ在程序运行时，会对应一个具体的数据类型
//Testt = new Test();
Test<String>t = new Test<String>();
t.setName("哈哈");
System.out.println(t.getName() );
Test<Integer>t2 = new Test<Integer>();
t2.setName(123);
System.out.println(t2.getName() );
定义在方法上：
//普通方法
publicString method(String str){
returnstr + "哈哈";
}
//泛型方法
publicK function(K str){
returnstr;
}
//泛型方法
public<TT> TT show(TT str) {
returnstr;
}、泛型同时应用在类上、方法时：（此时可以使用类上的泛型，也可使用方法上的泛型）
K的类型是在创建对象的时候 确定的
TT类型是在调用方法的时候 确定的
这里的K,TT 理解为 是一种数据类型的变量名
注意：创建多个泛型类对象的时候，可以赋值不同的泛型类型，不会产生冲突
泛型接口：
把泛型定义在接口上
格式:public interface 接口名<泛型类型1…>
publicinterface Inter<TT> {
public TT show(TT str);
}
方式一：在编写类时就实现泛型接口
定义类的时候就确定了泛型的数据类型
方式二：创建对象的时候，确定泛型数据类型
接口实现的第一种方式：定义类时就确定了泛型的数据类型
代码如下：
publicclass InterImpl<QQ> implements Inter<QQ>{
@Override
public QQ show(QQ str) {
returnstr;
}
}创建对象实例：
//方式1
InterImplimpl = new InterImpl();
Stringstr = impl.show("haha");
System.out.println(str);接口实现的第二种方式：创建对象时，才确定了泛型的数据类型
public class InterImpl<QQ> implements Inter<QQ>{
@Override
public QQ show(QQ str) {
returnstr;
}
}创建对象实例：
//方式2
InterImpl<String>impl = new InterImpl<String>();
Stringstr = impl.show("hehe");
System.out.println(str);6、泛型的通配符
泛型的数据类型：要求左右两边一致。
泛型通配符<?>
任意类型，如果没有明确，那么就是Object以及任意的Java类了
?extends E
向上限定，E及其子类
?代表了 可以是E所对应的数据类型，或者是E的子类类型
例如：
？ extends Animal
? 代表了 Animal类型，或者Animal子类类型
?super E
向下限定，E及其父类
?代表了 可以使 E所对应的数据类型，或者是E的父类类型
例如：
? super Dog
? 代表的是 Dog类型，或者是Dog的父类类型
具体实现举例：
//泛型的数据类型要求左右一致
//Collection<Object>coll = new ArrayList<Animal>(); //错误
//Collection<Animal>coll = new ArrayList<Dog>();//错误
Collection<?>c1 = new ArrayList<Animal>();
Collection<?>c2 = new ArrayList<Dog>();
Collection<?>c3 = new ArrayList<Cat>();
Collection<?>c4 = new ArrayList<Object>();六、增强for循环
1、增强for概述
jdk1.5出现的新特性
简化数组和Collection集合的遍历
格式：
for(元素数据类型变量 : 数组或者Collection集合) {
使用变量即可，该变量就是元素
}
好处：简化遍历
注意事项：增强for的目标要判断是否为null
把前面的集合代码的遍历用增强for改进
注意：
如果需要使用索引，请使用传统for
如果不需要使用索引，推荐是使用增强for(), 也可以使用迭代器
举例：
int[]arr = {1,2,3,4,5};
//传统for循环
for(int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
System.out.println("---------------");
//增强for循环
for(int j : arr) {
System.out.println(j);
}注意：jdk7新特性，菱形泛型：
ArrayList<String>list = new ArrayList<>();
jdk5、jdk6不能用此方法，而公司里多是用这两个版本的jdk，因为它们稳定。
2、案例：
案例一：使用ArrayList集合存储多个字符串对象，并遍历（加泛型，用增强for）
list.add("A");
list.add("B");
list.add("C");
for(String s : list) {
System.out.println(s);
}案例二：使用ArrayList集合存储多个自定义对象，并遍历（泛型，增强for）
ArrayList<Person>list = new ArrayList<Person>();
list.add(newPerson("赵日天"));
list.add(newPerson("啦啦"));
list.add(newPerson("哈哈"));
for(Personp : list) {
System.out.println(p.getName());
}
