黑马程序员_【总结】_集合框架知识梳理1

集合框架知识梳理1

---------- android培训 、 java培训、期待与您交流！ ---------- 

---------------------------------------------------------------------------------------------------------------------------------------------

 Collection集合框架
-------------------------------------------
1、集合用于储存对象、长度可变、可存储各种类型对象
2、集合中存储的都是对象的引用（地址）
--------------------------------------------
|--Collection  接口 单列集合

|-- List

|-- ArrayList

|-- LindedList

|-- Vector

|-- Set

|-- HeshSet

|-- TreeSet

--------------------------------------------
【0】
List： 可重复、有序。
Set: 不可重复、无序。
【1-1】
ArrayList
本质上，ArrayList是对象引用的一个可变长度数组。
底层： 数据结构。查询快，增删慢，线程不同步
Arrays.asList() 能直接返回一个非八大基本状态的数组。
【1-2】
LiknedList
底层： 链表结果。增删快，查询慢。  Vector升级版
Vector： 其特点就是 枚举 迭代的前身。
跟迭代是极其的相似：

Vector<String> v = new Vector<String>();
v.add("java01");
v.add("java01");
v.add("java01");

Enumeration<String> en = v.elements();
while(en.hasMoreElements()){
	System.out.println(en.nextElement());
}

【1-3】
迭代器
Iterator

for(Iterator<T>it=al.iterator(); it.hasNext(); ){
	System.out.println(it.next());
}

【2-1】
HeshSet
底层： 哈希值
通过 hashCode 方法保证唯一性，当哈希值地址相同时，
会调用equals 方法再次判断
【2-2】
TreeSet
底层： 二叉树，
1、进行操作实现 Comparable 接口 覆盖 compareTo()方法，当主要条件相同时，
比较次要元素，保证运算唯一性的语语句是：compareTo()方法 return 0;
2、当元素不具备比较性或不是需要的比较时，定义一个类实现 Comparator接口
重写 compare()方法。
TreeSet比较方式一

main方法：

	public static void main(String[] args) {
		// Comparable 内部排序【A】
		TreeSet  ts=new TreeSet();
		//Comparator 外部比较器 【B】
		//TreeSet  ts=new TreeSet(new Myc());
		ts.add(new Stu("lisi02",22));
		ts.add(new Stu("lisi007",20));
		ts.add(new Stu("lisi009",19));
		ts.add(new Stu("lisi06",19));
		ts.add(new Stu("lisi06",18));
		ts.add(new Stu("lisi03",18));
		Iterator it=ts.iterator();
		while(it.hasNext()){
			Stu s=(Stu)it.next();
			System.out.println(s);
		}
	}

Comparable 内部实现比较方法：

class Stu implements Comparable{
	String name;
	int age;
	Stu(String name,int age){
		this.name = name;
		this.age = age;
	}
    //覆盖该方法
	public int compareTo(Object o) {
		//1、-1、分别代表 正序、倒序  
		//return -1;
		//也可以自定义--按照名字排序
		if(!(o instanceof Stu)){
			//如果不是该类型则抛出异常
			throw new RuntimeException("，，，");
		}
		Stu s = (Stu)o;
		//主条条件
		int num = this.name.compareTo(s.name);
		if(num==0){
			//基本数据类型不能 compareTo 进行比较
			num = new Integer(this.age).compareTo(new Integer(this.age));  
		}
		return num;
	}
	public String toString(){
		return name +"---"+age;
	}	
}

Comparator 外部 自定义比较器：

class Myc implements Comparator{
	//覆盖
	public int compare(Object o1, Object o2) {
		Stu s1 = (Stu) o1;
		Stu s2 = (Stu) o2;
		//主条件
		int num = s1.name.compareTo(s2.name);
		if(num==0){
			//次条件
			num = new Integer(s1.age).compareTo(new Integer(s2.age));
		}
		return num;
	}	
}//<span style="white-space:pre">		</span>int num = s1.name.compareTo(s2.name); 
//<span style="white-space:pre">		</span>return num==0?new Integer(s1.age).compareTo(new Integer(s2.age)):num;   写法2

