黑马程序员学习日记--javaAPI（二）
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------一：集合框架
集合类
特点：集合可用于存储对象，集合长度是可变的，集合可以存储不同类型的对象
每一个容器对数据的存储方式都有不同，这个存储方式称之为数据结构。
add方法的参数类型是Object，以便于接受任意类型对象。
集合中存储的都是对象的引用。
集合中的常见方法：
添加：
boolean add(Object obj);
boolean addAll(Collection coll)
删除：
boolean remove(Object obj)
boolean removeAll(Collection coll)
void clear()
判断：
boolean contains(Object obj)
boolean containsAll(Collection coll)
boolean isEmpty()
获取：
int size();
Iterator iterator()
其他：
boolean retainAll(Collection coll):取交集
Object toArray()
迭代器：集合取出元素的方式
Collection：
List：元素是有序的，元素可以重复，因为该集合体系有索引
set：元素是无序的，元素不可以重复
List特有方法：
增：add（index，element）
addAll（index，Collection）
删：remove（index）
改：set （index，element）
查：get（index）
sublist（from,to）
listIterator()
int indexOf(Object)
int lastIndexOf(Object)
ListIterator:List集合特有的迭代器，Itarator的子接口
ArrayList:底层的数据结构是使用的是数组结构，线程不同步
特点：查询很快，增删稍慢
LinkedList：底层使用的是链表数据结构
他点：增删很快，查询稍慢
Vector：底层是数组数据结构，线层同步
练习代码：
import java.util.*;
class J14_1
{
public static void main(String[] args)
{
ArrayList a = new ArrayList();
a.add("java01");
a.add("java02");
a.add("java03");
a.add("java04");
/*
Iterator i = a.iterator();
while(i.hasNext())
sop(i.next());
*/
for(Iterator i = a.iterator();i.hasNext();)
sop(i.next());
/*
ArrayList b = new ArrayList();
b.add("java01");
b.add("java02");
b.add("java05");
b.add("java06");
*/
//a.retainAll(b);
//a.removeAll(b);
//a.addAll(b);
//sop(a);
//sop(b);
//sop("size="+a.size());
//sop(a);
//a.remove("java02");
//sop(a);
//a.clear();
//sop("是否为空："+a.isEmpty());
//sop("java03是否存在："+a.contains("java03"));
}
static void sop(Object obj)
{
System.out.println(obj);
}
}
LinkedList特有方法：
addFirst() getFirst() removeFirst()
addLast() getLast() removeLast()
堆栈：先进后出
队列：先进先出 First In First Out
List集合判断元素是否相同，依据是元素的equals方法
练习代码：
import java.util.*;
class J14_3
{
public static void main(String[] args)
{
LinkedList ls = new LinkedList();
ls.addLast("java01");
ls.addLast("java02");
ls.addLast("java03");
ls.addLast("java04");
sop(ls);
//sop(ls.getFirst());
//sop(ls.getLast());
//sop(ls.removeFirst());
while(!ls.isEmpty())
sop(ls.removeFirst());
sop("size="+ls.size());
}
static void sop(Object obj)
{
System.out.println(obj);
}
}
Set：元素是无序的，元素不可以重复
Set集合的功能和Collection是一致的
|--HashSet：底层数据结构是哈希表，线程是不同步的
|--TreeSet：可以对Set集合中的元素进行排序
HashSet元素的唯一性：通过元素的两个方法：hashCode和equals来完成
练习代码：
import java.util.*;
class J14_7
{
public static void main(String[] args)
{
HashSet hs = new HashSet();
sop(hs.add("java03"));
hs.add("java04");
hs.add("java01");
hs.add("java02");
hs.add("java05");
sop(hs.add("java03"));
hs.add("java04");
Iterator it = hs.iterator();
while(it.hasNext())
sop(it.next());
}
static void sop(Object obj)
{
System.out.println(obj);
}
}
class Demo
{
public int hashCode()
{
return 60;
}
}
public interface Comparable:
此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为他的自然比较方法。
TreeSet：底层数据结构是二叉树
保证元素唯一性的依据：compareTo方法return 0
TreeSet排序的第一种方式：让元素自身具备比较性。元素需要实现Comparable接口。覆盖compareTo方法。
TreeSet的第二种排序方式：当元素自身不具备比较性时，或者具备的比较性不是所需要的，这时就需要让集合自身具备比较性
代码示例：
import java.util.*;
class J15_1
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet(new MyComparator());
ts.add(new Student("lisi02",22));
ts.add(new Student("lisi05",25));
ts.add(new Student("lisi04",18));
ts.add(new Student("lisi03",18));
ts.add(new Student("lisi03",19));
for(Iterator it = ts.iterator();it.hasNext();)
{
Student p = (Student)it.next();
sop(p.getName()+"..."+p.getAge());
}
}
static void sop(Object obj)
{
System.out.println(obj);
}
}
class Student implements Comparable
{
private String name;
private int age;
Student(String name,int age)
{
this.name = name;
this.age = age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public int compareTo(Object obj)
{
if(!(obj instanceof Student))
throw new RuntimeException("不是学生对象");
Student p = (Student)obj;
System.out.println(this.name+"..equals.."+p.name);
if(this.age>p.age)
return 1;
if(this.ages2.getAge())
return 1;
if(s1.getAge() 二：泛型
JDK1.5版本以后出现的新特性，用于解决安全问题，是一个类型安全机制。
好处：
将运行时期出现问题转移到编译时期，避免了强制转换的麻烦
泛型格式：
通过<>来定义要操作的引用数据类型（长见于集合框架）
泛型类：当类中要操作的引用数据类型不确定的时候使用
泛型方法：为了让不同方法可以操作不同类型，而且类型不确定，可以将泛型定义在方法上。
（静态方法不可以访问类上定义的泛型）
？通配符，也可以理解为占位符
泛型的限定：
？ extends E：可以接受E类型或者E的子类型（上限）
？ super E：可以接受E类型或者E的符类型（下限）
练习代码：
class J15_4
{
public static void main(String[] args)
{
/*
Tool t = new Tool();
t.setObj(new Worker());
Worker w = (Worker)t.getObj();
Utils u = new Utils();
u.setObj(new Worker());
Worker w =u.getObj();
Demo d = new Demo();
d.show("haha");
d.print(7);
d.print("java");
Demo.method("china");
Demo.method(5);
*/
InterImp i = new InterImp();
i.show(4);
}
}
interface Inter
{
public abstract void show(T t);
}
class InterImp implements Inter
{
public void show(T s)
{
System.out.println("show:"+s);
}
}
/*
class InterImp implements Inter
{
public void show(String s)
{
System.out.println("show:"+s);
}
}
*/
class Demo
{
public void show(T t)
{
System.out.println("show:"+t);
}
public void print(Q t)
{
System.out.println("print:"+t);
}
public static void method(Q q)
{
System.out.println("method:"+q);
}
}
class Student
{
}
class Worker
{
}
class Tool
{
private Object obj;
public void setObj(Object obj)
{
this.obj = obj;
}
public Object getObj()
{
return obj;
}
}
class Utils
{
private T obj;
public void setObj(T obj)
{
this.obj = obj;
}
public T getObj()
{
return obj;
}
}
三：Map
|--Hashtable：底层是哈希表数据结构，不可以存入null键null值，线程同步。
|--HashMap：底层是哈希表数据结构，允许使用null键null值，线程不同步。
|--TreeMap：底层是二叉树数据结构，线层不同步。可用于给Map集合中的键进行排序
keySet：将map中所有的键存入到Set集合中
Map集合的取出原理：将Map集合转成Set集合，在通过迭代的方式取出
Set
Map.Entry：Entry也是一个接口，他是Map接口中的一个内部接口
代码示例：
import java.util.*;
class J15_7
{
public static void main(String[] args)
{
Map m = new HashMap ();
m.put(new Student("hoop01",11),"beijing");
m.put(new Student("hoop01",11),"tianjing");
m.put(new Student("hoop02",12),"shanghai");
m.put(new Student("hoop03",13),"guangzhou");
m.put(new Student("hoop04",14),"shenzhen");
//第一种方式
Set s = m.keySet();
Iterator it = s.iterator();
while(it.hasNext())
{
Student st = it.next();
System.out.println(st+"..."+m.get(st));
}
//第二种方式
Set> set = m.entrySet();
Iterator> iter = set.iterator();
while(iter.hasNext())
{
Map.Entry me = iter.next();
Student stu = me.getKey();
String addr = me.getValue();
System.out.println(stu+"........."+addr);
}
}
}
class Student implements Comparable
{
private String name;
private int age;
Student(String name,int age)
{
this.name = name;
this.age = age;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
public String toString()
{
return name+":"+age;
}
public int hashCode()
{
return name.hashCode()+age*39;
}
public boolean equals(Object obj)
{
if(!(obj instanceof Student))
throw new ClassCastException();
Student s = (Student) obj;
return this.name.equals(s.getName())&&this.age==s.getAge();
}
public int compareTo(Student s)
{
int num = new Integer(this.getAge()).compareTo(new Integer(s.getAge()));
if(num==0)
return this.name.compareTo(s.getName());
return num;
}
}