【3】对比 List  和 Set    集合。

class Person{
	String name;
	int age;
	Person(String name,int age){
		this.name = name;
		this.age = age;
	}
	public String toString(){
		return name+">>"+age;
	}
}
public class CollectionTest{
	public static void main(String [] args){
		ArrayList<Person> al = new ArrayList<Person> ();
		al.add(new Person("li01",19));
		al.add(new Person("li01",19));
		al.add(new Person("li02",20));
		
		// 迭代器--方式一   不能add 、remove
		for(Iterator<Person> it = al.iterator(); it.hasNext() ; ){
			System.out.println(it.next());
		}
		System.out.println("---------------------");
		//ListIterator  迭代时，可以  并发交互了。
		for(ListIterator<Person>lit = al.listIterator(); lit.hasNext() ; ){
			Person obj = lit.next();
			if(obj.name.equals("li02")){
				lit.add(new Person("li03",18));
				lit.add(new Person("li03",32));
			}
			if(obj.name.equals("li01")){
				lit.remove();
			}
		}
		// 迭代器--方式二
		Iterator<Person> it = al.iterator();
		while(it.hasNext()){
			System.out.println(it.next()+"...方式二");
		}
		System.out.println("---------------------");
		HashSet<String> hs = new HashSet<String>();
		hs.add("ya01");
		hs.add("ya01");
		hs.add("ya02");
		// 打印 HashSet  集合
		for(String has : hs){
			System.out.println(has+"...");
		}	
	}
}

结论：
1、集合就是一个可变长度的数组
2、List 是可重复的
3、Set  是不可重复的
4、取出方式有1、迭代Iterator   ：for、while两种方式。
    2、高级for
5、ListIterator  可以在迭代时，进行并发交互




111：常见方法
 1、新增：add() 2、清除： clear() 3、是否包含：contains(Object o) 5、是否为空：isEmpty() 
 5：排序：toArray() 7、删除：remove(Object o) 
 8、全部删粗：removeAll(Collection<?> c) 9：长度、个数：size() 

等，具体更详细，要学会查看API


【4】
Generic
泛型的好处：
1、安全。
2、消除强制类型转换
泛型 就是指定一种类型。
其实泛型<>就是用来接收类型的。
当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可
1、
泛型机制 
ArrayList<Person> al = new ArrayList<Person> (); 
迭代器对应：
Iterator<Person> it = al.iterator()


泛型类
泛型类定义的泛型，在整个类中有效
如果被方法使用，那么泛型的对象明确早操作的具体类型后
所有要操作的类型就已经固定了。

class Demo <T> {
	public void show(T t){
		System.out.println("show:"+t);
	}
	public void print(T t){
		System.out.println("print:"+t);
	}
}

泛型方法
为了让不同方法可以操作不同类型，而且类型还不确定
那么可以将泛型定义在方法上。
public void show(T t){    // 随着泛型类的类型走 
System.out.println("show:"+t);
}
//public <T> void print(T t){    这里的t上上面的一样的吗，不是。
public <Q> void print(Q q){      //为了方便阅读，还是写成不一样的。
System.out.println("print:"+q);
}
泛型接口
接口接收位置类型
方法也接收位置类型
主函数 就可以传递任意类型的参数

interface Inter<T>{   //
	void show(T t);
}
class InterImpl<T> implements Inter<T>{
	public void show(T t){
		System.out.print(t);
	}
}
class InterDemo{
	public static void main(String[] args) {
		InterImpl<String> in = new InterImpl();
		InterImpl<Integer> in2 = new InterImpl();
		in.show("haha");
		in2.show(123);
	}
}

主函数 就可以传递任意类型的参数

静态泛型
特殊之处
静态方法不可以访问类上定义的泛型。
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

class Demo3<T> {
	
	//public static <T> void showS(T t){// 报错，不能和非静态类同类型
	//public <T> static  void showS(T t){//报错，书写格式错误
		
	public static <M> void showS(M m){// 静态泛型方法不可为非静态泛型类相同类型，原理很简单，静态先加载，
		System.out.println("print:"+m);
	}
}

【4-1】
泛型的高级引用
<?>  通配符，也可以理解为占位符。
泛型的限定：
<? enteds E>   E 可以接收 E类型或者E的子类型。上限。
<? super  E>   E 可以接收 E类型或者E的父类型。下限。

public class test2 
	{
		public static void main(String[] args) 
		{
			ArrayList<Personp> alp= new ArrayList<Personp> ();
			alp.add(new Personp("wocao01"));
			alp.add(new Personp("wocao02"));
			
			ArrayList<Student> als= new ArrayList<Student> ();
			als.add(new Student("002s"));
			als.add(new Student("003s"));
			
			ArrayList<Pupil> alx= new ArrayList<Pupil> ();
			alx.add(new Pupil("xxx11"));
			alx.add(new Pupil("dd333"));
			
			show(als);
			show(alp);
			show(alx);
			showX(als);
			showX(alp);
			//showX(alx);  //【P】
		}
		public static void show(ArrayList<? extends Personp> al){
			for(Iterator<? extends Personp> it=al.iterator();it.hasNext(); ){
				System.out.println(it.next().getName());
			}
		}
		public static void showX(ArrayList<? super Student> al){
			for(Iterator<? super Student> it=al.iterator();it.hasNext(); ){
				//System.out.println(it.next().getName());//编译不通过
				System.out.println(it.next());
			}
		}
	}
	class Personp{
		private String name;
		Personp(String name){
			this.name=name;
		}
		public String getName(){
			return name;
		}
		public String toString(){
			return name+"";
		}
	}
	class Student extends Personp{
		Student(String name){
			super(name);
		}
	}
	class Pupil extends Student{
		Pupil(String name){
			super(name);
		}
	}

这个时候 【p】 处就出现了错误。
因为
<? extends Personp> 是 指 Personp  和Personp的子类    Student、Pupil 都是人的子类
<? super Student> 是指Student   和Student 的父类 Pupil是 Student 的子类，所以报错。
再看下面的代码： 继承关系依然用上面的代码。
充分的利用了泛型的限定， TreeSet进行了排序，并简洁了很多代码。

public class test2 {
	public static void main(String[] args) {
		TreeSet<Personp> tp = new TreeSet<Personp>(new Comp());
		tp.add(new Per("fds08"));
		tp.add(new Per("asd07"));
		tp.add(new Per("asd01"));
		TreeSet<Student> ts = new TreeSet<Student>(new Comp());
		ts.add(new Stu("fds----08"));
		ts.add(new Stu("asd---07"));
		ts.add(new Stu("asd---01"));
		TreeSet<Pupil> tx = new TreeSet<Pupil>(new Comp());
		tx.add(new Pul("fds>>>08"));
		tx.add(new Pul("asd>>>07"));
		tx.add(new Pul("asd>>>01"));
		show(tx);
		show(ts);
		show(tp);
	}
	//通过泛型向下限定， 指定了类型的范围。
	public static void show(TreeSet<? extends Personp> ts){
		for(Iterator<? extends Personp> it = ts.iterator(); it.hasNext(); ){
			System.out.println(it.next().getName());
		}
	}
}
//不用在依次设定比较器，泛型设定为父类， 让比较器通用了。
class Comp implements Comparator<Personp>{
	public int compare(Personp p1,Personp p2){
		return p1.getName().compareTo(p2.getName());
	}
}

通过对 比较器的 泛型限定，父类， 使其具备了通用性，但是局限于父类以及父类子类。

---------------------------------------------------------------------------------------------------------------------------------------------

---------- android培训、 java培训、期待与您交流！----------

黑马官网